cygnet 0.1.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,1350 @@
+// src/core/error.ts
+class BotError extends Error {
+  error;
+  ctx;
+  constructor(error, ctx) {
+    super(`Bot error caused by update (${getUpdateType(ctx.update.envelope)}): ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? { cause: error } : undefined);
+    this.error = error;
+    this.ctx = ctx;
+    this.name = "BotError";
+  }
+}
+
+class SignalError extends Error {
+  statusCode;
+  description;
+  constructor(statusCode, description) {
+    super(`Signal API error ${statusCode}: ${description}`);
+    this.statusCode = statusCode;
+    this.description = description;
+    this.name = "SignalError";
+  }
+}
+function getUpdateType(envelope) {
+  if (envelope.dataMessage)
+    return "dataMessage";
+  if (envelope.syncMessage)
+    return "syncMessage";
+  if (envelope.editMessage)
+    return "editMessage";
+  if (envelope.deleteMessage)
+    return "deleteMessage";
+  if (envelope.receiptMessage)
+    return "receiptMessage";
+  if (envelope.typingMessage)
+    return "typingMessage";
+  if (envelope.callMessage)
+    return "callMessage";
+  return "unknown";
+}
+
+// src/filter.ts
+function matchFilter(ctx, query) {
+  const env = ctx.update.envelope;
+  switch (query) {
+    case "message":
+      return env.dataMessage != null && !env.dataMessage.reaction && env.dataMessage.groupInfo?.type !== "UPDATE";
+    case "message:text":
+      return env.dataMessage != null && !env.dataMessage.reaction && typeof env.dataMessage.message === "string" && env.dataMessage.message.length > 0;
+    case "message:attachments":
+      return env.dataMessage != null && !env.dataMessage.reaction && (env.dataMessage.attachments?.length ?? 0) > 0;
+    case "message:quote":
+      return env.dataMessage != null && !env.dataMessage.reaction && env.dataMessage.quote != null;
+    case "message:reaction":
+      return env.dataMessage != null && env.dataMessage.reaction != null;
+    case "message:group":
+      return env.dataMessage != null && !env.dataMessage.reaction && env.dataMessage.groupInfo != null && env.dataMessage.groupInfo.type !== "UPDATE";
+    case "message:private":
+      return env.dataMessage != null && !env.dataMessage.reaction && env.dataMessage.groupInfo == null;
+    case "group_update":
+      return env.dataMessage != null && env.dataMessage.groupInfo?.type === "UPDATE";
+    case "message:sticker":
+      return env.dataMessage != null && !env.dataMessage.reaction && env.dataMessage.sticker != null;
+    case "edit_message":
+      return env.editMessage != null;
+    case "delete_message":
+      return env.deleteMessage != null;
+    case "receipt":
+      return env.receiptMessage != null;
+    case "typing":
+      return env.typingMessage != null;
+    case "call":
+      return env.callMessage != null;
+    case "sync_message":
+      return env.syncMessage != null;
+    default:
+      return false;
+  }
+}
+
+// src/composer.ts
+function flatten(mw) {
+  return typeof mw === "function" ? mw : (ctx, next) => mw.middleware()(ctx, next);
+}
+function concat(first, then) {
+  return async (ctx, next) => {
+    let called = false;
+    await first(ctx, async () => {
+      if (called)
+        throw new Error("next() called multiple times");
+      called = true;
+      await then(ctx, next);
+    });
+  };
+}
+function run(mw, ctx) {
+  return new Promise((resolve, reject) => {
+    Promise.resolve(mw(ctx, async () => {})).then(() => resolve(), reject);
+  });
+}
+function compose(middlewares) {
+  const fns = middlewares.map(flatten);
+  return fns.reduce(concat, (_ctx, next) => next());
+}
+
+class Composer {
+  #handler;
+  _onForkError = (err) => console.error("[cygnet] Error in forked middleware:", err);
+  constructor(...middleware) {
+    this.#handler = middleware.length > 0 ? compose(middleware) : (_ctx, next) => next();
+  }
+  middleware() {
+    return this.#handler;
+  }
+  use(...middleware) {
+    const mw = compose(middleware);
+    this.#handler = concat(this.#handler, mw);
+    return this;
+  }
+  on(filter, ...middleware) {
+    const filters = Array.isArray(filter) ? filter : [filter];
+    return this.filter((ctx) => filters.some((q) => matchFilter(ctx, q)), ...middleware);
+  }
+  chatType(type, ...middleware) {
+    return this.filter((ctx) => type === "group" ? ctx.isGroup : !ctx.isGroup, ...middleware);
+  }
+  hears(trigger, ...middleware) {
+    const triggers = Array.isArray(trigger) ? trigger : [trigger];
+    return this.filter((ctx) => {
+      const text = ctx.text;
+      if (!text)
+        return false;
+      for (const t of triggers) {
+        if (typeof t === "string") {
+          if (text.includes(t)) {
+            ctx.match = t;
+            return true;
+          }
+        } else {
+          const m = t.exec(text);
+          if (m) {
+            ctx.match = m;
+            return true;
+          }
+        }
+      }
+      return false;
+    }, ...middleware);
+  }
+  command(command, ...middleware) {
+    const commands = Array.isArray(command) ? command : [command];
+    const normalized = commands.map((c) => c.replace(/^\//, "").toLowerCase());
+    return this.filter((ctx) => {
+      const text = ctx.text;
+      if (!text?.startsWith("/"))
+        return false;
+      const match = /^\/([a-z0-9_]+)(@\S+)?(?:\s(.*))?$/i.exec(text);
+      if (!match)
+        return false;
+      const cmd = (match[1] ?? "").toLowerCase();
+      if (!normalized.includes(cmd))
+        return false;
+      ctx.match = (match[3] ?? "").trim();
+      return true;
+    }, ...middleware);
+  }
+  filter(predicate, ...middleware) {
+    const mw = compose(middleware);
+    return this.use(async (ctx, next) => {
+      if (await predicate(ctx)) {
+        await mw(ctx, next);
+      } else {
+        await next();
+      }
+    });
+  }
+  drop(predicate) {
+    return this.use(async (ctx, next) => {
+      if (!await predicate(ctx))
+        await next();
+    });
+  }
+  branch(predicate, trueMiddleware, falseMiddleware) {
+    return this.use(async (ctx, next) => {
+      if (await predicate(ctx)) {
+        await flatten(trueMiddleware)(ctx, next);
+      } else {
+        await flatten(falseMiddleware)(ctx, next);
+      }
+    });
+  }
+  fork(...middleware) {
+    const mw = compose(middleware);
+    return this.use((ctx, next) => {
+      run(mw, ctx).catch((err) => this._onForkError(err, ctx));
+      return next();
+    });
+  }
+  lazy(factory) {
+    return this.use(async (ctx, next) => {
+      const result = await factory(ctx);
+      const middlewares = Array.isArray(result) ? result : [result];
+      const mw = compose(middlewares);
+      await mw(ctx, next);
+    });
+  }
+  errorBoundary(errorHandler, ...middleware) {
+    const mw = compose(middleware);
+    return this.use(async (ctx, next) => {
+      try {
+        await run(mw, ctx);
+      } catch (err) {
+        await errorHandler(new BotError(err, ctx), next);
+        return;
+      }
+      await next();
+    });
+  }
+}
+
+// src/context.ts
+var groupStateCaches = new Map;
+function groupHasMember(group, memberId) {
+  if (group.isMember !== undefined)
+    return group.isMember;
+  const members = group.members;
+  if (!Array.isArray(members))
+    return false;
+  return members.some((member) => typeof member === "string" ? member === memberId : member.number === memberId || member.uuid === memberId);
+}
+function getGroupStateCache(botId) {
+  let cache = groupStateCaches.get(botId);
+  if (!cache) {
+    cache = new Map;
+    groupStateCaches.set(botId, cache);
+  }
+  return cache;
+}
+function primeGroupStateCache(botId, groups) {
+  const cache = getGroupStateCache(botId);
+  const seen = new Set;
+  for (const group of groups) {
+    seen.add(group.id);
+    const previous = cache.get(group.id);
+    cache.set(group.id, {
+      name: group.name,
+      isMember: groupHasMember(group, botId),
+      revision: group.revision ?? previous?.revision
+    });
+  }
+  for (const [groupId, previous] of cache) {
+    if (!seen.has(groupId) && previous.isMember) {
+      cache.set(groupId, {
+        ...previous,
+        isMember: false
+      });
+    }
+  }
+}
+function restoreGroupStateCache(botId, snapshot) {
+  const cache = getGroupStateCache(botId);
+  for (const [groupId, state] of Object.entries(snapshot)) {
+    cache.set(groupId, {
+      name: state.name,
+      isMember: state.isMember,
+      revision: state.revision
+    });
+  }
+}
+function snapshotGroupStateCache(botId) {
+  const cache = getGroupStateCache(botId);
+  const snapshot = {};
+  for (const [groupId, state] of cache) {
+    snapshot[groupId] = {
+      name: state.name,
+      isMember: state.isMember,
+      revision: state.revision
+    };
+  }
+  return snapshot;
+}
+
+class Context {
+  update;
+  api;
+  me;
+  match;
+  constructor(update, api, me) {
+    this.update = update;
+    this.api = api;
+    this.me = me;
+  }
+  get dataMessage() {
+    return this.update.envelope.dataMessage;
+  }
+  get syncMessage() {
+    return this.update.envelope.syncMessage;
+  }
+  get editMessage() {
+    return this.update.envelope.editMessage;
+  }
+  get deleteMessage() {
+    return this.update.envelope.deleteMessage;
+  }
+  get receipt() {
+    return this.update.envelope.receiptMessage;
+  }
+  get typingMessage() {
+    return this.update.envelope.typingMessage;
+  }
+  get callMessage() {
+    return this.update.envelope.callMessage;
+  }
+  get message() {
+    const dm = this.update.envelope.dataMessage;
+    return dm && !dm.reaction && dm.groupInfo?.type !== "UPDATE" ? dm : undefined;
+  }
+  get reaction() {
+    const dm = this.update.envelope.dataMessage;
+    return dm?.reaction ?? undefined;
+  }
+  get groupUpdate() {
+    const dm = this.update.envelope.dataMessage;
+    return dm?.groupInfo?.type === "UPDATE" ? dm : undefined;
+  }
+  get from() {
+    return this.update.envelope.sourceNumber || undefined;
+  }
+  get fromUuid() {
+    return this.update.envelope.sourceUuid || this.update.envelope.source || undefined;
+  }
+  get fromName() {
+    return this.update.envelope.sourceName || undefined;
+  }
+  get sender() {
+    return this.update.envelope.sourceNumber || this.update.envelope.sourceUuid || this.update.envelope.source;
+  }
+  get chat() {
+    const dm = this.update.envelope.dataMessage;
+    if (dm?.groupInfo?.groupId)
+      return `group.${btoa(dm.groupInfo.groupId)}`;
+    const em = this.update.envelope.editMessage;
+    if (em?.message?.groupInfo?.groupId)
+      return `group.${btoa(em.message.groupInfo.groupId)}`;
+    const typing = this.update.envelope.typingMessage;
+    if (typing?.groupId)
+      return `group.${btoa(typing.groupId)}`;
+    return this.update.envelope.sourceNumber || this.update.envelope.source;
+  }
+  get isGroup() {
+    return this.update.envelope.dataMessage?.groupInfo != null || this.update.envelope.editMessage?.message?.groupInfo != null;
+  }
+  get text() {
+    const dm = this.update.envelope.dataMessage;
+    if (dm && !dm.reaction && typeof dm.message === "string") {
+      return dm.message;
+    }
+    const em = this.update.envelope.editMessage;
+    if (em && typeof em.message.message === "string") {
+      return em.message.message;
+    }
+    return "";
+  }
+  get msgTimestamp() {
+    return this.update.envelope.dataMessage?.timestamp ?? this.update.envelope.editMessage?.message?.timestamp ?? this.update.envelope.timestamp;
+  }
+  async reply(text, options = {}) {
+    await this.api.send(this.chat, text, options);
+  }
+  async quote(text, options = {}) {
+    const ts = this.msgTimestamp;
+    const author = this.sender;
+    if (!ts || !author) {
+      return this.reply(text, options);
+    }
+    await this.api.send(this.chat, text, {
+      ...options,
+      quote: {
+        timestamp: ts,
+        author,
+        text: this.text || undefined
+      }
+    });
+  }
+  async react(emoji) {
+    const ts = this.msgTimestamp;
+    const author = this.sender;
+    if (!ts || !author)
+      throw new Error("Cannot react: no message timestamp or author");
+    await this.api.react(this.chat, {
+      reaction: emoji,
+      targetAuthor: author,
+      targetTimestamp: ts
+    });
+  }
+  async unreact(emoji) {
+    const ts = this.msgTimestamp;
+    const author = this.sender;
+    if (!ts || !author)
+      throw new Error("Cannot unreact: no message timestamp or author");
+    await this.api.react(this.chat, {
+      reaction: emoji,
+      targetAuthor: author,
+      targetTimestamp: ts,
+      isRemove: true
+    });
+  }
+  async typing(stop = false) {
+    await this.api.typing(this.chat, stop);
+  }
+  async deleteMsg(timestamp) {
+    const ts = timestamp ?? this.msgTimestamp;
+    if (!ts)
+      throw new Error("Cannot delete: no timestamp");
+    await this.api.deleteMessage(this.chat, ts);
+  }
+  has(query) {
+    return matchFilter(this, query);
+  }
+  hasText(trigger) {
+    const text = this.text;
+    if (!text)
+      return false;
+    if (trigger === undefined)
+      return true;
+    if (typeof trigger === "string") {
+      if (text.includes(trigger)) {
+        this.match = trigger;
+        return true;
+      }
+      return false;
+    }
+    const m = trigger.exec(text);
+    if (m) {
+      this.match = m;
+      return true;
+    }
+    return false;
+  }
+  hasChatType(type) {
+    return type === "group" ? this.isGroup : !this.isGroup;
+  }
+  async inspectGroupUpdate() {
+    const update = this.groupUpdate;
+    const info = update?.groupInfo;
+    if (!update || !info?.groupId)
+      return;
+    const groupId = `group.${btoa(info.groupId)}`;
+    const cache = getGroupStateCache(this.me);
+    const previous = cache.get(groupId);
+    const incomingRevision = info.revision;
+    const previousRevision = previous?.revision;
+    if (previousRevision !== undefined && incomingRevision !== undefined && incomingRevision <= previousRevision) {
+      return {
+        kind: "stale",
+        groupId,
+        groupName: info.groupName ?? previous?.name,
+        revision: incomingRevision,
+        previousName: previous?.name,
+        previousRevision
+      };
+    }
+    const hasGap = previousRevision !== undefined && incomingRevision !== undefined && incomingRevision > previousRevision + 1;
+    if (hasGap) {
+      console.warn(`[cygnet] Group update gap for ${groupId}: expected revision ${previousRevision + 1}, got ${incomingRevision}`);
+    }
+    const nameChanged = previous?.name !== undefined && info.groupName !== undefined && previous.name !== info.groupName;
+    const needsReconcile = hasGap || !previous || !previous.isMember || !nameChanged;
+    let currentGroup;
+    if (needsReconcile) {
+      try {
+        const groups = await this.api.getGroups();
+        currentGroup = groups.find((group) => group.id === groupId);
+      } catch {}
+    }
+    let kind = "unknown";
+    let nextState;
+    if (!needsReconcile && previous) {
+      kind = "renamed";
+      nextState = {
+        name: info.groupName ?? previous.name,
+        isMember: true,
+        revision: incomingRevision ?? previousRevision
+      };
+    } else if (currentGroup) {
+      const isMember = groupHasMember(currentGroup, this.me);
+      if (!isMember) {
+        kind = previous?.isMember ? "left" : "unknown";
+        nextState = {
+          name: currentGroup.name || (info.groupName ?? previous?.name),
+          isMember: false,
+          revision: incomingRevision ?? currentGroup.revision ?? previousRevision
+        };
+      } else if (!previous || !previous.isMember) {
+        kind = "joined";
+        nextState = {
+          name: currentGroup.name || info.groupName,
+          isMember: true,
+          revision: incomingRevision ?? currentGroup.revision ?? previousRevision
+        };
+      } else if (nameChanged) {
+        kind = "renamed";
+        nextState = {
+          name: currentGroup.name || info.groupName,
+          isMember: true,
+          revision: incomingRevision ?? currentGroup.revision ?? previousRevision
+        };
+      } else {
+        kind = "updated";
+        nextState = {
+          name: currentGroup.name || (info.groupName ?? previous.name),
+          isMember: true,
+          revision: incomingRevision ?? currentGroup.revision ?? previousRevision
+        };
+      }
+    } else if (!previous) {
+      nextState = {
+        name: info.groupName,
+        isMember: false,
+        revision: incomingRevision
+      };
+    } else if (!previous.isMember) {
+      nextState = {
+        name: info.groupName ?? previous.name,
+        isMember: false,
+        revision: incomingRevision ?? previousRevision
+      };
+    } else if (nameChanged) {
+      kind = "renamed";
+      nextState = {
+        name: info.groupName ?? previous.name,
+        isMember: true,
+        revision: incomingRevision ?? previousRevision
+      };
+    } else {
+      kind = "updated";
+      nextState = {
+        name: info.groupName ?? previous.name,
+        isMember: true,
+        revision: incomingRevision ?? previousRevision
+      };
+    }
+    cache.set(groupId, nextState);
+    const missedRevisions = hasGap && previousRevision !== undefined && incomingRevision !== undefined ? incomingRevision - previousRevision - 1 : undefined;
+    return {
+      kind,
+      groupId,
+      groupName: currentGroup?.name || nextState.name,
+      revision: info.revision,
+      previousName: previous?.name,
+      previousRevision,
+      missedRevisions,
+      currentGroup
+    };
+  }
+}
+
+// src/core/client.ts
+class HttpClient {
+  baseUrl;
+  phoneNumber;
+  constructor(config) {
+    let url = config.baseUrl;
+    if (!url.startsWith("http://") && !url.startsWith("https://")) {
+      url = "http://" + url;
+    }
+    this.baseUrl = url.replace(/\/$/, "");
+    this.phoneNumber = config.phoneNumber;
+  }
+  async get(path) {
+    const res = await fetch(this.baseUrl + path, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    return this.#handleResponse(res);
+  }
+  async post(path, body) {
+    const res = await fetch(this.baseUrl + path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+    return this.#handleResponse(res);
+  }
+  async#handleResponse(res) {
+    if (res.ok) {
+      const text = await res.text();
+      if (!text)
+        return;
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    }
+    let description;
+    try {
+      const body = await res.json();
+      description = body.error ?? body.message ?? res.statusText;
+    } catch {
+      description = res.statusText;
+    }
+    throw new SignalError(res.status, description);
+  }
+  wsReceiveUrl() {
+    const wsBase = this.baseUrl.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
+    return `${wsBase}/v1/receive/${encodeURIComponent(this.phoneNumber)}`;
+  }
+}
+
+// src/core/api.ts
+class SignalAPI {
+  #client;
+  constructor(config) {
+    this.#client = new HttpClient(config);
+  }
+  get phoneNumber() {
+    return this.#client.phoneNumber;
+  }
+  async checkHealth() {
+    try {
+      await this.#client.get("/v1/health");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async send(recipient, text, options = {}) {
+    const payload = {
+      number: this.#client.phoneNumber,
+      message: text,
+      recipients: [recipient]
+    };
+    if (options.base64Attachments?.length) {
+      payload.base64_attachments = options.base64Attachments;
+    }
+    if (options.quote) {
+      payload.quote_timestamp = options.quote.timestamp;
+      payload.quote_author = options.quote.author;
+      if (options.quote.text !== undefined)
+        payload.quote_message = options.quote.text;
+      if (options.quote.mentions?.length)
+        payload.quote_mentions = options.quote.mentions;
+    }
+    if (options.mentions?.length) {
+      payload.mentions = options.mentions;
+    }
+    if (options.textMode) {
+      payload.text_mode = options.textMode;
+    }
+    if (options.viewOnce) {
+      payload.view_once = options.viewOnce;
+    }
+    if (options.editTimestamp !== undefined) {
+      payload.edit_timestamp = options.editTimestamp;
+    }
+    return this.#client.post("/v2/send", payload);
+  }
+  async react(recipient, reaction) {
+    const payload = {
+      recipient,
+      reaction: reaction.reaction,
+      target_author: reaction.targetAuthor,
+      timestamp: reaction.targetTimestamp,
+      remove: reaction.isRemove ?? false
+    };
+    await this.#client.post(`/v1/${encodeURIComponent(this.#client.phoneNumber)}/reaction`, payload);
+  }
+  async typing(recipient, stop = false) {
+    const payload = {
+      account: this.#client.phoneNumber,
+      recipient,
+      stop
+    };
+    await this.#client.post("/v1/typing", payload);
+  }
+  async deleteMessage(recipient, timestamp) {
+    const payload = {
+      recipient,
+      timestamp
+    };
+    await this.#client.post(`/v1/${encodeURIComponent(this.#client.phoneNumber)}/delete-message`, payload);
+  }
+  async editMessage(recipient, targetTimestamp, newText, options = {}) {
+    return this.send(recipient, newText, {
+      ...options,
+      editTimestamp: targetTimestamp
+    });
+  }
+  async getGroups() {
+    return this.#client.get(`/v1/groups/${encodeURIComponent(this.#client.phoneNumber)}`);
+  }
+  get httpClient() {
+    return this.#client;
+  }
+}
+
+// src/core/polling.ts
+class PollingListener {
+  #client;
+  #receivePath;
+  #interval;
+  #stopped = false;
+  constructor(client, options = {}) {
+    this.#client = client;
+    this.#receivePath = `/v1/receive/${encodeURIComponent(client.phoneNumber)}`;
+    this.#interval = options.interval ?? 1000;
+  }
+  stop() {
+    this.#stopped = true;
+  }
+  async* [Symbol.asyncIterator]() {
+    while (!this.#stopped) {
+      try {
+        const updates = await this.#client.get(this.#receivePath);
+        if (Array.isArray(updates)) {
+          for (const update of updates) {
+            if (this.#stopped)
+              return;
+            yield update;
+          }
+        }
+      } catch (err) {
+        if (this.#stopped)
+          return;
+        console.error("[cygnet] Polling error:", err);
+      }
+      if (!this.#stopped) {
+        await sleep(this.#interval);
+      }
+    }
+  }
+}
+function sleep(ms) {
+  return new Promise((res) => setTimeout(res, ms));
+}
+
+// src/core/websocket.ts
+class WebSocketListener {
+  #url;
+  #maxDelay;
+  #initialDelay;
+  #stopped = false;
+  #ws = null;
+  constructor(wsUrl, options = {}) {
+    this.#url = wsUrl;
+    this.#maxDelay = options.maxReconnectDelay ?? 30000;
+    this.#initialDelay = options.initialReconnectDelay ?? 1000;
+  }
+  stop() {
+    this.#stopped = true;
+    this.#ws?.close();
+  }
+  async* [Symbol.asyncIterator]() {
+    let delay = this.#initialDelay;
+    while (!this.#stopped) {
+      try {
+        yield* this.#connect();
+        delay = this.#initialDelay;
+      } catch (err) {
+        if (this.#stopped)
+          break;
+        console.error(`[cygnet] WebSocket error, reconnecting in ${delay}ms:`, err);
+        await sleep2(delay);
+        delay = Math.min(delay * 2, this.#maxDelay);
+      }
+    }
+  }
+  async* #connect() {
+    const ws = new WebSocket(this.#url);
+    this.#ws = ws;
+    const queue = [];
+    let resolve = null;
+    let closed = false;
+    let closeError = null;
+    ws.addEventListener("message", (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        queue.push(data);
+        resolve?.();
+        resolve = null;
+      } catch (err) {
+        console.error("[cygnet] Failed to parse WebSocket message:", err);
+      }
+    });
+    ws.addEventListener("close", (event) => {
+      closed = true;
+      if (!event.wasClean && event.code !== 1000) {
+        closeError = new Error(`WebSocket closed with code ${event.code}: ${event.reason}`);
+      }
+      resolve?.();
+      resolve = null;
+    });
+    ws.addEventListener("error", (event) => {
+      closeError = new Error(`WebSocket error: ${event.message ?? "unknown"}`);
+      resolve?.();
+      resolve = null;
+    });
+    await new Promise((res, rej) => {
+      ws.addEventListener("open", () => res());
+      ws.addEventListener("error", (e) => rej(new Error(`Failed to connect: ${e.message ?? "unknown"}`)));
+    });
+    try {
+      while (!this.#stopped) {
+        while (queue.length > 0) {
+          yield queue.shift();
+        }
+        if (closed)
+          break;
+        await new Promise((res) => {
+          resolve = res;
+          if (queue.length > 0 || closed) {
+            resolve = null;
+            res();
+          }
+        });
+      }
+    } finally {
+      ws.close();
+      this.#ws = null;
+    }
+    if (closeError)
+      throw closeError;
+  }
+}
+function sleep2(ms) {
+  return new Promise((res) => setTimeout(res, ms));
+}
+
+// src/bot.ts
+class Bot extends Composer {
+  api;
+  config;
+  #me = "";
+  #stopped = false;
+  #listener = null;
+  #errorHandler = defaultErrorHandler;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.api = new SignalAPI({
+      baseUrl: config.signalService,
+      phoneNumber: config.phoneNumber
+    });
+    this._onForkError = (err, ctx) => {
+      const botError = new BotError(err, ctx);
+      Promise.resolve(this.#errorHandler(botError)).catch((handlerErr) => {
+        console.error("[cygnet] Error in error handler:", handlerErr);
+      });
+    };
+  }
+  catch(handler) {
+    this.#errorHandler = handler;
+    return this;
+  }
+  async init() {
+    const healthy = await this.api.checkHealth();
+    if (!healthy) {
+      throw new Error(`[cygnet] Cannot reach signal-cli-rest-api at ${this.config.signalService}. Is it running?`);
+    }
+    this.#me = this.config.phoneNumber;
+    await this.#restoreGroupStateCache();
+    try {
+      const groups = await this.api.getGroups();
+      primeGroupStateCache(this.#me, groups);
+      await this.#persistGroupStateCache();
+    } catch (err) {
+      console.warn("[cygnet] Failed to prime group state cache:", err);
+    }
+  }
+  async start() {
+    this.#stopped = false;
+    await this.init();
+    const transport = this.config.transport ?? "websocket";
+    if (transport === "polling") {
+      this.#listener = new PollingListener(this.api.httpClient, {
+        interval: this.config.pollingInterval
+      });
+      console.log(`[cygnet] Bot started as ${this.#me} (polling)`);
+    } else {
+      const wsUrl = this.api.httpClient.wsReceiveUrl();
+      this.#listener = new WebSocketListener(wsUrl);
+      console.log(`[cygnet] Bot started as ${this.#me} (websocket)`);
+    }
+    for await (const update of this.#listener) {
+      if (this.#stopped)
+        break;
+      await this.handleUpdate(update);
+    }
+  }
+  stop() {
+    this.#stopped = true;
+    this.#listener?.stop();
+    console.log("[cygnet] Bot stopped.");
+  }
+  async handleUpdate(update) {
+    const ContextClass = this.config.ContextConstructor ?? Context;
+    const ctx = new ContextClass(update, this.api, this.#me);
+    try {
+      await run(this.middleware(), ctx);
+    } catch (err) {
+      const botError = new BotError(err, ctx);
+      try {
+        await this.#errorHandler(botError);
+      } catch (handlerErr) {
+        console.error("[cygnet] Error in error handler:", handlerErr);
+      }
+    }
+    if (update.envelope.dataMessage?.groupInfo?.type === "UPDATE") {
+      await this.#persistGroupStateCache();
+    }
+  }
+  async#restoreGroupStateCache() {
+    const storage = this.config.groupStateStorage;
+    if (!storage)
+      return;
+    try {
+      const snapshot = await storage.read(this.#groupStateKey());
+      if (!snapshot)
+        return;
+      if (typeof snapshot !== "object" || Array.isArray(snapshot)) {
+        console.warn("[cygnet] Ignoring invalid group state snapshot.");
+        return;
+      }
+      restoreGroupStateCache(this.#me, snapshot);
+    } catch (err) {
+      console.warn("[cygnet] Failed to restore group state cache:", err);
+    }
+  }
+  async#persistGroupStateCache() {
+    const storage = this.config.groupStateStorage;
+    if (!storage)
+      return;
+    try {
+      const snapshot = snapshotGroupStateCache(this.#me);
+      await storage.write(this.#groupStateKey(), snapshot);
+    } catch (err) {
+      console.warn("[cygnet] Failed to persist group state cache:", err);
+    }
+  }
+  #groupStateKey() {
+    return this.config.groupStateKey ?? this.#me;
+  }
+}
+function defaultErrorHandler(err) {
+  console.error("[cygnet] Unhandled error:", err.error);
+  console.error("[cygnet] Set bot.catch() to handle errors");
+}
+// src/convenience/session.ts
+import { readFile, writeFile } from "fs/promises";
+var directStorageBrand = Symbol("cygnet.directStorage");
+function session(options = {}) {
+  const storage = options.storage ?? new MemoryStorage;
+  const getKey = options.getSessionKey ?? ((ctx) => ctx.chat);
+  const initial = options.initial;
+  const prefix = options.keyPrefix ?? "";
+  return async (ctx, next) => {
+    const rawKey = await getKey(ctx);
+    const key = rawKey === undefined ? undefined : prefix + rawKey;
+    if (key === undefined) {
+      return next();
+    }
+    let data = await storage.read(key);
+    if (data === undefined && initial) {
+      data = initial();
+    }
+    ctx.session = data;
+    await next();
+    const updated = ctx.session;
+    if (updated === null || updated === undefined) {
+      await storage.delete(key);
+    } else {
+      await storage.write(key, updated);
+    }
+  };
+}
+
+class MemoryStorage {
+  [directStorageBrand] = true;
+  #store = new Map;
+  read(key) {
+    return this.#store.get(key);
+  }
+  write(key, value) {
+    this.#store.set(key, value);
+  }
+  delete(key) {
+    this.#store.delete(key);
+  }
+  keys() {
+    return this.#store.keys();
+  }
+}
+
+class FileStorage {
+  [directStorageBrand] = true;
+  #path;
+  constructor(path) {
+    this.#path = path;
+  }
+  async read(key) {
+    const store = await this.#readStore();
+    return store[key];
+  }
+  async write(key, value) {
+    const store = await this.#readStore();
+    store[key] = value;
+    await this.#writeStore(store);
+  }
+  async delete(key) {
+    const store = await this.#readStore();
+    if (!(key in store))
+      return;
+    delete store[key];
+    await this.#writeStore(store);
+  }
+  async#readStore() {
+    try {
+      const text = await readFile(this.#path, "utf8");
+      if (!text)
+        return {};
+      const parsed = JSON.parse(text);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {};
+      }
+      return parsed;
+    } catch (err) {
+      const code = typeof err === "object" && err !== null && "code" in err ? String(err.code) : "";
+      if (code === "ENOENT")
+        return {};
+      throw err;
+    }
+  }
+  async#writeStore(store) {
+    await writeFile(this.#path, JSON.stringify(store), "utf8");
+  }
+}
+function enhanceStorage(options) {
+  const { storage, ttl } = options;
+  return {
+    async read(key) {
+      const entry = await storage.read(key);
+      if (!entry)
+        return;
+      if (entry.expires !== undefined && Date.now() > entry.expires) {
+        await storage.delete(key);
+        return;
+      }
+      return entry.value;
+    },
+    async write(key, value) {
+      await storage.write(key, {
+        value,
+        expires: Date.now() + ttl
+      });
+    },
+    async delete(key) {
+      await storage.delete(key);
+    }
+  };
+}
+// src/convenience/scenes/base.ts
+class BaseScene extends Composer {
+  id;
+  #ttl;
+  #enterHandlers = [];
+  #leaveHandlers = [];
+  constructor(id, ttl) {
+    super();
+    this.id = id;
+    this.#ttl = ttl;
+  }
+  get ttl() {
+    return this.#ttl;
+  }
+  enter(...middleware) {
+    this.#enterHandlers.push(...middleware);
+    return this;
+  }
+  leave(...middleware) {
+    this.#leaveHandlers.push(...middleware);
+    return this;
+  }
+  enterMiddleware() {
+    if (this.#enterHandlers.length === 0)
+      return (_ctx, next) => next();
+    const handlers = this.#enterHandlers;
+    return (ctx, next) => {
+      let i = 0;
+      const dispatch = async () => {
+        if (i >= handlers.length)
+          return next();
+        const mw = handlers[i++];
+        if (!mw)
+          return next();
+        if (typeof mw === "function")
+          await mw(ctx, dispatch);
+        else
+          await mw.middleware()(ctx, dispatch);
+      };
+      return dispatch();
+    };
+  }
+  leaveMiddleware() {
+    if (this.#leaveHandlers.length === 0)
+      return (_ctx, next) => next();
+    const handlers = this.#leaveHandlers;
+    return (ctx, next) => {
+      let i = 0;
+      const dispatch = async () => {
+        if (i >= handlers.length)
+          return next();
+        const mw = handlers[i++];
+        if (!mw)
+          return next();
+        if (typeof mw === "function")
+          await mw(ctx, dispatch);
+        else
+          await mw.middleware()(ctx, dispatch);
+      };
+      return dispatch();
+    };
+  }
+}
+// src/convenience/scenes/stage.ts
+class Stage extends Composer {
+  #scenes;
+  constructor(scenes) {
+    super();
+    this.#scenes = new Map(scenes.map((s) => [s.id, s]));
+  }
+  middleware() {
+    const scenes = this.#scenes;
+    return async (ctx, next) => {
+      const sceneCtrl = getOrCreateSceneController(ctx, scenes);
+      const current = sceneCtrl.current;
+      if (current) {
+        const expires = ctx.session.__scenes?.expires;
+        if (expires && Date.now() > expires) {
+          await sceneCtrl.leave();
+          return next();
+        }
+        await run(flatten(current), ctx);
+        return;
+      }
+      await next();
+    };
+  }
+  enter(sceneId) {
+    return (ctx) => getOrCreateSceneController(ctx, this.#scenes).enter(sceneId);
+  }
+  leave() {
+    return (ctx) => getOrCreateSceneController(ctx, this.#scenes).leave();
+  }
+  reenter() {
+    return (ctx) => getOrCreateSceneController(ctx, this.#scenes).reenter();
+  }
+  static enter(sceneId) {
+    return (ctx) => {
+      const scene = ctx.scene;
+      if (!scene) {
+        throw new Error(`[cygnet] ctx.scene is not attached. Use a Stage instance helper (stage.enter("${sceneId}")) or register bot.use(stage) before this middleware.`);
+      }
+      return scene.enter(sceneId);
+    };
+  }
+  static leave() {
+    return (ctx) => {
+      const scene = ctx.scene;
+      if (!scene) {
+        throw new Error("[cygnet] ctx.scene is not attached. Use a Stage instance helper (stage.leave()) or register bot.use(stage) before this middleware.");
+      }
+      return scene.leave();
+    };
+  }
+  static reenter() {
+    return (ctx) => {
+      const scene = ctx.scene;
+      if (!scene) {
+        throw new Error("[cygnet] ctx.scene is not attached. Use a Stage instance helper (stage.reenter()) or register bot.use(stage) before this middleware.");
+      }
+      return scene.reenter();
+    };
+  }
+}
+function getOrCreateSceneController(ctx, scenes) {
+  const flavored = ctx;
+  if (flavored.scene)
+    return flavored.scene;
+  const sceneCtrl = createSceneController(ctx, scenes);
+  flavored.scene = sceneCtrl;
+  return sceneCtrl;
+}
+function createSceneController(ctx, scenes) {
+  const ctrl = {
+    get id() {
+      return ctx.session.__scenes?.current;
+    },
+    get current() {
+      const id = ctx.session.__scenes?.current;
+      return id ? scenes.get(id) : undefined;
+    },
+    get state() {
+      return ctx.session.__scenes?.state ?? {};
+    },
+    set state(val) {
+      if (!ctx.session.__scenes)
+        ctx.session.__scenes = {};
+      ctx.session.__scenes.state = val;
+    },
+    async enter(sceneId, initialState) {
+      const current = scenes.get(ctx.session.__scenes?.current ?? "");
+      if (current) {
+        await run(flatten(current.leaveMiddleware()), ctx);
+      }
+      const next = scenes.get(sceneId);
+      if (!next)
+        throw new Error(`[cygnet] Scene "${sceneId}" not found`);
+      const ttl = next.ttl;
+      ctx.session.__scenes = {
+        current: sceneId,
+        state: initialState ?? {},
+        cursor: 0,
+        expires: ttl ? Date.now() + ttl : undefined
+      };
+      await run(flatten(next.enterMiddleware()), ctx);
+    },
+    async leave() {
+      const id = ctx.session.__scenes?.current;
+      if (!id)
+        return;
+      const scene = scenes.get(id);
+      if (scene) {
+        await run(flatten(scene.leaveMiddleware()), ctx);
+      }
+      ctx.session.__scenes = undefined;
+    },
+    async reenter() {
+      const id = ctx.session.__scenes?.current;
+      if (!id)
+        return;
+      await ctrl.enter(id, ctrl.state);
+    }
+  };
+  return ctrl;
+}
+// src/convenience/scenes/wizard.ts
+class WizardScene extends BaseScene {
+  #steps;
+  constructor(id, ...steps) {
+    super(id);
+    this.#steps = steps;
+    this.use((ctx, next) => {
+      const step = this.#currentStep(ctx);
+      if (!step)
+        return next();
+      this.#attachWizard(ctx);
+      if (typeof step === "function")
+        return step(ctx, next);
+      return step.middleware()(ctx, next);
+    });
+  }
+  enterMiddleware() {
+    const enter = super.enterMiddleware();
+    return async (ctx, next) => {
+      const runFirstStep = async () => {
+        const step = this.#steps[0];
+        if (!step) {
+          await next();
+          return;
+        }
+        this.#attachWizard(ctx);
+        if (typeof step === "function") {
+          await step(ctx, next);
+          return;
+        }
+        await step.middleware()(ctx, next);
+      };
+      if (typeof enter === "function") {
+        await enter(ctx, runFirstStep);
+        return;
+      }
+      await enter.middleware()(ctx, runFirstStep);
+    };
+  }
+  get stepCount() {
+    return this.#steps.length;
+  }
+  #currentStep(ctx) {
+    const cursor = ctx.scene.current?.id === this.id ? ctx.session.__scenes?.cursor ?? 0 : 0;
+    return this.#steps[cursor];
+  }
+  #attachWizard(ctx) {
+    const self = this;
+    const wizard = {
+      get cursor() {
+        return ctx.session.__scenes?.cursor ?? 0;
+      },
+      selectStep(index) {
+        if (!ctx.session.__scenes)
+          ctx.session.__scenes = {};
+        ctx.session.__scenes.cursor = Math.max(0, Math.min(index, self.#steps.length - 1));
+      },
+      async advance() {
+        wizard.selectStep(wizard.cursor + 1);
+      },
+      async retreat() {
+        wizard.selectStep(wizard.cursor - 1);
+      },
+      get state() {
+        return ctx.session.__scenes?.state ?? {};
+      },
+      set state(val) {
+        if (!ctx.session.__scenes)
+          ctx.session.__scenes = {};
+        ctx.session.__scenes.state = val;
+      }
+    };
+    ctx.wizard = wizard;
+    return wizard;
+  }
+}
+export {
+  snapshotGroupStateCache,
+  session,
+  run,
+  restoreGroupStateCache,
+  primeGroupStateCache,
+  matchFilter,
+  flatten,
+  enhanceStorage,
+  directStorageBrand,
+  concat,
+  WizardScene,
+  WebSocketListener,
+  Stage,
+  SignalError,
+  SignalAPI,
+  PollingListener,
+  MemoryStorage,
+  HttpClient,
+  FileStorage,
+  Context,
+  Composer,
+  BotError,
+  Bot,
+  BaseScene
+};
+
+//# debugId=5A36B56B282D103864756E2164756E21
+//# sourceMappingURL=index.js.map