@elizaos/plugin-bluesky 2.0.0-alpha.1

package/dist/cjs/index.node.cjs

@@ -0,0 +1,741 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// index.node.ts
+var exports_index_node = {};
+__export(exports_index_node, {
+  default: () => typescript_default,
+  blueSkyPlugin: () => blueSkyPlugin,
+  BlueSkyService: () => BlueSkyService,
+  BlueSkyClient: () => BlueSkyClient
+});
+module.exports = __toCommonJS(exports_index_node);
+
+// index.ts
+var import_core6 = require("@elizaos/core");
+
+// services/bluesky.ts
+var import_core5 = require("@elizaos/core");
+
+// client.ts
+var import_api = require("@atproto/api");
+var import_core = require("@elizaos/core");
+var import_lru_cache = require("lru-cache");
+
+// types/index.ts
+var import_zod = require("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 = import_zod.z.object({
+  handle: import_zod.z.string().regex(AT_PROTOCOL_HANDLE_REGEX, "Invalid handle format"),
+  password: import_zod.z.string().min(1),
+  service: import_zod.z.string().url().default(BLUESKY_SERVICE_URL),
+  dryRun: import_zod.z.boolean().default(false),
+  pollInterval: import_zod.z.number().positive().default(BLUESKY_POLL_INTERVAL),
+  enablePost: import_zod.z.boolean().default(true),
+  postIntervalMin: import_zod.z.number().positive().default(BLUESKY_POST_INTERVAL_MIN),
+  postIntervalMax: import_zod.z.number().positive().default(BLUESKY_POST_INTERVAL_MAX),
+  enableActionProcessing: import_zod.z.boolean().default(true),
+  actionInterval: import_zod.z.number().positive().default(BLUESKY_ACTION_INTERVAL),
+  postImmediately: import_zod.z.boolean().default(false),
+  maxActionsProcessing: import_zod.z.number().positive().default(BLUESKY_MAX_ACTIONS),
+  enableDMs: import_zod.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 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 import_api.BskyAgent({ service: config.service });
+    this.profileCache = new import_lru_cache.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
+    };
+    import_core.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) => ({
+        post: adaptPostView(item.post),
+        reply: item.reply && isPostView(item.reply.root) && isPostView(item.reply.parent) ? {
+          root: adaptPostView(item.reply.root),
+          parent: adaptPostView(item.reply.parent)
+        } : undefined,
+        reason: item.reason
+      }))
+    };
+  }
+  async sendPost(request) {
+    if (this.config.dryRun) {
+      import_core.logger.info(`Dry run: would create post with text: ${request.content.text}`);
+      return this.mockPost(request.content.text);
+    }
+    const rt = new import_api.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) {
+      import_core.logger.info(`Dry run: would delete post: ${uri}`);
+      return;
+    }
+    await this.agent.deletePost(uri);
+  }
+  async likePost(uri, cid) {
+    if (this.config.dryRun) {
+      import_core.logger.info(`Dry run: would like post: ${uri}`);
+      return;
+    }
+    await this.agent.like(uri, cid);
+  }
+  async repost(uri, cid) {
+    if (this.config.dryRun) {
+      import_core.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) {
+      import_core.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
+var import_core2 = require("@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();
+    }
+    import_core2.logger.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();
+    import_core2.logger.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
+var import_core3 = require("@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 = import_core3.composePrompt({
+      state: {},
+      template: generateDmTemplate
+    });
+    const response = await this.runtime.useModel(import_core3.ModelType.TEXT_SMALL, {
+      prompt,
+      maxTokens: 50
+    });
+    return response;
+  }
+}
+
+// services/post.ts
+var import_core4 = require("@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 = import_core4.composePrompt({
+      state: {
+        maxLength: String(BLUESKY_MAX_POST_LENGTH)
+      },
+      template: generatePostTemplate
+    });
+    const response = await this.runtime.useModel(import_core4.ModelType.TEXT_SMALL, {
+      prompt,
+      maxTokens: 100
+    });
+    return response;
+  }
+  async truncate(text) {
+    const prompt = import_core4.composePrompt({
+      state: {
+        maxLength: String(BLUESKY_MAX_POST_LENGTH),
+        text
+      },
+      template: truncatePostTemplate
+    });
+    const response = await this.runtime.useModel(import_core4.ModelType.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 import_core5.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();
+    import_core5.logger.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);
+    import_core5.logger.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");
+          }
+          import_core6.logger.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) {
+            import_core6.logger.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");
+          }
+          import_core6.logger.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) {
+    import_core6.logger.log("BlueSky plugin initialized");
+  },
+  services: [BlueSkyService],
+  tests: pluginTests
+};
+var typescript_default = blueSkyPlugin;
+
+//# debugId=8563B0C8EA46B71664756E2164756E21