xnotif 0.1.1-beta.0 → 0.2.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuta Kobayashi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -19,21 +19,48 @@ client.on("notification", (n) => {
 await client.start();
 ```
 
-## How It Works
-
-```
-Twitter ──▶ Mozilla Autopush (WebSocket) ──▶ AESGCM decrypt ──▶ EventEmitter
-```
-
-xnotif generates an ECDH key pair, registers it with Twitter's push endpoint using your session cookies, then listens on Mozilla's Autopush WebSocket. Incoming notifications are decrypted and emitted as typed events.
-
 ## Install
 
 ```bash
-bun add xnotif
+npm install xnotif
+```
+
+> Requires Node.js >= 22.0.0
+
+## Notification Payload
+
+Each `notification` event delivers a `TwitterNotification` object:
+
+```jsonc
+{
+  "title": "@jack",
+  "body": "just setting up my twttr",
+  "icon": "https://pbs.twimg.com/profile_images/...",
+  "timestamp": 1142974214000,
+  "tag": "mention_12345",
+  "data": {
+    "type": "mention",
+    "uri": "https://x.com/i/web/status/20",
+    "title": "@jack",
+    "body": "just setting up my twttr",
+    "tag": "mention_12345",
+    "lang": "en",
+    "scribe_target": "mention",
+    "impression_id": "abc123",
+  },
+}
 ```
 
-> Requires Bun >= 1.0.0
+Top-level fields:
+
+| Field       | Type      | Description                                       |
+| ----------- | --------- | ------------------------------------------------- |
+| `title`     | `string`  | Who triggered the notification                    |
+| `body`      | `string`  | Human-readable description                        |
+| `icon`      | `string?` | Profile image URL                                 |
+| `timestamp` | `number?` | Unix epoch in milliseconds                        |
+| `tag`       | `string?` | Deduplication tag                                 |
+| `data`      | `object?` | Structured metadata (see `data.type` for routing) |
 
 ## Getting Cookies
 
@@ -86,6 +113,37 @@ await client.start();
 - `Decryptor` — AESGCM Web Push decryption (ECDH + HKDF + AES-128-GCM)
 - `AutopushClient` — Mozilla Autopush WebSocket client
 
+## How It Works
+
+```mermaid
+sequenceDiagram
+    participant App as xnotif
+    participant Autopush as Mozilla Autopush<br/>wss://push.services.mozilla.com
+    participant Twitter as Twitter/X
+
+    App->>App: Generate ECDH P-256 key pair + 16-byte auth secret
+    App->>Autopush: WebSocket connect (subprotocol: push-notification)
+    Autopush-->>App: hello ACK (uaid assigned)
+    App->>Autopush: Register channel with VAPID key
+    Autopush-->>App: Push Endpoint URL
+
+    App->>Twitter: POST /1.1/notifications/settings/login.json<br/>{ token: endpoint, encryption_key1: p256dh, encryption_key2: auth }
+    Twitter-->>App: 200 OK
+
+    loop Real-time notifications
+        Twitter->>Autopush: Web Push (AESGCM encrypted payload)
+        Autopush->>App: WebSocket message
+        App->>App: ECDH shared secret (256-bit)<br/>→ HKDF-SHA256 (IKM, CEK, nonce)<br/>→ AES-128-GCM decrypt<br/>→ Strip 2-byte padding
+        App-->>App: Emit "notification" event
+    end
+```
+
+1. **Key generation** — Generate an ECDH P-256 key pair and a 16-byte auth secret via `crypto.subtle` (skipped when restoring from saved `state`)
+2. **Autopush connection** — Open a WebSocket to `wss://push.services.mozilla.com` with the `push-notification` subprotocol, send a `hello` handshake, then register a channel to obtain a Push Endpoint URL
+3. **Twitter registration** — POST the Push Endpoint, base64url-encoded public key, and auth secret to Twitter's `/1.1/notifications/settings/login.json`, authenticated with your session cookies (`auth_token` / `ct0`)
+4. **Receive & decrypt** — When Twitter pushes an AESGCM-encrypted payload through Autopush, derive a shared secret via ECDH, expand it with HKDF-SHA256 into a 16-byte CEK and 12-byte nonce, then decrypt with AES-128-GCM
+5. **Emit** — Parse the decrypted JSON into a `TwitterNotification` and fire it as a `notification` event
+
 ## License
 
 MIT

package/dist/index.d.mts

@@ -0,0 +1,114 @@
+import { EventEmitter } from "events";
+
+//#region src/types.d.ts
+interface AutopushNotification {
+  messageType: "notification";
+  channelID: string;
+  version: string;
+  data: string;
+  headers: {
+    crypto_key: string;
+    encryption: string;
+  };
+}
+interface TwitterNotification {
+  title: string;
+  body: string;
+  icon?: string;
+  timestamp?: number;
+  tag?: string;
+  data?: {
+    type?: string;
+    uri?: string;
+    title?: string;
+    body?: string;
+    tag?: string;
+    lang?: string;
+    bundle_text?: string;
+    scribe_target?: string;
+    impression_id?: string;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+interface ClientState {
+  uaid: string;
+  channelId: string;
+  endpoint: string;
+  remoteBroadcasts: Record<string, string>;
+  decryptor: {
+    jwk: JsonWebKey;
+    auth: string;
+  };
+}
+interface NotificationClientOptions {
+  cookies: {
+    auth_token: string;
+    ct0: string;
+    [key: string]: string;
+  };
+  state?: ClientState;
+}
+//#endregion
+//#region src/client.d.ts
+interface NotificationClientEvents {
+  notification: [notification: TwitterNotification];
+  connected: [state: ClientState];
+  error: [error: Error];
+  disconnected: [];
+  reconnecting: [delay: number];
+}
+declare class NotificationClient extends EventEmitter<NotificationClientEvents> {
+  private autopush;
+  private running;
+  private options;
+  constructor(options: NotificationClientOptions);
+  start(): Promise<void>;
+  stop(): void;
+}
+declare function createClient(options: NotificationClientOptions): NotificationClient;
+//#endregion
+//#region src/decrypt.d.ts
+declare class Decryptor {
+  private keyPair;
+  private publicKeyRaw;
+  private authSecret;
+  private jwk;
+  private constructor();
+  static create(jwk?: JsonWebKey, authBase64url?: string): Promise<Decryptor>;
+  getJwk(): JsonWebKey;
+  getAuthBase64url(): string;
+  getPublicKeyBase64url(): string;
+  decrypt(cryptoKeyHeader: string, encryptionHeader: string, payload: ArrayBuffer): Promise<string>;
+}
+//#endregion
+//#region src/autopush.d.ts
+interface AutopushOptions {
+  uaid?: string;
+  channelId: string;
+  vapidKey: string;
+  remoteBroadcasts?: Record<string, string>;
+  onNotification: (notification: AutopushNotification) => void;
+  onError?: (error: unknown) => void;
+  onDisconnected?: () => void;
+  onReconnecting?: (delay: number) => void;
+}
+declare class AutopushClient {
+  private options;
+  private ws;
+  private uaid;
+  private endpoint;
+  private reconnectDelay;
+  private closed;
+  private remoteBroadcasts;
+  constructor(options: AutopushOptions);
+  getUaid(): string;
+  getEndpoint(): string;
+  getRemoteBroadcasts(): Record<string, string>;
+  connect(): Promise<string>;
+  close(): void;
+  private send;
+  private reconnect;
+}
+//#endregion
+export { AutopushClient, type AutopushNotification, type AutopushOptions, type ClientState, Decryptor, NotificationClient, type NotificationClientOptions, type TwitterNotification, createClient };

package/dist/index.mjs

@@ -0,0 +1,438 @@
+import { EventEmitter } from "events";
+import { TwitterOpenApi } from "twitter-openapi-typescript";
+import { BaseAPI } from "twitter-openapi-typescript-generated";
+
+//#region src/utils.ts
+function base64urlToBuffer(b64url) {
+	const b64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
+	const padded = b64 + "=".repeat((4 - b64.length % 4) % 4);
+	const binary = atob(padded);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes.buffer;
+}
+function bufferToBase64url(buffer) {
+	const bytes = new Uint8Array(buffer);
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function concatBuffers(...buffers) {
+	const totalLength = buffers.reduce((acc, buf) => acc + buf.byteLength, 0);
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const buf of buffers) {
+		result.set(new Uint8Array(buf), offset);
+		offset += buf.byteLength;
+	}
+	return result.buffer;
+}
+
+//#endregion
+//#region src/decrypt.ts
+var Decryptor = class Decryptor {
+	constructor(keyPair, publicKeyRaw, authSecret, jwk) {
+		this.keyPair = keyPair;
+		this.publicKeyRaw = publicKeyRaw;
+		this.authSecret = authSecret;
+		this.jwk = jwk;
+	}
+	static async create(jwk, authBase64url) {
+		let keyPair;
+		let savedJwk;
+		if (jwk) {
+			const privateKey = await crypto.subtle.importKey("jwk", jwk, {
+				name: "ECDH",
+				namedCurve: "P-256"
+			}, true, ["deriveBits"]);
+			const pubJwk = {
+				...jwk,
+				d: void 0,
+				key_ops: []
+			};
+			delete pubJwk.d;
+			keyPair = {
+				privateKey,
+				publicKey: await crypto.subtle.importKey("jwk", pubJwk, {
+					name: "ECDH",
+					namedCurve: "P-256"
+				}, true, [])
+			};
+			savedJwk = jwk;
+		} else {
+			keyPair = await crypto.subtle.generateKey({
+				name: "ECDH",
+				namedCurve: "P-256"
+			}, true, ["deriveBits"]);
+			savedJwk = await crypto.subtle.exportKey("jwk", keyPair.privateKey);
+		}
+		const publicKeyRaw = await crypto.subtle.exportKey("raw", keyPair.publicKey);
+		const authSecret = authBase64url ? base64urlToBuffer(authBase64url) : crypto.getRandomValues(new Uint8Array(16)).buffer;
+		return new Decryptor(keyPair, publicKeyRaw, authSecret, savedJwk);
+	}
+	getJwk() {
+		return this.jwk;
+	}
+	getAuthBase64url() {
+		return bufferToBase64url(this.authSecret);
+	}
+	getPublicKeyBase64url() {
+		return bufferToBase64url(this.publicKeyRaw);
+	}
+	async decrypt(cryptoKeyHeader, encryptionHeader, payload) {
+		const cryptoKeyParams = parseHeader(cryptoKeyHeader);
+		const encryptionParams = parseHeader(encryptionHeader);
+		const remotePubKeyBytes = base64urlToBuffer(cryptoKeyParams.dh);
+		const salt = base64urlToBuffer(encryptionParams.salt);
+		const rs = encryptionParams.rs ? parseInt(encryptionParams.rs) : 0;
+		const remotePubKey = await crypto.subtle.importKey("raw", remotePubKeyBytes, {
+			name: "ECDH",
+			namedCurve: "P-256"
+		}, true, []);
+		const sharedSecret = new Uint8Array(await crypto.subtle.deriveBits({
+			name: "ECDH",
+			public: remotePubKey
+		}, this.keyPair.privateKey, 256));
+		const authInfo = new TextEncoder().encode("Content-Encoding: auth\0");
+		const ikm = await hkdf(new Uint8Array(this.authSecret), sharedSecret, authInfo, 32);
+		const context = concatBuffers(new TextEncoder().encode("P-256\0").buffer, new Uint8Array([0, 65]).buffer, this.publicKeyRaw, new Uint8Array([0, 65]).buffer, remotePubKeyBytes);
+		const cekInfo = concatBuffers(new TextEncoder().encode("Content-Encoding: aesgcm\0").buffer, context);
+		const cek = await hkdf(new Uint8Array(salt), ikm, new Uint8Array(cekInfo), 16);
+		const nonceInfo = concatBuffers(new TextEncoder().encode("Content-Encoding: nonce\0").buffer, context);
+		const nonce = await hkdf(new Uint8Array(salt), ikm, new Uint8Array(nonceInfo), 12);
+		const cekKey = await crypto.subtle.importKey("raw", cek, "AES-GCM", false, ["decrypt"]);
+		let decrypted;
+		if (rs >= 18) {
+			const chunks = splitPayload(payload, rs);
+			const parts = [];
+			for (let i = 0; i < chunks.length; i++) {
+				const chunkNonce = adjustNonce(nonce, i);
+				const part = await crypto.subtle.decrypt({
+					name: "AES-GCM",
+					iv: chunkNonce
+				}, cekKey, chunks[i]);
+				parts.push(part);
+			}
+			decrypted = concatBuffers(...parts);
+		} else decrypted = await crypto.subtle.decrypt({
+			name: "AES-GCM",
+			iv: nonce
+		}, cekKey, payload);
+		const paddingLen = new DataView(decrypted).getUint16(0);
+		const plaintext = decrypted.slice(2 + paddingLen);
+		return new TextDecoder().decode(plaintext);
+	}
+};
+function parseHeader(header) {
+	const result = {};
+	for (const part of header.split(";")) {
+		const trimmed = part.trim();
+		const eqIdx = trimmed.indexOf("=");
+		if (eqIdx !== -1) result[trimmed.slice(0, eqIdx).trim()] = trimmed.slice(eqIdx + 1).trim();
+	}
+	return result;
+}
+async function hmacSha256(key, data) {
+	const cryptoKey = await crypto.subtle.importKey("raw", key, {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	return new Uint8Array(await crypto.subtle.sign("HMAC", cryptoKey, data));
+}
+async function hkdf(salt, ikm, info, length) {
+	const prk = await hmacSha256(salt, ikm);
+	const infoWithCounter = new Uint8Array(info.length + 1);
+	infoWithCounter.set(info);
+	infoWithCounter[info.length] = 1;
+	return (await hmacSha256(prk, infoWithCounter)).slice(0, length);
+}
+function splitPayload(payload, rs) {
+	const bytes = new Uint8Array(payload);
+	const chunks = [];
+	for (let i = 0; i < bytes.length; i += rs) chunks.push(bytes.slice(i, Math.min(i + rs, bytes.length)).buffer);
+	return chunks;
+}
+function adjustNonce(nonce, offset) {
+	if (offset === 0) return nonce;
+	const adjusted = new Uint8Array(nonce);
+	for (let i = 11; i >= 6; i--) adjusted[i] ^= offset >>> (11 - i) * 8 & 255;
+	return adjusted;
+}
+
+//#endregion
+//#region src/autopush.ts
+const AUTOPUSH_URL = "wss://push.services.mozilla.com/";
+var AutopushClient = class {
+	ws = null;
+	uaid = "";
+	endpoint = "";
+	reconnectDelay = 1e3;
+	closed = false;
+	remoteBroadcasts;
+	constructor(options) {
+		this.options = options;
+		if (options.uaid) this.uaid = options.uaid;
+		this.remoteBroadcasts = options.remoteBroadcasts || {};
+	}
+	getUaid() {
+		return this.uaid;
+	}
+	getEndpoint() {
+		return this.endpoint;
+	}
+	getRemoteBroadcasts() {
+		return this.remoteBroadcasts;
+	}
+	connect() {
+		return new Promise((resolve, reject) => {
+			let resolved = false;
+			this.ws = new WebSocket(AUTOPUSH_URL);
+			this.ws.onopen = () => {
+				this.reconnectDelay = 1e3;
+				this.send({
+					messageType: "hello",
+					use_webpush: true,
+					uaid: this.uaid || "",
+					broadcasts: this.remoteBroadcasts
+				});
+			};
+			this.ws.onmessage = (event) => {
+				const msg = JSON.parse(String(event.data));
+				switch (msg.messageType) {
+					case "hello":
+						this.uaid = msg.uaid;
+						if (msg.broadcasts) this.remoteBroadcasts = msg.broadcasts;
+						this.send({
+							channelID: this.options.channelId,
+							messageType: "register",
+							key: this.options.vapidKey
+						});
+						break;
+					case "register":
+						if (msg.status === 200) {
+							this.endpoint = msg.pushEndpoint;
+							if (!resolved) {
+								resolved = true;
+								resolve(this.endpoint);
+							}
+						} else {
+							const err = /* @__PURE__ */ new Error(`Register failed: status ${msg.status}`);
+							if (!resolved) {
+								resolved = true;
+								reject(err);
+							}
+						}
+						break;
+					case "notification": {
+						const notification = msg;
+						this.send({
+							messageType: "ack",
+							updates: [{
+								channelID: notification.channelID,
+								version: notification.version,
+								code: 100
+							}]
+						});
+						this.options.onNotification(notification);
+						break;
+					}
+				}
+			};
+			this.ws.onclose = () => {
+				if (!this.closed) {
+					this.options.onDisconnected?.();
+					this.reconnect();
+				}
+			};
+			this.ws.onerror = (event) => {
+				const error = typeof ErrorEvent !== "undefined" && event instanceof ErrorEvent && event.message ? new Error(event.message) : /* @__PURE__ */ new Error("WebSocket connection failed");
+				this.options.onError?.(error);
+				if (!resolved) {
+					resolved = true;
+					reject(error);
+				}
+			};
+		});
+	}
+	close() {
+		this.closed = true;
+		this.ws?.close();
+	}
+	send(msg) {
+		this.ws?.send(JSON.stringify(msg));
+	}
+	reconnect() {
+		this.options.onReconnecting?.(this.reconnectDelay);
+		setTimeout(() => {
+			this.reconnectDelay = Math.min(this.reconnectDelay * 2, 6e4);
+			this.connect().catch((err) => {
+				this.options.onError?.(err);
+			});
+		}, this.reconnectDelay);
+	}
+};
+
+//#endregion
+//#region src/twitter.ts
+const API_HEADER_NAMES = [
+	"Accept",
+	"x-twitter-client-language",
+	"Priority",
+	"Referer",
+	"Sec-Fetch-Dest",
+	"Sec-Ch-Ua-Platform",
+	"Sec-Fetch-Mode",
+	"x-csrf-token",
+	"x-client-uuid",
+	"x-guest-token",
+	"Sec-Ch-Ua",
+	"x-twitter-active-user",
+	"user-agent",
+	"Accept-Language",
+	"Sec-Fetch-Site",
+	"x-twitter-auth-type",
+	"Sec-Ch-Ua-Mobile",
+	"Accept-Encoding"
+];
+var NotificationApi = class extends BaseAPI {
+	constructor(config) {
+		super(config);
+	}
+	async post(path, body, initOverride) {
+		const headers = {};
+		const apiKey = this.configuration.apiKey;
+		if (apiKey) for (const name of API_HEADER_NAMES) {
+			const value = await apiKey(name);
+			if (value) headers[name] = value;
+		}
+		const accessToken = this.configuration.accessToken;
+		if (accessToken) headers["Authorization"] = `Bearer ${await accessToken()}`;
+		headers["Content-Type"] = "application/json";
+		return this.request({
+			path,
+			method: "POST",
+			headers,
+			body
+		}, initOverride);
+	}
+};
+async function createClient$1(cookies) {
+	return new TwitterOpenApi().getClientFromCookies(cookies);
+}
+function makeInitOverride(client, path) {
+	return client.initOverrides({
+		"@method": "POST",
+		"@path": path
+	});
+}
+async function registerPush(client, subscription) {
+	const api = new NotificationApi(client.config);
+	const path = "/1.1/notifications/settings/login.json";
+	const res = await api.post(path, { push_device_info: {
+		os_version: "Web/Chrome",
+		udid: "Web/Chrome",
+		env: 3,
+		locale: "en",
+		protocol_version: 1,
+		token: subscription.endpoint,
+		encryption_key1: subscription.p256dh,
+		encryption_key2: subscription.auth
+	} }, makeInitOverride(client, path));
+	if (!res.ok) {
+		const text = await res.text();
+		throw new Error(`login.json failed (${res.status}): ${text}`);
+	}
+}
+
+//#endregion
+//#region src/client.ts
+const VAPID_KEY = "BF5oEo0xDUpgylKDTlsd8pZmxQA1leYINiY-rSscWYK_3tWAkz4VMbtf1MLE_Yyd6iII6o-e3Q9TCN5vZMzVMEs";
+var NotificationClient = class extends EventEmitter {
+	autopush = null;
+	running = false;
+	options;
+	constructor(options) {
+		super();
+		this.options = options;
+	}
+	async start() {
+		if (this.running) return;
+		this.running = true;
+		try {
+			let decryptor;
+			let channelId;
+			let uaid;
+			let savedEndpoint;
+			let remoteBroadcasts;
+			if (this.options.state) {
+				const s = this.options.state;
+				decryptor = await Decryptor.create(s.decryptor.jwk, s.decryptor.auth);
+				channelId = s.channelId;
+				uaid = s.uaid;
+				savedEndpoint = s.endpoint;
+				remoteBroadcasts = s.remoteBroadcasts;
+			} else {
+				decryptor = await Decryptor.create();
+				channelId = crypto.randomUUID();
+			}
+			this.autopush = new AutopushClient({
+				uaid,
+				channelId,
+				vapidKey: VAPID_KEY,
+				remoteBroadcasts,
+				onNotification: async (msg) => {
+					try {
+						const payload = base64urlToBuffer(msg.data);
+						const json = await decryptor.decrypt(msg.headers.crypto_key, msg.headers.encryption, payload);
+						const notification = JSON.parse(json);
+						this.emit("notification", notification);
+					} catch (err) {
+						this.emit("error", err instanceof Error ? err : new Error(String(err)));
+					}
+				},
+				onError: (err) => {
+					this.emit("error", err instanceof Error ? err : new Error(String(err)));
+				},
+				onDisconnected: () => {
+					this.emit("disconnected");
+				},
+				onReconnecting: (delay) => {
+					this.emit("reconnecting", delay);
+				}
+			});
+			const endpoint = await this.autopush.connect();
+			const needsRegistration = endpoint !== savedEndpoint;
+			const state = {
+				uaid: this.autopush.getUaid(),
+				channelId,
+				endpoint,
+				remoteBroadcasts: this.autopush.getRemoteBroadcasts(),
+				decryptor: {
+					jwk: decryptor.getJwk(),
+					auth: decryptor.getAuthBase64url()
+				}
+			};
+			this.emit("connected", state);
+			if (needsRegistration) await registerPush(await createClient$1(this.options.cookies), {
+				endpoint,
+				p256dh: decryptor.getPublicKeyBase64url(),
+				auth: decryptor.getAuthBase64url()
+			});
+		} catch (err) {
+			this.running = false;
+			this.autopush = null;
+			throw err;
+		}
+	}
+	stop() {
+		this.running = false;
+		this.autopush?.close();
+		this.autopush = null;
+	}
+};
+function createClient(options) {
+	return new NotificationClient(options);
+}
+
+//#endregion
+export { AutopushClient, Decryptor, NotificationClient, createClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xnotif",
-  "version": "0.1.1-beta.0",
+  "version": "0.2.0-beta.1",
   "description": "Receive Twitter/X push notifications programmatically via Mozilla Autopush",
   "keywords": [
     "autopush",
@@ -23,25 +23,29 @@
     "README.md"
   ],
   "type": "module",
-  "types": "./dist/index.d.ts",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
     }
   },
-  "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target bun --packages external && bunx tsc --emitDeclarationOnly"
-  },
   "dependencies": {
     "twitter-openapi-typescript": "^0.0.55",
     "twitter-openapi-typescript-generated": "^0.0.38"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.0",
-    "typescript": "^5.9.3"
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
   },
   "engines": {
-    "bun": ">=1.0.0"
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format esm",
+    "test": "vitest run --coverage"
   }
-}
+}

package/dist/autopush.d.ts

@@ -1,29 +0,0 @@
-import type { AutopushNotification } from "./types";
-export interface AutopushOptions {
-    uaid?: string;
-    channelId: string;
-    vapidKey: string;
-    remoteBroadcasts?: Record<string, string>;
-    onNotification: (notification: AutopushNotification) => void;
-    onError?: (error: unknown) => void;
-    onDisconnected?: () => void;
-    onReconnecting?: (delay: number) => void;
-}
-export declare class AutopushClient {
-    private options;
-    private ws;
-    private uaid;
-    private endpoint;
-    private reconnectDelay;
-    private closed;
-    private remoteBroadcasts;
-    constructor(options: AutopushOptions);
-    getUaid(): string;
-    getEndpoint(): string;
-    getRemoteBroadcasts(): Record<string, string>;
-    connect(): Promise<string>;
-    close(): void;
-    private send;
-    private reconnect;
-}
-//# sourceMappingURL=autopush.d.ts.map

package/dist/autopush.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"autopush.d.ts","sourceRoot":"","sources":["../src/autopush.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAIpD,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,cAAc,EAAE,CAAC,YAAY,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC7D,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACnC,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;IAC5B,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAC1C;AAED,qBAAa,cAAc;IAQb,OAAO,CAAC,OAAO;IAP3B,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAyB;gBAE7B,OAAO,EAAE,eAAe;IAK5C,OAAO,IAAI,MAAM;IAIjB,WAAW,IAAI,MAAM;IAIrB,mBAAmB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAI7C,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAoF1B,KAAK,IAAI,IAAI;IAKb,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,SAAS;CASlB"}

package/dist/client.d.ts

@@ -1,20 +0,0 @@
-import { EventEmitter } from "events";
-import type { ClientState, NotificationClientOptions, TwitterNotification } from "./types";
-interface NotificationClientEvents {
-    notification: [notification: TwitterNotification];
-    connected: [state: ClientState];
-    error: [error: Error];
-    disconnected: [];
-    reconnecting: [delay: number];
-}
-export declare class NotificationClient extends EventEmitter<NotificationClientEvents> {
-    private autopush;
-    private running;
-    private options;
-    constructor(options: NotificationClientOptions);
-    start(): Promise<void>;
-    stop(): void;
-}
-export declare function createClient(options: NotificationClientOptions): NotificationClient;
-export {};
-//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAKtC,OAAO,KAAK,EAEV,WAAW,EACX,yBAAyB,EACzB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAKjB,UAAU,wBAAwB;IAChC,YAAY,EAAE,CAAC,YAAY,EAAE,mBAAmB,CAAC,CAAC;IAClD,SAAS,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IAChC,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACtB,YAAY,EAAE,EAAE,CAAC;IACjB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED,qBAAa,kBAAmB,SAAQ,YAAY,CAAC,wBAAwB,CAAC;IAC5E,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAA4B;gBAE/B,OAAO,EAAE,yBAAyB;IAKxC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAoF5B,IAAI,IAAI,IAAI;CAKb;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,yBAAyB,GAAG,kBAAkB,CAEnF"}

package/dist/decrypt.d.ts

@@ -1,13 +0,0 @@
-export declare class Decryptor {
-    private keyPair;
-    private publicKeyRaw;
-    private authSecret;
-    private jwk;
-    private constructor();
-    static create(jwk?: JsonWebKey, authBase64url?: string): Promise<Decryptor>;
-    getJwk(): JsonWebKey;
-    getAuthBase64url(): string;
-    getPublicKeyBase64url(): string;
-    decrypt(cryptoKeyHeader: string, encryptionHeader: string, payload: ArrayBuffer): Promise<string>;
-}
-//# sourceMappingURL=decrypt.d.ts.map

package/dist/decrypt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"decrypt.d.ts","sourceRoot":"","sources":["../src/decrypt.ts"],"names":[],"mappings":"AAEA,qBAAa,SAAS;IAElB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,GAAG;IAJb,OAAO;WAOM,MAAM,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAsCjF,MAAM,IAAI,UAAU;IAIpB,gBAAgB,IAAI,MAAM;IAI1B,qBAAqB,IAAI,MAAM;IAIzB,OAAO,CACX,eAAe,EAAE,MAAM,EACvB,gBAAgB,EAAE,MAAM,EACxB,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,MAAM,CAAC;CAqFnB"}

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-export { NotificationClient, createClient } from "./client";
-export { Decryptor } from "./decrypt";
-export { AutopushClient } from "./autopush";
-export type { AutopushOptions } from "./autopush";
-export type { TwitterNotification, ClientState, NotificationClientOptions, AutopushNotification, } from "./types";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,YAAY,EACV,mBAAmB,EACnB,WAAW,EACX,yBAAyB,EACzB,oBAAoB,GACrB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -1,447 +0,0 @@
-// @bun
-// src/client.ts
-import { EventEmitter } from "events";
-
-// src/utils.ts
-function base64urlToBuffer(b64url) {
-  const b64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
-  const padded = b64 + "=".repeat((4 - b64.length % 4) % 4);
-  const binary = atob(padded);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0;i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes.buffer;
-}
-function bufferToBase64url(buffer) {
-  const bytes = new Uint8Array(buffer);
-  let binary = "";
-  for (const byte of bytes) {
-    binary += String.fromCharCode(byte);
-  }
-  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function concatBuffers(...buffers) {
-  const totalLength = buffers.reduce((acc, buf) => acc + buf.byteLength, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const buf of buffers) {
-    result.set(new Uint8Array(buf), offset);
-    offset += buf.byteLength;
-  }
-  return result.buffer;
-}
-
-// src/decrypt.ts
-class Decryptor {
-  keyPair;
-  publicKeyRaw;
-  authSecret;
-  jwk;
-  constructor(keyPair, publicKeyRaw, authSecret, jwk) {
-    this.keyPair = keyPair;
-    this.publicKeyRaw = publicKeyRaw;
-    this.authSecret = authSecret;
-    this.jwk = jwk;
-  }
-  static async create(jwk, authBase64url) {
-    let keyPair;
-    let savedJwk;
-    if (jwk) {
-      const privateKey = await crypto.subtle.importKey("jwk", jwk, { name: "ECDH", namedCurve: "P-256" }, true, ["deriveBits"]);
-      const pubJwk = { ...jwk, d: undefined, key_ops: [] };
-      delete pubJwk.d;
-      const publicKey = await crypto.subtle.importKey("jwk", pubJwk, { name: "ECDH", namedCurve: "P-256" }, true, []);
-      keyPair = { privateKey, publicKey };
-      savedJwk = jwk;
-    } else {
-      keyPair = await crypto.subtle.generateKey({ name: "ECDH", namedCurve: "P-256" }, true, [
-        "deriveBits"
-      ]);
-      savedJwk = await crypto.subtle.exportKey("jwk", keyPair.privateKey);
-    }
-    const publicKeyRaw = await crypto.subtle.exportKey("raw", keyPair.publicKey);
-    const authSecret = authBase64url ? base64urlToBuffer(authBase64url) : crypto.getRandomValues(new Uint8Array(16)).buffer;
-    return new Decryptor(keyPair, publicKeyRaw, authSecret, savedJwk);
-  }
-  getJwk() {
-    return this.jwk;
-  }
-  getAuthBase64url() {
-    return bufferToBase64url(this.authSecret);
-  }
-  getPublicKeyBase64url() {
-    return bufferToBase64url(this.publicKeyRaw);
-  }
-  async decrypt(cryptoKeyHeader, encryptionHeader, payload) {
-    const cryptoKeyParams = parseHeader(cryptoKeyHeader);
-    const encryptionParams = parseHeader(encryptionHeader);
-    const remotePubKeyBytes = base64urlToBuffer(cryptoKeyParams.dh);
-    const salt = base64urlToBuffer(encryptionParams.salt);
-    const rs = encryptionParams.rs ? parseInt(encryptionParams.rs) : 0;
-    const remotePubKey = await crypto.subtle.importKey("raw", remotePubKeyBytes, { name: "ECDH", namedCurve: "P-256" }, true, []);
-    const sharedSecret = new Uint8Array(await crypto.subtle.deriveBits({ name: "ECDH", public: remotePubKey }, this.keyPair.privateKey, 256));
-    const authInfo = new TextEncoder().encode("Content-Encoding: auth\x00");
-    const ikm = await hkdf(new Uint8Array(this.authSecret), sharedSecret, authInfo, 32);
-    const context = concatBuffers(new TextEncoder().encode("P-256\x00").buffer, new Uint8Array([0, 65]).buffer, this.publicKeyRaw, new Uint8Array([0, 65]).buffer, remotePubKeyBytes);
-    const cekInfo = concatBuffers(new TextEncoder().encode("Content-Encoding: aesgcm\x00").buffer, context);
-    const cek = await hkdf(new Uint8Array(salt), ikm, new Uint8Array(cekInfo), 16);
-    const nonceInfo = concatBuffers(new TextEncoder().encode("Content-Encoding: nonce\x00").buffer, context);
-    const nonce = await hkdf(new Uint8Array(salt), ikm, new Uint8Array(nonceInfo), 12);
-    const cekKey = await crypto.subtle.importKey("raw", cek, "AES-GCM", false, ["decrypt"]);
-    let decrypted;
-    if (rs >= 18) {
-      const chunks = splitPayload(payload, rs);
-      const parts = [];
-      for (let i = 0;i < chunks.length; i++) {
-        const chunkNonce = adjustNonce(nonce, i);
-        const part = await crypto.subtle.decrypt({ name: "AES-GCM", iv: chunkNonce }, cekKey, chunks[i]);
-        parts.push(part);
-      }
-      decrypted = concatBuffers(...parts);
-    } else {
-      decrypted = await crypto.subtle.decrypt({ name: "AES-GCM", iv: nonce }, cekKey, payload);
-    }
-    const view = new DataView(decrypted);
-    const paddingLen = view.getUint16(0);
-    const plaintext = decrypted.slice(2 + paddingLen);
-    return new TextDecoder().decode(plaintext);
-  }
-}
-function parseHeader(header) {
-  const result = {};
-  for (const part of header.split(";")) {
-    const trimmed = part.trim();
-    const eqIdx = trimmed.indexOf("=");
-    if (eqIdx !== -1) {
-      result[trimmed.slice(0, eqIdx).trim()] = trimmed.slice(eqIdx + 1).trim();
-    }
-  }
-  return result;
-}
-async function hmacSha256(key, data) {
-  const cryptoKey = await crypto.subtle.importKey("raw", key, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-  return new Uint8Array(await crypto.subtle.sign("HMAC", cryptoKey, data));
-}
-async function hkdf(salt, ikm, info, length) {
-  const prk = await hmacSha256(salt, ikm);
-  const infoWithCounter = new Uint8Array(info.length + 1);
-  infoWithCounter.set(info);
-  infoWithCounter[info.length] = 1;
-  const expanded = await hmacSha256(prk, infoWithCounter);
-  return expanded.slice(0, length);
-}
-function splitPayload(payload, rs) {
-  const bytes = new Uint8Array(payload);
-  const chunks = [];
-  for (let i = 0;i < bytes.length; i += rs) {
-    chunks.push(bytes.slice(i, Math.min(i + rs, bytes.length)).buffer);
-  }
-  return chunks;
-}
-function adjustNonce(nonce, offset) {
-  if (offset === 0)
-    return nonce;
-  const adjusted = new Uint8Array(nonce);
-  for (let i = 11;i >= 6; i--) {
-    adjusted[i] ^= offset >>> (11 - i) * 8 & 255;
-  }
-  return adjusted;
-}
-
-// src/autopush.ts
-var AUTOPUSH_URL = "wss://push.services.mozilla.com/";
-
-class AutopushClient {
-  options;
-  ws = null;
-  uaid = "";
-  endpoint = "";
-  reconnectDelay = 1000;
-  closed = false;
-  remoteBroadcasts;
-  constructor(options) {
-    this.options = options;
-    if (options.uaid)
-      this.uaid = options.uaid;
-    this.remoteBroadcasts = options.remoteBroadcasts || {};
-  }
-  getUaid() {
-    return this.uaid;
-  }
-  getEndpoint() {
-    return this.endpoint;
-  }
-  getRemoteBroadcasts() {
-    return this.remoteBroadcasts;
-  }
-  connect() {
-    return new Promise((resolve, reject) => {
-      let resolved = false;
-      this.ws = new WebSocket(AUTOPUSH_URL, ["push-notification"]);
-      this.ws.onopen = () => {
-        this.reconnectDelay = 1000;
-        this.send({
-          messageType: "hello",
-          use_webpush: true,
-          uaid: this.uaid || "",
-          broadcasts: this.remoteBroadcasts
-        });
-      };
-      this.ws.onmessage = (event) => {
-        const msg = JSON.parse(String(event.data));
-        switch (msg.messageType) {
-          case "hello":
-            this.uaid = msg.uaid;
-            if (msg.broadcasts) {
-              this.remoteBroadcasts = msg.broadcasts;
-            }
-            this.send({
-              channelID: this.options.channelId,
-              messageType: "register",
-              key: this.options.vapidKey
-            });
-            break;
-          case "register":
-            if (msg.status === 200) {
-              this.endpoint = msg.pushEndpoint;
-              if (!resolved) {
-                resolved = true;
-                resolve(this.endpoint);
-              }
-            } else {
-              const err = new Error(`Register failed: status ${msg.status}`);
-              if (!resolved) {
-                resolved = true;
-                reject(err);
-              }
-            }
-            break;
-          case "notification": {
-            const notification = msg;
-            this.send({
-              messageType: "ack",
-              updates: [
-                {
-                  channelID: notification.channelID,
-                  version: notification.version,
-                  code: 100
-                }
-              ]
-            });
-            this.options.onNotification(notification);
-            break;
-          }
-        }
-      };
-      this.ws.onclose = () => {
-        if (!this.closed) {
-          this.options.onDisconnected?.();
-          this.reconnect();
-        }
-      };
-      this.ws.onerror = (err) => {
-        this.options.onError?.(err);
-        if (!resolved) {
-          resolved = true;
-          reject(err);
-        }
-      };
-    });
-  }
-  close() {
-    this.closed = true;
-    this.ws?.close();
-  }
-  send(msg) {
-    this.ws?.send(JSON.stringify(msg));
-  }
-  reconnect() {
-    this.options.onReconnecting?.(this.reconnectDelay);
-    setTimeout(() => {
-      this.reconnectDelay = Math.min(this.reconnectDelay * 2, 60000);
-      this.connect().catch((err) => {
-        this.options.onError?.(err);
-      });
-    }, this.reconnectDelay);
-  }
-}
-
-// src/twitter.ts
-import { TwitterOpenApi } from "twitter-openapi-typescript";
-import {
-  BaseAPI
-} from "twitter-openapi-typescript-generated";
-var API_HEADER_NAMES = [
-  "Accept",
-  "x-twitter-client-language",
-  "Priority",
-  "Referer",
-  "Sec-Fetch-Dest",
-  "Sec-Ch-Ua-Platform",
-  "Sec-Fetch-Mode",
-  "x-csrf-token",
-  "x-client-uuid",
-  "x-guest-token",
-  "Sec-Ch-Ua",
-  "x-twitter-active-user",
-  "user-agent",
-  "Accept-Language",
-  "Sec-Fetch-Site",
-  "x-twitter-auth-type",
-  "Sec-Ch-Ua-Mobile",
-  "Accept-Encoding"
-];
-
-class NotificationApi extends BaseAPI {
-  constructor(config) {
-    super(config);
-  }
-  async post(path, body, initOverride) {
-    const headers = {};
-    const apiKey = this.configuration.apiKey;
-    if (apiKey) {
-      for (const name of API_HEADER_NAMES) {
-        const value = await apiKey(name);
-        if (value)
-          headers[name] = value;
-      }
-    }
-    const accessToken = this.configuration.accessToken;
-    if (accessToken) {
-      headers["Authorization"] = `Bearer ${await accessToken()}`;
-    }
-    headers["Content-Type"] = "application/json";
-    return this.request({ path, method: "POST", headers, body }, initOverride);
-  }
-}
-async function createClient(cookies) {
-  const api = new TwitterOpenApi;
-  return api.getClientFromCookies(cookies);
-}
-function makeInitOverride(client, path) {
-  return client.initOverrides({
-    "@method": "POST",
-    "@path": path
-  });
-}
-async function registerPush(client, subscription) {
-  const api = new NotificationApi(client.config);
-  const path = "/1.1/notifications/settings/login.json";
-  const res = await api.post(path, {
-    push_device_info: {
-      os_version: "Web/Chrome",
-      udid: "Web/Chrome",
-      env: 3,
-      locale: "en",
-      protocol_version: 1,
-      token: subscription.endpoint,
-      encryption_key1: subscription.p256dh,
-      encryption_key2: subscription.auth
-    }
-  }, makeInitOverride(client, path));
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`login.json failed (${res.status}): ${text}`);
-  }
-}
-
-// src/client.ts
-var VAPID_KEY = "BF5oEo0xDUpgylKDTlsd8pZmxQA1leYINiY-rSscWYK_3tWAkz4VMbtf1MLE_Yyd6iII6o-e3Q9TCN5vZMzVMEs";
-
-class NotificationClient extends EventEmitter {
-  autopush = null;
-  running = false;
-  options;
-  constructor(options) {
-    super();
-    this.options = options;
-  }
-  async start() {
-    if (this.running)
-      return;
-    this.running = true;
-    try {
-      let decryptor;
-      let channelId;
-      let uaid;
-      let savedEndpoint;
-      let remoteBroadcasts;
-      if (this.options.state) {
-        const s = this.options.state;
-        decryptor = await Decryptor.create(s.decryptor.jwk, s.decryptor.auth);
-        channelId = s.channelId;
-        uaid = s.uaid;
-        savedEndpoint = s.endpoint;
-        remoteBroadcasts = s.remoteBroadcasts;
-      } else {
-        decryptor = await Decryptor.create();
-        channelId = crypto.randomUUID();
-      }
-      this.autopush = new AutopushClient({
-        uaid,
-        channelId,
-        vapidKey: VAPID_KEY,
-        remoteBroadcasts,
-        onNotification: async (msg) => {
-          try {
-            const payload = base64urlToBuffer(msg.data);
-            const json = await decryptor.decrypt(msg.headers.crypto_key, msg.headers.encryption, payload);
-            const notification = JSON.parse(json);
-            this.emit("notification", notification);
-          } catch (err) {
-            this.emit("error", err instanceof Error ? err : new Error(String(err)));
-          }
-        },
-        onError: (err) => {
-          this.emit("error", err instanceof Error ? err : new Error(String(err)));
-        },
-        onDisconnected: () => {
-          this.emit("disconnected");
-        },
-        onReconnecting: (delay) => {
-          this.emit("reconnecting", delay);
-        }
-      });
-      const endpoint = await this.autopush.connect();
-      const needsRegistration = endpoint !== savedEndpoint;
-      const state = {
-        uaid: this.autopush.getUaid(),
-        channelId,
-        endpoint,
-        remoteBroadcasts: this.autopush.getRemoteBroadcasts(),
-        decryptor: {
-          jwk: decryptor.getJwk(),
-          auth: decryptor.getAuthBase64url()
-        }
-      };
-      this.emit("connected", state);
-      if (needsRegistration) {
-        const twitterClient = await createClient(this.options.cookies);
-        await registerPush(twitterClient, {
-          endpoint,
-          p256dh: decryptor.getPublicKeyBase64url(),
-          auth: decryptor.getAuthBase64url()
-        });
-      }
-    } catch (err) {
-      this.running = false;
-      this.autopush = null;
-      throw err;
-    }
-  }
-  stop() {
-    this.running = false;
-    this.autopush?.close();
-    this.autopush = null;
-  }
-}
-function createClient2(options) {
-  return new NotificationClient(options);
-}
-export {
-  createClient2 as createClient,
-  NotificationClient,
-  Decryptor,
-  AutopushClient
-};

package/dist/twitter.d.ts

@@ -1,9 +0,0 @@
-import { type TwitterOpenApiClient } from "twitter-openapi-typescript";
-export interface PushSubscription {
-    endpoint: string;
-    p256dh: string;
-    auth: string;
-}
-export declare function createClient(cookies: Record<string, string>): Promise<TwitterOpenApiClient>;
-export declare function registerPush(client: TwitterOpenApiClient, subscription: PushSubscription): Promise<void>;
-//# sourceMappingURL=twitter.d.ts.map

package/dist/twitter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"twitter.d.ts","sourceRoot":"","sources":["../src/twitter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AASvF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAsDD,wBAAsB,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAGjG;AASD,wBAAsB,YAAY,CAChC,MAAM,EAAE,oBAAoB,EAC5B,YAAY,EAAE,gBAAgB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAyBf"}

package/dist/types.d.ts

@@ -1,49 +0,0 @@
-export interface AutopushNotification {
-    messageType: "notification";
-    channelID: string;
-    version: string;
-    data: string;
-    headers: {
-        crypto_key: string;
-        encryption: string;
-    };
-}
-export interface TwitterNotification {
-    title: string;
-    body: string;
-    icon?: string;
-    timestamp?: number;
-    tag?: string;
-    data?: {
-        type?: string;
-        uri?: string;
-        title?: string;
-        body?: string;
-        tag?: string;
-        lang?: string;
-        bundle_text?: string;
-        scribe_target?: string;
-        impression_id?: string;
-        [key: string]: unknown;
-    };
-    [key: string]: unknown;
-}
-export interface ClientState {
-    uaid: string;
-    channelId: string;
-    endpoint: string;
-    remoteBroadcasts: Record<string, string>;
-    decryptor: {
-        jwk: JsonWebKey;
-        auth: string;
-    };
-}
-export interface NotificationClientOptions {
-    cookies: {
-        auth_token: string;
-        ct0: string;
-        [key: string]: string;
-    };
-    state?: ClientState;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,cAAc,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE;QACP,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;CACH;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE;QACL,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;IACF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,SAAS,EAAE;QACT,GAAG,EAAE,UAAU,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACpE,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB"}

package/dist/utils.d.ts

@@ -1,4 +0,0 @@
-export declare function base64urlToBuffer(b64url: string): ArrayBuffer;
-export declare function bufferToBase64url(buffer: ArrayBuffer): string;
-export declare function concatBuffers(...buffers: ArrayBuffer[]): ArrayBuffer;
-//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAS7D;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAO7D;AAED,wBAAgB,aAAa,CAAC,GAAG,OAAO,EAAE,WAAW,EAAE,GAAG,WAAW,CASpE"}