xnotif 0.1.0

package/dist/autopush.d.ts

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,447 @@
+// @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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1 @@
+{"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"}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "xnotif",
+  "version": "0.1.0",
+  "description": "Receive Twitter/X push notifications programmatically via Mozilla Autopush",
+  "keywords": [
+    "autopush",
+    "notifications",
+    "push",
+    "twitter",
+    "webpush",
+    "x"
+  ],
+  "homepage": "https://github.com/yutakobayashidev/xnotif",
+  "bugs": "https://github.com/yutakobayashidev/xnotif/issues",
+  "license": "MIT",
+  "author": "yutakobayashidev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yutakobayashidev/xnotif"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "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"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  }
+}