@elizaos/plugin-bluesky 2.0.0-alpha.7 → 2.0.11-beta.7

package/dist/node/index.node.js

@@ -1,715 +0,0 @@
-// index.ts
-import { logger as logger4 } from "@elizaos/core";
-
-// services/bluesky.ts
-import { logger as logger3, Service } from "@elizaos/core";
-
-// client.ts
-import { BskyAgent, RichText } from "@atproto/api";
-import { logger } from "@elizaos/core";
-import { LRUCache } from "lru-cache";
-
-// types/index.ts
-import { z } from "zod";
-var BLUESKY_SERVICE_URL = "https://bsky.social";
-var BLUESKY_MAX_POST_LENGTH = 300;
-var BLUESKY_POLL_INTERVAL = 60;
-var BLUESKY_POST_INTERVAL_MIN = 1800;
-var BLUESKY_POST_INTERVAL_MAX = 3600;
-var BLUESKY_ACTION_INTERVAL = 120;
-var BLUESKY_MAX_ACTIONS = 5;
-var BLUESKY_CHAT_SERVICE_DID = "did:web:api.bsky.chat";
-var BLUESKY_SERVICE_NAME = "bluesky";
-var AT_PROTOCOL_HANDLE_REGEX = /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/;
-var CACHE_TTL = {
-  PROFILE: 3600000,
-  TIMELINE: 300000,
-  POST: 1800000,
-  NOTIFICATIONS: 300000,
-  CONVERSATIONS: 300000
-};
-var CACHE_SIZE = {
-  PROFILE: 1000,
-  TIMELINE: 500,
-  POST: 1e4,
-  NOTIFICATIONS: 1000,
-  CONVERSATIONS: 100
-};
-var BlueSkyConfigSchema = z.object({
-  handle: z.string().regex(AT_PROTOCOL_HANDLE_REGEX, "Invalid handle format"),
-  password: z.string().min(1),
-  service: z.string().url().default(BLUESKY_SERVICE_URL),
-  dryRun: z.boolean().default(false),
-  pollInterval: z.number().positive().default(BLUESKY_POLL_INTERVAL),
-  enablePost: z.boolean().default(true),
-  postIntervalMin: z.number().positive().default(BLUESKY_POST_INTERVAL_MIN),
-  postIntervalMax: z.number().positive().default(BLUESKY_POST_INTERVAL_MAX),
-  enableActionProcessing: z.boolean().default(true),
-  actionInterval: z.number().positive().default(BLUESKY_ACTION_INTERVAL),
-  postImmediately: z.boolean().default(false),
-  maxActionsProcessing: z.number().positive().default(BLUESKY_MAX_ACTIONS),
-  enableDMs: z.boolean().default(true)
-});
-
-class BlueSkyError extends Error {
-  code;
-  status;
-  constructor(message, code, status) {
-    super(message);
-    this.code = code;
-    this.status = status;
-    this.name = "BlueSkyError";
-  }
-}
-
-// client.ts
-function isPostView(item) {
-  return typeof item === "object" && item !== null && "uri" in item && "cid" in item && "author" in item && "record" in item && "indexedAt" in item && typeof item.uri === "string" && typeof item.cid === "string";
-}
-function isReplyWithPostViews(reply) {
-  return typeof reply === "object" && reply !== null && "root" in reply && "parent" in reply && isPostView(reply.root) && isPostView(reply.parent);
-}
-function adaptPostView(postView) {
-  const author = postView.author;
-  const record = postView.record;
-  return {
-    uri: postView.uri,
-    cid: postView.cid,
-    author: {
-      did: author.did,
-      handle: author.handle,
-      displayName: author.displayName,
-      description: author.description,
-      avatar: author.avatar,
-      banner: author.banner,
-      followersCount: author.followersCount,
-      followsCount: author.followsCount,
-      postsCount: author.postsCount,
-      indexedAt: author.indexedAt,
-      createdAt: author.createdAt
-    },
-    record: {
-      $type: record.$type ?? "app.bsky.feed.post",
-      text: record.text ?? "",
-      facets: record.facets,
-      embed: record.embed,
-      createdAt: record.createdAt ?? ""
-    },
-    embed: postView.embed,
-    replyCount: postView.replyCount,
-    repostCount: postView.repostCount,
-    likeCount: postView.likeCount,
-    quoteCount: postView.quoteCount,
-    indexedAt: postView.indexedAt
-  };
-}
-
-class BlueSkyClient {
-  config;
-  agent;
-  session = null;
-  profileCache;
-  constructor(config) {
-    this.config = config;
-    this.agent = new BskyAgent({ service: config.service });
-    this.profileCache = new LRUCache({
-      max: CACHE_SIZE.PROFILE,
-      ttl: CACHE_TTL.PROFILE
-    });
-  }
-  async authenticate() {
-    const response = await this.agent.login({
-      identifier: this.config.handle,
-      password: this.config.password
-    });
-    if (!response.success) {
-      throw new BlueSkyError("Authentication failed", "AUTH_FAILED");
-    }
-    this.session = {
-      did: response.data.did,
-      handle: response.data.handle,
-      email: response.data.email,
-      accessJwt: response.data.accessJwt,
-      refreshJwt: response.data.refreshJwt
-    };
-    logger.info(`Authenticated with BlueSky: ${this.session.handle}`);
-    return this.session;
-  }
-  getSession() {
-    return this.session;
-  }
-  async getProfile(handle) {
-    const cached = this.profileCache.get(handle);
-    if (cached)
-      return cached;
-    const response = await this.agent.getProfile({ actor: handle });
-    const profile = {
-      did: response.data.did,
-      handle: response.data.handle,
-      displayName: response.data.displayName,
-      description: response.data.description,
-      avatar: response.data.avatar,
-      banner: response.data.banner,
-      followersCount: response.data.followersCount,
-      followsCount: response.data.followsCount,
-      postsCount: response.data.postsCount,
-      indexedAt: response.data.indexedAt,
-      createdAt: response.data.createdAt
-    };
-    this.profileCache.set(handle, profile);
-    return profile;
-  }
-  async getTimeline(params = {}) {
-    const response = await this.agent.getTimeline({
-      algorithm: params.algorithm,
-      limit: params.limit ?? 50,
-      cursor: params.cursor
-    });
-    return {
-      cursor: response.data.cursor,
-      feed: response.data.feed.map((item) => {
-        const reply = isReplyWithPostViews(item.reply) ? {
-          root: adaptPostView(item.reply.root),
-          parent: adaptPostView(item.reply.parent)
-        } : undefined;
-        return {
-          post: adaptPostView(item.post),
-          reply,
-          reason: item.reason
-        };
-      })
-    };
-  }
-  async sendPost(request) {
-    if (this.config.dryRun) {
-      logger.info(`Dry run: would create post with text: ${request.content.text}`);
-      return this.mockPost(request.content.text);
-    }
-    const rt = new RichText({ text: request.content.text });
-    await rt.detectFacets(this.agent);
-    const record = {
-      $type: "app.bsky.feed.post",
-      text: rt.text,
-      facets: rt.facets,
-      createdAt: new Date().toISOString()
-    };
-    if (request.replyTo) {
-      record.reply = { root: request.replyTo, parent: request.replyTo };
-    }
-    if (request.content.embed) {
-      record.embed = request.content.embed;
-    }
-    const response = await this.agent.post(record);
-    const thread = await this.agent.getPostThread({
-      uri: response.uri,
-      depth: 0
-    });
-    if (thread.data.thread.$type !== "app.bsky.feed.defs#threadViewPost") {
-      throw new BlueSkyError("Failed to retrieve created post", "POST_CREATE_FAILED");
-    }
-    const threadViewPost = thread.data.thread;
-    return adaptPostView(threadViewPost.post);
-  }
-  async deletePost(uri) {
-    if (this.config.dryRun) {
-      logger.info(`Dry run: would delete post: ${uri}`);
-      return;
-    }
-    await this.agent.deletePost(uri);
-  }
-  async likePost(uri, cid) {
-    if (this.config.dryRun) {
-      logger.info(`Dry run: would like post: ${uri}`);
-      return;
-    }
-    await this.agent.like(uri, cid);
-  }
-  async repost(uri, cid) {
-    if (this.config.dryRun) {
-      logger.info({ uri }, "Dry run: would repost");
-      return;
-    }
-    await this.agent.repost(uri, cid);
-  }
-  async getNotifications(limit = 50, cursor) {
-    const response = await this.agent.listNotifications({ limit, cursor });
-    return {
-      notifications: response.data.notifications,
-      cursor: response.data.cursor
-    };
-  }
-  async updateSeenNotifications() {
-    await this.agent.updateSeenNotifications();
-  }
-  async getConversations(limit = 50, cursor) {
-    const response = await this.agent.api.chat.bsky.convo.listConvos({ limit, cursor }, { headers: { "atproto-proxy": BLUESKY_CHAT_SERVICE_DID } });
-    return {
-      conversations: response.data.convos,
-      cursor: response.data.cursor
-    };
-  }
-  async getMessages(convoId, limit = 50, cursor) {
-    const response = await this.agent.api.chat.bsky.convo.getMessages({ convoId, limit, cursor }, { headers: { "atproto-proxy": BLUESKY_CHAT_SERVICE_DID } });
-    return {
-      messages: response.data.messages,
-      cursor: response.data.cursor
-    };
-  }
-  async sendMessage(request) {
-    if (this.config.dryRun) {
-      logger.info({ convoId: request.convoId }, "Dry run: would send message");
-      return this.mockMessage(request.message.text ?? "");
-    }
-    const response = await this.agent.api.chat.bsky.convo.sendMessage({
-      convoId: request.convoId,
-      message: { text: request.message.text ?? "" }
-    }, { headers: { "atproto-proxy": BLUESKY_CHAT_SERVICE_DID } });
-    return response.data;
-  }
-  async cleanup() {
-    this.profileCache.clear();
-    this.session = null;
-  }
-  mockPost(text) {
-    const now = new Date().toISOString();
-    return {
-      uri: `mock://post/${Date.now()}`,
-      cid: `mock-cid-${Date.now()}`,
-      author: {
-        did: this.session?.did ?? "did:plc:mock",
-        handle: this.session?.handle ?? "mock.handle"
-      },
-      record: { $type: "app.bsky.feed.post", text, createdAt: now },
-      indexedAt: now
-    };
-  }
-  mockMessage(text) {
-    return {
-      id: `mock-msg-${Date.now()}`,
-      rev: "1",
-      text,
-      sender: { did: this.session?.did ?? "did:plc:mock" },
-      sentAt: new Date().toISOString()
-    };
-  }
-}
-
-// managers/agent.ts
-import { logger as logger2 } from "@elizaos/core";
-
-// utils/config.ts
-function getApiKeyOptional(runtime, key) {
-  const value = runtime.getSetting(key);
-  return typeof value === "string" ? value : undefined;
-}
-function hasBlueSkyEnabled(runtime) {
-  const enabled = runtime.getSetting("BLUESKY_ENABLED");
-  if (enabled)
-    return String(enabled).toLowerCase() === "true";
-  return Boolean(runtime.getSetting("BLUESKY_HANDLE") && runtime.getSetting("BLUESKY_PASSWORD"));
-}
-function validateBlueSkyConfig(runtime) {
-  const result = BlueSkyConfigSchema.safeParse({
-    handle: String(runtime.getSetting("BLUESKY_HANDLE") ?? ""),
-    password: String(runtime.getSetting("BLUESKY_PASSWORD") ?? ""),
-    service: String(runtime.getSetting("BLUESKY_SERVICE") ?? BLUESKY_SERVICE_URL),
-    dryRun: runtime.getSetting("BLUESKY_DRY_RUN") === "true",
-    pollInterval: parseInt(String(runtime.getSetting("BLUESKY_POLL_INTERVAL") ?? ""), 10) || BLUESKY_POLL_INTERVAL,
-    enablePost: runtime.getSetting("BLUESKY_ENABLE_POSTING") !== "false",
-    postIntervalMin: parseInt(String(runtime.getSetting("BLUESKY_POST_INTERVAL_MIN") ?? ""), 10) || BLUESKY_POST_INTERVAL_MIN,
-    postIntervalMax: parseInt(String(runtime.getSetting("BLUESKY_POST_INTERVAL_MAX") ?? ""), 10) || BLUESKY_POST_INTERVAL_MAX,
-    enableActionProcessing: runtime.getSetting("BLUESKY_ENABLE_ACTION_PROCESSING") !== "false",
-    actionInterval: parseInt(String(runtime.getSetting("BLUESKY_ACTION_INTERVAL") ?? ""), 10) || BLUESKY_ACTION_INTERVAL,
-    postImmediately: runtime.getSetting("BLUESKY_POST_IMMEDIATELY") === "true",
-    maxActionsProcessing: parseInt(String(runtime.getSetting("BLUESKY_MAX_ACTIONS_PROCESSING") ?? ""), 10) || BLUESKY_MAX_ACTIONS,
-    enableDMs: runtime.getSetting("BLUESKY_ENABLE_DMS") !== "false"
-  });
-  if (!result.success) {
-    const errors = result.error.errors?.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ") || result.error.toString();
-    throw new Error(`Invalid BlueSky configuration: ${errors}`);
-  }
-  return result.data;
-}
-function getPollInterval(runtime) {
-  const seconds = parseInt(String(runtime.getSetting("BLUESKY_POLL_INTERVAL") ?? ""), 10) || BLUESKY_POLL_INTERVAL;
-  return seconds * 1000;
-}
-function getActionInterval(runtime) {
-  const seconds = parseInt(String(runtime.getSetting("BLUESKY_ACTION_INTERVAL") ?? ""), 10) || BLUESKY_ACTION_INTERVAL;
-  return seconds * 1000;
-}
-function getMaxActionsProcessing(runtime) {
-  return parseInt(String(runtime.getSetting("BLUESKY_MAX_ACTIONS_PROCESSING") ?? ""), 10) || BLUESKY_MAX_ACTIONS;
-}
-function isPostingEnabled(runtime) {
-  return runtime.getSetting("BLUESKY_ENABLE_POSTING") !== "false";
-}
-function shouldPostImmediately(runtime) {
-  return runtime.getSetting("BLUESKY_POST_IMMEDIATELY") === "true";
-}
-function getPostIntervalRange(runtime) {
-  const min = parseInt(String(runtime.getSetting("BLUESKY_POST_INTERVAL_MIN") ?? ""), 10) || BLUESKY_POST_INTERVAL_MIN;
-  const max = parseInt(String(runtime.getSetting("BLUESKY_POST_INTERVAL_MAX") ?? ""), 10) || BLUESKY_POST_INTERVAL_MAX;
-  return { min: min * 1000, max: max * 1000 };
-}
-
-// managers/agent.ts
-class BlueSkyAgentManager {
-  runtime;
-  config;
-  client;
-  pollTimer = null;
-  actionTimer = null;
-  postTimer = null;
-  running = false;
-  lastSeenAt = null;
-  constructor(runtime, config, client) {
-    this.runtime = runtime;
-    this.config = config;
-    this.client = client;
-  }
-  async start() {
-    if (this.running)
-      return;
-    await this.client.authenticate();
-    this.running = true;
-    this.startNotificationPolling();
-    if (this.config.enableActionProcessing) {
-      this.startActionProcessing();
-    }
-    if (isPostingEnabled(this.runtime)) {
-      this.startAutomatedPosting();
-    }
-    logger2.success({ agentId: this.runtime.agentId }, "BlueSky agent manager started");
-  }
-  async stop() {
-    this.running = false;
-    if (this.pollTimer)
-      clearInterval(this.pollTimer);
-    if (this.actionTimer)
-      clearInterval(this.actionTimer);
-    if (this.postTimer)
-      clearTimeout(this.postTimer);
-    this.pollTimer = null;
-    this.actionTimer = null;
-    this.postTimer = null;
-    await this.client.cleanup();
-    logger2.info({ agentId: this.runtime.agentId }, "BlueSky agent manager stopped");
-  }
-  startNotificationPolling() {
-    const interval = getPollInterval(this.runtime);
-    this.pollNotifications();
-    this.pollTimer = setInterval(() => this.pollNotifications(), interval);
-  }
-  async pollNotifications() {
-    if (!this.running)
-      return;
-    const { notifications } = await this.client.getNotifications(50);
-    if (notifications.length === 0)
-      return;
-    const newNotifications = this.lastSeenAt ? notifications.filter((n) => {
-      const lastSeen = this.lastSeenAt;
-      return lastSeen !== null && n.indexedAt > lastSeen;
-    }) : notifications;
-    if (newNotifications.length > 0) {
-      this.lastSeenAt = notifications[0].indexedAt;
-      for (const notification of newNotifications) {
-        this.emitNotificationEvent(notification);
-      }
-      await this.client.updateSeenNotifications();
-    }
-  }
-  emitNotificationEvent(notification) {
-    const eventMap = {
-      mention: "bluesky.mention_received",
-      reply: "bluesky.mention_received",
-      follow: "bluesky.follow_received",
-      like: "bluesky.like_received",
-      repost: "bluesky.repost_received",
-      quote: "bluesky.quote_received"
-    };
-    const event = eventMap[notification.reason];
-    if (event) {
-      const payload = {
-        runtime: this.runtime,
-        source: "bluesky",
-        notification
-      };
-      this.runtime.emitEvent(event, payload);
-    }
-  }
-  startActionProcessing() {
-    const interval = getActionInterval(this.runtime);
-    this.processActions();
-    this.actionTimer = setInterval(() => this.processActions(), interval);
-  }
-  async processActions() {
-    if (!this.running)
-      return;
-    const max = getMaxActionsProcessing(this.runtime);
-    const { notifications } = await this.client.getNotifications(max);
-    for (const notification of notifications) {
-      if (notification.reason === "mention" || notification.reason === "reply") {
-        const payload = {
-          runtime: this.runtime,
-          source: "bluesky",
-          notification
-        };
-        this.runtime.emitEvent("bluesky.should_respond", payload);
-      }
-    }
-  }
-  startAutomatedPosting() {
-    if (shouldPostImmediately(this.runtime)) {
-      this.createAutomatedPost();
-    }
-    this.scheduleNextPost();
-  }
-  scheduleNextPost() {
-    const { min, max } = getPostIntervalRange(this.runtime);
-    const interval = Math.random() * (max - min) + min;
-    this.postTimer = setTimeout(() => {
-      if (this.running) {
-        this.createAutomatedPost();
-        this.scheduleNextPost();
-      }
-    }, interval);
-  }
-  createAutomatedPost() {
-    const payload = {
-      runtime: this.runtime,
-      source: "bluesky",
-      automated: true
-    };
-    this.runtime.emitEvent("bluesky.create_post", payload);
-  }
-}
-
-// services/message.ts
-import { composePrompt, ModelType } from "@elizaos/core";
-
-// generated/prompts/typescript/prompts.ts
-var generateDmTemplate = `Generate a friendly direct message response under 200 characters.`;
-var generatePostTemplate = `Generate an engaging BlueSky post under {{maxLength}} characters.`;
-var truncatePostTemplate = `Shorten to under {{maxLength}} characters: "{{text}}"`;
-
-// services/message.ts
-class BlueSkyMessageService {
-  client;
-  runtime;
-  static serviceType = "IMessageService";
-  constructor(client, runtime) {
-    this.client = client;
-    this.runtime = runtime;
-  }
-  async getMessages(convoId, limit = 50) {
-    const response = await this.client.getMessages(convoId, limit);
-    return response.messages;
-  }
-  async sendMessage(convoId, text) {
-    const messageText = text.trim() || await this.generateReply();
-    return this.client.sendMessage({ convoId, message: { text: messageText } });
-  }
-  async getConversations(limit = 50) {
-    const response = await this.client.getConversations(limit);
-    return response.conversations;
-  }
-  async generateReply() {
-    const prompt = composePrompt({
-      state: {},
-      template: generateDmTemplate
-    });
-    const response = await this.runtime.useModel(ModelType.TEXT_SMALL, {
-      prompt,
-      maxTokens: 50
-    });
-    return response;
-  }
-}
-
-// services/post.ts
-import { composePrompt as composePrompt2, ModelType as ModelType2 } from "@elizaos/core";
-class BlueSkyPostService {
-  client;
-  runtime;
-  static serviceType = "IPostService";
-  constructor(client, runtime) {
-    this.client = client;
-    this.runtime = runtime;
-  }
-  async getPosts(limit = 50, cursor) {
-    const response = await this.client.getTimeline({ limit, cursor });
-    return response.feed.map((item) => item.post);
-  }
-  async createPost(text, replyTo) {
-    let postText = text.trim() || await this.generateContent();
-    if (postText.length > BLUESKY_MAX_POST_LENGTH) {
-      postText = await this.truncate(postText);
-    }
-    const request = {
-      content: { text: postText },
-      replyTo
-    };
-    return this.client.sendPost(request);
-  }
-  async deletePost(uri) {
-    await this.client.deletePost(uri);
-  }
-  async generateContent() {
-    const prompt = composePrompt2({
-      state: {
-        maxLength: String(BLUESKY_MAX_POST_LENGTH)
-      },
-      template: generatePostTemplate
-    });
-    const response = await this.runtime.useModel(ModelType2.TEXT_SMALL, {
-      prompt,
-      maxTokens: 100
-    });
-    return response;
-  }
-  async truncate(text) {
-    const prompt = composePrompt2({
-      state: {
-        maxLength: String(BLUESKY_MAX_POST_LENGTH),
-        text
-      },
-      template: truncatePostTemplate
-    });
-    const response = await this.runtime.useModel(ModelType2.TEXT_SMALL, {
-      prompt,
-      maxTokens: 100
-    });
-    const truncated = response;
-    return truncated.length > BLUESKY_MAX_POST_LENGTH ? `${truncated.substring(0, BLUESKY_MAX_POST_LENGTH - 3)}...` : truncated;
-  }
-}
-
-// services/bluesky.ts
-class BlueSkyService extends Service {
-  static instance;
-  managers = new Map;
-  messageServices = new Map;
-  postServices = new Map;
-  static serviceType = BLUESKY_SERVICE_NAME;
-  capabilityDescription = "Send and receive messages on BlueSky";
-  static getInstance() {
-    BlueSkyService.instance ??= new BlueSkyService;
-    return BlueSkyService.instance;
-  }
-  static async start(runtime) {
-    const service = BlueSkyService.getInstance();
-    if (service.managers.has(runtime.agentId)) {
-      return service;
-    }
-    if (!hasBlueSkyEnabled(runtime)) {
-      return service;
-    }
-    const config = validateBlueSkyConfig(runtime);
-    const client = new BlueSkyClient({
-      service: config.service,
-      handle: config.handle,
-      password: config.password,
-      dryRun: config.dryRun
-    });
-    const manager = new BlueSkyAgentManager(runtime, config, client);
-    service.managers.set(runtime.agentId, manager);
-    service.messageServices.set(runtime.agentId, new BlueSkyMessageService(client, runtime));
-    service.postServices.set(runtime.agentId, new BlueSkyPostService(client, runtime));
-    await manager.start();
-    logger3.success({ agentId: runtime.agentId }, "BlueSky client started");
-    return service;
-  }
-  static async stop(runtime) {
-    const service = BlueSkyService.getInstance();
-    const manager = service.managers.get(runtime.agentId);
-    if (!manager)
-      return;
-    await manager.stop();
-    service.managers.delete(runtime.agentId);
-    service.messageServices.delete(runtime.agentId);
-    service.postServices.delete(runtime.agentId);
-    logger3.info({ agentId: runtime.agentId }, "BlueSky client stopped");
-  }
-  async stop() {
-    for (const manager of this.managers.values()) {
-      await BlueSkyService.stop(manager.runtime);
-    }
-  }
-  getMessageService(agentId) {
-    return this.messageServices.get(agentId);
-  }
-  getPostService(agentId) {
-    return this.postServices.get(agentId);
-  }
-}
-
-// index.ts
-var pluginTests = [
-  {
-    name: "bluesky_plugin_tests",
-    tests: [
-      {
-        name: "bluesky_test_credentials_validation",
-        fn: async (runtime) => {
-          const handle = getApiKeyOptional(runtime, "BLUESKY_HANDLE");
-          const password = getApiKeyOptional(runtime, "BLUESKY_PASSWORD");
-          if (!handle || !password) {
-            throw new Error("BLUESKY_HANDLE and BLUESKY_PASSWORD are not configured");
-          }
-          logger4.log("BlueSky credentials are configured");
-        }
-      },
-      {
-        name: "bluesky_test_service_initialization",
-        fn: async (runtime) => {
-          const handle = getApiKeyOptional(runtime, "BLUESKY_HANDLE");
-          const password = getApiKeyOptional(runtime, "BLUESKY_PASSWORD");
-          if (!handle || !password) {
-            logger4.log("Skipping service initialization test - credentials not configured");
-            return;
-          }
-          const service = await BlueSkyService.start(runtime);
-          if (!service) {
-            throw new Error("Failed to initialize BlueSky service");
-          }
-          logger4.log("BlueSky service initialized successfully");
-        }
-      }
-    ]
-  }
-];
-var blueSkyPlugin = {
-  name: "bluesky",
-  description: "BlueSky client plugin using AT Protocol for social interactions",
-  config: {
-    BLUESKY_HANDLE: process.env.BLUESKY_HANDLE ?? null,
-    BLUESKY_PASSWORD: process.env.BLUESKY_PASSWORD ?? null,
-    BLUESKY_SERVICE: process.env.BLUESKY_SERVICE ?? null,
-    BLUESKY_DRY_RUN: process.env.BLUESKY_DRY_RUN ?? null,
-    BLUESKY_POLL_INTERVAL: process.env.BLUESKY_POLL_INTERVAL ?? null,
-    BLUESKY_ENABLE_POSTING: process.env.BLUESKY_ENABLE_POSTING ?? null,
-    BLUESKY_ENABLE_DMS: process.env.BLUESKY_ENABLE_DMS ?? null,
-    BLUESKY_POST_INTERVAL_MIN: process.env.BLUESKY_POST_INTERVAL_MIN ?? null,
-    BLUESKY_POST_INTERVAL_MAX: process.env.BLUESKY_POST_INTERVAL_MAX ?? null,
-    BLUESKY_ENABLE_ACTION_PROCESSING: process.env.BLUESKY_ENABLE_ACTION_PROCESSING ?? null,
-    BLUESKY_ACTION_INTERVAL: process.env.BLUESKY_ACTION_INTERVAL ?? null,
-    BLUESKY_POST_IMMEDIATELY: process.env.BLUESKY_POST_IMMEDIATELY ?? null,
-    BLUESKY_MAX_ACTIONS_PROCESSING: process.env.BLUESKY_MAX_ACTIONS_PROCESSING ?? null,
-    BLUESKY_MAX_POST_LENGTH: process.env.BLUESKY_MAX_POST_LENGTH ?? null
-  },
-  async init(_config, _runtime) {
-    logger4.log("BlueSky plugin initialized");
-  },
-  services: [BlueSkyService],
-  tests: pluginTests
-};
-var typescript_default = blueSkyPlugin;
-export {
-  typescript_default as default,
-  blueSkyPlugin,
-  BlueSkyService,
-  BlueSkyClient
-};
-
-//# debugId=8E1C17CA465481F364756E2164756E21