@bruch/max-client 0.1.0

package/src/session/store.ts

@@ -0,0 +1,154 @@
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+import { getLogger } from "../logging.ts";
+import {
+  DEFAULT_CONFIG_HASH,
+  defaultSyncState,
+  type SessionInfo,
+  type SessionStore as SessionStoreContract,
+} from "./types.ts";
+
+interface SessionRow {
+  token: string;
+  device_id: string;
+  phone: string;
+  mt_instance_id: string;
+  chats_sync: number;
+  contacts_sync: number;
+  drafts_sync: number;
+  presence_sync: number;
+  config_hash: string | number;
+}
+
+const columns = `token, device_id, phone, mt_instance_id, chats_sync, contacts_sync,
+  drafts_sync, presence_sync, config_hash`;
+
+export class SqliteSessionStore implements SessionStoreContract {
+  readonly path: string;
+  private database: Database | null = null;
+
+  constructor(workDir: string, databaseName = "session.db") {
+    mkdirSync(workDir, { recursive: true });
+    this.path = join(workDir, databaseName);
+  }
+
+  async saveSession(session: SessionInfo): Promise<void> {
+    const db = this.getDatabase();
+    db.query(`INSERT OR REPLACE INTO sessions (${columns}) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
+      session.token,
+      session.deviceId,
+      session.phone,
+      session.mtInstanceId,
+      session.sync.chatsSync,
+      session.sync.contactsSync,
+      session.sync.draftsSync,
+      session.sync.presenceSync,
+      String(session.sync.configHash),
+    );
+    getLogger().info("session saved");
+  }
+
+  async updateToken(oldToken: string, newToken: string): Promise<void> {
+    this.getDatabase()
+      .query("UPDATE sessions SET token = ? WHERE token = ?")
+      .run(newToken, oldToken);
+  }
+
+  async loadSession(): Promise<SessionInfo | null> {
+    return this.rowToSession(
+      this.getDatabase()
+        .query(`SELECT ${columns} FROM sessions LIMIT 1`)
+        .get() as SessionRow | null,
+    );
+  }
+
+  async loadSessionByDeviceId(deviceId: string): Promise<SessionInfo | null> {
+    return this.rowToSession(
+      this.getDatabase()
+        .query(`SELECT ${columns} FROM sessions WHERE device_id = ?`)
+        .get(deviceId) as SessionRow | null,
+    );
+  }
+
+  async loadSessionByPhone(phone: string): Promise<SessionInfo | null> {
+    return this.rowToSession(
+      this.getDatabase()
+        .query(`SELECT ${columns} FROM sessions WHERE phone = ?`)
+        .get(phone) as SessionRow | null,
+    );
+  }
+
+  async deleteSession(token: string): Promise<void> {
+    this.getDatabase().query("DELETE FROM sessions WHERE token = ?").run(token);
+  }
+
+  async deleteAllSessions(): Promise<void> {
+    this.getDatabase().run("DELETE FROM sessions");
+  }
+
+  async close(): Promise<void> {
+    this.database?.close();
+    this.database = null;
+  }
+
+  private getDatabase(): Database {
+    if (this.database) return this.database;
+    const database = new Database(this.path, { create: true, strict: true });
+    database.run(`CREATE TABLE IF NOT EXISTS sessions (
+      token TEXT NOT NULL PRIMARY KEY,
+      device_id TEXT NOT NULL,
+      phone TEXT NOT NULL,
+      mt_instance_id TEXT NOT NULL DEFAULT '',
+      chats_sync INTEGER NOT NULL DEFAULT -1,
+      contacts_sync INTEGER NOT NULL DEFAULT -1,
+      drafts_sync INTEGER NOT NULL DEFAULT -1,
+      presence_sync INTEGER NOT NULL DEFAULT -1,
+      config_hash TEXT NOT NULL DEFAULT ''
+    )`);
+    this.ensureColumns(database);
+    database
+      .query("UPDATE sessions SET config_hash = ? WHERE config_hash = ''")
+      .run(DEFAULT_CONFIG_HASH);
+    this.database = database;
+    return database;
+  }
+
+  private ensureColumns(database: Database): void {
+    const existing = new Set(
+      (database.query("PRAGMA table_info(sessions)").all() as { name: string }[]).map(
+        (row) => row.name,
+      ),
+    );
+    const definitions: Record<string, string> = {
+      mt_instance_id: "TEXT NOT NULL DEFAULT ''",
+      chats_sync: "INTEGER NOT NULL DEFAULT -1",
+      contacts_sync: "INTEGER NOT NULL DEFAULT -1",
+      drafts_sync: "INTEGER NOT NULL DEFAULT -1",
+      presence_sync: "INTEGER NOT NULL DEFAULT -1",
+      config_hash: "TEXT NOT NULL DEFAULT ''",
+    };
+    for (const [name, definition] of Object.entries(definitions)) {
+      if (!existing.has(name))
+        database.run(`ALTER TABLE sessions ADD COLUMN ${name} ${definition}`);
+    }
+  }
+
+  private rowToSession(row: SessionRow | null): SessionInfo | null {
+    if (!row) return null;
+    return {
+      token: row.token,
+      deviceId: row.device_id,
+      phone: row.phone,
+      mtInstanceId: row.mt_instance_id || "",
+      sync: defaultSyncState({
+        chatsSync: row.chats_sync,
+        contactsSync: row.contacts_sync,
+        draftsSync: row.drafts_sync,
+        presenceSync: row.presence_sync,
+        configHash: row.config_hash || DEFAULT_CONFIG_HASH,
+      }),
+    };
+  }
+}

package/src/session/types.ts

@@ -0,0 +1,45 @@
+export const DEFAULT_CONFIG_HASH =
+  "00000000-0000000000000000-00000000-0000000000000000-0000000000000000-0-0000000000000000-00000000";
+
+export interface SyncState {
+  chatsSync: number;
+  contactsSync: number;
+  draftsSync: number;
+  presenceSync: number;
+  configHash: string | number;
+}
+
+export type SyncOverrides = Partial<SyncState>;
+
+export interface SessionInfo {
+  token: string;
+  deviceId: string;
+  phone: string;
+  mtInstanceId: string;
+  sync: SyncState;
+}
+
+export interface SessionStore {
+  saveSession(session: SessionInfo): Promise<void>;
+  updateToken(oldToken: string, newToken: string): Promise<void>;
+  loadSession(): Promise<SessionInfo | null>;
+  loadSessionByDeviceId(deviceId: string): Promise<SessionInfo | null>;
+  loadSessionByPhone(phone: string): Promise<SessionInfo | null>;
+  deleteSession(token: string): Promise<void>;
+  deleteAllSessions(): Promise<void>;
+  close(): Promise<void>;
+}
+
+export function defaultSyncState(overrides: SyncOverrides = {}): SyncState {
+  return {
+    chatsSync: overrides.chatsSync ?? -1,
+    contactsSync: overrides.contactsSync ?? -1,
+    draftsSync: overrides.draftsSync ?? -1,
+    presenceSync: overrides.presenceSync ?? -1,
+    configHash: overrides.configHash ?? DEFAULT_CONFIG_HASH,
+  };
+}
+
+export function resolveSync(saved: SyncState, overrides: SyncOverrides = {}): SyncState {
+  return { ...saved, ...overrides };
+}

package/src/telemetry/index.ts

@@ -0,0 +1,3 @@
+export * from "./navigation.ts";
+export * from "./payloads.ts";
+export * from "./service.ts";

package/src/telemetry/navigation.ts

@@ -0,0 +1,160 @@
+export const Screen = {
+  BACKGROUND: 1,
+  CONTACTS: 100,
+  CHATS: 150,
+  SEARCH: 151,
+  CALLS: 300,
+  CHAT: 350,
+  SETTINGS: 450,
+  MINIAPP: 500,
+} as const;
+export type Screen = (typeof Screen)[keyof typeof Screen];
+
+export interface RandomSource {
+  random(): number;
+}
+
+export interface RouteProfile {
+  steps: number;
+  minPause: number;
+  maxPause: number;
+  longPauseChance: number;
+  minLongPause: number;
+  maxLongPause: number;
+  backChance: number;
+}
+
+interface ScreenTransition {
+  screen: Screen;
+  weight: number;
+}
+
+export const mainTabParams = { source_type: 5, source_id: 1, tab_config: 2 } as const;
+
+export const defaultProfiles: Readonly<Record<string, RouteProfile>> = {
+  quick: {
+    steps: 2,
+    minPause: 35,
+    maxPause: 95,
+    longPauseChance: 0.05,
+    minLongPause: 180,
+    maxLongPause: 420,
+    backChance: 0.3,
+  },
+  browse: {
+    steps: 4,
+    minPause: 70,
+    maxPause: 210,
+    longPauseChance: 0.12,
+    minLongPause: 240,
+    maxLongPause: 720,
+    backChance: 0.22,
+  },
+  read: {
+    steps: 3,
+    minPause: 140,
+    maxPause: 360,
+    longPauseChance: 0.25,
+    minLongPause: 420,
+    maxLongPause: 1200,
+    backChance: 0.18,
+  },
+};
+
+const graph: Readonly<Record<Screen, readonly ScreenTransition[]>> = {
+  [Screen.BACKGROUND]: [
+    { screen: Screen.CHATS, weight: 10 },
+    { screen: Screen.SETTINGS, weight: 1 },
+  ],
+  [Screen.CHATS]: [
+    { screen: Screen.CHAT, weight: 7 },
+    { screen: Screen.CONTACTS, weight: 2 },
+    { screen: Screen.SEARCH, weight: 2 },
+    { screen: Screen.CALLS, weight: 1 },
+    { screen: Screen.SETTINGS, weight: 1 },
+    { screen: Screen.CHATS, weight: 2 },
+  ],
+  [Screen.CHAT]: [
+    { screen: Screen.CHATS, weight: 8 },
+    { screen: Screen.CHAT, weight: 2 },
+    { screen: Screen.SETTINGS, weight: 1 },
+  ],
+  [Screen.CONTACTS]: [
+    { screen: Screen.CHATS, weight: 6 },
+    { screen: Screen.CHAT, weight: 2 },
+    { screen: Screen.SEARCH, weight: 1 },
+  ],
+  [Screen.SEARCH]: [
+    { screen: Screen.CHATS, weight: 5 },
+    { screen: Screen.CHAT, weight: 3 },
+    { screen: Screen.CONTACTS, weight: 1 },
+  ],
+  [Screen.CALLS]: [
+    { screen: Screen.CHATS, weight: 5 },
+    { screen: Screen.CONTACTS, weight: 2 },
+    { screen: Screen.SETTINGS, weight: 2 },
+  ],
+  [Screen.SETTINGS]: [
+    { screen: Screen.CHATS, weight: 7 },
+    { screen: Screen.CONTACTS, weight: 2 },
+    { screen: Screen.CALLS, weight: 2 },
+    { screen: Screen.MINIAPP, weight: 1 },
+  ],
+  [Screen.MINIAPP]: [
+    { screen: Screen.SETTINGS, weight: 3 },
+    { screen: Screen.CHATS, weight: 6 },
+  ],
+};
+
+export class NavigationPlanner {
+  currentScreen: Screen = Screen.BACKGROUND;
+  readonly history: Screen[] = [];
+
+  constructor(private readonly random: RandomSource = Math) {}
+
+  newProfile(): RouteProfile {
+    const profiles = Object.values(defaultProfiles);
+    return profiles[Math.floor(this.random.random() * profiles.length)] as RouteProfile;
+  }
+
+  pause(profile: RouteProfile): number {
+    const long = this.random.random() < profile.longPauseChance;
+    return this.between(
+      long ? profile.minLongPause : profile.minPause,
+      long ? profile.maxLongPause : profile.maxPause,
+    );
+  }
+
+  nextScreen(profile: RouteProfile): Screen {
+    if (this.history.length > 0 && this.random.random() < profile.backChance) {
+      this.currentScreen = this.history.pop() as Screen;
+      return this.currentScreen;
+    }
+    const transitions = graph[this.currentScreen];
+    const total = transitions.reduce((sum, item) => sum + item.weight, 0);
+    let point = Math.floor(this.random.random() * total) + 1;
+    let selected = transitions[transitions.length - 1] as ScreenTransition;
+    for (const transition of transitions) {
+      point -= transition.weight;
+      if (point <= 0) {
+        selected = transition;
+        break;
+      }
+    }
+    if (selected.screen !== this.currentScreen) {
+      this.history.push(this.currentScreen);
+      if (this.history.length > 4) this.history.shift();
+    }
+    this.currentScreen = selected.screen;
+    return selected.screen;
+  }
+
+  resetToBackground(): void {
+    this.currentScreen = Screen.BACKGROUND;
+    this.history.length = 0;
+  }
+
+  private between(minimum: number, maximum: number): number {
+    return minimum + this.random.random() * (maximum - minimum);
+  }
+}

package/src/telemetry/payloads.ts

@@ -0,0 +1,84 @@
+import type { MaxId } from "../types/index.ts";
+import type { RandomSource, Screen } from "./navigation.ts";
+
+export interface TelemetryEvent {
+  time: number;
+  userId: MaxId;
+  type: "PERF" | "NAV";
+  event: string;
+  params: Record<string, unknown>;
+  sessionId: number;
+}
+
+export class TelemetryPayloadBuilder {
+  constructor(private readonly random: RandomSource = Math) {}
+
+  login(userId: MaxId, sessionId: number): TelemetryEvent {
+    return this.event(userId, sessionId, "PERF", "login", {
+      properties: { connection_type: 2, vpn: 0, class: 2, background: 1, warm_start: 1 },
+      errorType: 100,
+    });
+  }
+
+  navigation(options: {
+    userId: MaxId;
+    sessionId: number;
+    screenFrom: Screen;
+    screenTo: Screen;
+    prevTime: number;
+    actionId: number;
+    extraParams?: Record<string, MaxId | number>;
+  }): TelemetryEvent {
+    return this.event(options.userId, options.sessionId, "NAV", "GO", {
+      prev_time: options.prevTime,
+      screen_to: options.screenTo,
+      action_id: options.actionId,
+      screen_from: options.screenFrom,
+      ...options.extraParams,
+    });
+  }
+
+  openChat(userId: MaxId, sessionId: number): TelemetryEvent {
+    const messages = this.integer(60, 240);
+    const render = this.integer(50, 260);
+    return this.event(userId, sessionId, "PERF", "open_chat_to_render", {
+      spans: [
+        { duration: messages + render, name: "open_chat_to_render" },
+        { duration: messages, name: "messages_list_created" },
+        { duration: render, name: "messages_render" },
+      ],
+      properties: { class: 2, warm: 1, flow: 1 },
+    });
+  }
+
+  openChats(userId: MaxId, sessionId: number): TelemetryEvent {
+    const created = this.integer(50, 230);
+    const rendered = this.integer(180, 650);
+    return this.event(userId, sessionId, "PERF", "open_chats_to_render", {
+      spans: [
+        { duration: created + rendered, name: "open_chats_to_render" },
+        { duration: created, name: "chats_tab_created" },
+        { duration: rendered, name: "chat_list_render" },
+      ],
+      properties: { class: 2 },
+    });
+  }
+
+  toPayload(events: TelemetryEvent[]): Record<string, unknown> {
+    return { events };
+  }
+
+  private event(
+    userId: MaxId,
+    sessionId: number,
+    type: TelemetryEvent["type"],
+    event: string,
+    params: Record<string, unknown>,
+  ): TelemetryEvent {
+    return { time: Date.now(), userId, type, event, params, sessionId };
+  }
+
+  private integer(minimum: number, maximum: number): number {
+    return Math.floor(this.random.random() * (maximum - minimum + 1)) + minimum;
+  }
+}

package/src/telemetry/service.ts

@@ -0,0 +1,194 @@
+import { getLogger } from "../logging.ts";
+import { Opcode } from "../protocol/index.ts";
+import type { Chat, MaxId, Profile } from "../types/index.ts";
+import {
+  NavigationPlanner,
+  Screen,
+  mainTabParams,
+  type RandomSource,
+  type RouteProfile,
+} from "./navigation.ts";
+import { TelemetryPayloadBuilder, type TelemetryEvent } from "./payloads.ts";
+
+export interface TelemetryRuntime {
+  readonly config: { requestTimeout: number; device: { clientSessionId: number } };
+  readonly connection: { readonly isOpen?: boolean };
+  readonly started: boolean;
+  readonly me: Profile | null;
+  readonly chats: Chat[];
+  invoke(opcode: number, payload?: Record<string, unknown>, timeout?: number): Promise<unknown>;
+}
+
+export interface TelemetryTiming {
+  startupDelay: readonly [number, number];
+  sessionIdleDelay: readonly [number, number];
+  renderDelay: readonly [number, number];
+  returnDelay: readonly [number, number];
+  returnToBackgroundChance: number;
+  openChatsRenderChance: number;
+}
+
+export const defaultTelemetryTiming: TelemetryTiming = {
+  startupDelay: [15, 90],
+  sessionIdleDelay: [900, 2700],
+  renderDelay: [0.15, 1.2],
+  returnDelay: [12, 45],
+  returnToBackgroundChance: 0.4,
+  openChatsRenderChance: 0.2,
+};
+
+export class TelemetryService {
+  readonly planner: NavigationPlanner;
+  readonly payloads: TelemetryPayloadBuilder;
+  private controller: AbortController | null = null;
+  private task: Promise<void> | null = null;
+  private actionId = 0;
+  private sessionId: number;
+  private lastNavTime = Date.now();
+
+  constructor(
+    private readonly app: TelemetryRuntime,
+    private readonly random: RandomSource = Math,
+    private readonly timing: TelemetryTiming = defaultTelemetryTiming,
+  ) {
+    this.planner = new NavigationPlanner(random);
+    this.payloads = new TelemetryPayloadBuilder(random);
+    this.sessionId = app.config.device.clientSessionId;
+  }
+
+  get running(): boolean {
+    return this.task !== null;
+  }
+
+  get ready(): boolean {
+    return this.app.started && this.app.me !== null && this.app.connection.isOpen !== false;
+  }
+
+  start(): void {
+    if (this.running || !this.ready) return;
+    const controller = new AbortController();
+    this.controller = controller;
+    this.task = this.run(controller.signal).finally(() => {
+      if (this.controller === controller) {
+        this.controller = null;
+        this.task = null;
+      }
+    });
+  }
+
+  async stop(): Promise<void> {
+    const task = this.task;
+    this.controller?.abort();
+    this.controller = null;
+    if (task) await task.catch(() => undefined);
+    this.task = null;
+  }
+
+  async sendEvents(events: TelemetryEvent[]): Promise<void> {
+    if (events.length === 0 || !this.ready) return;
+    await this.app.invoke(
+      Opcode.LOG,
+      this.payloads.toPayload(events),
+      this.app.config.requestTimeout,
+    );
+  }
+
+  sourceParams(screen: Screen): Record<string, MaxId | number> {
+    if (screen === Screen.CHATS) return { ...mainTabParams };
+    if (screen !== Screen.CHAT) return {};
+    const chat = this.pickChat();
+    return chat
+      ? { source_type: chat.type === "DIALOG" ? 1 : 2, source_id: chat.id }
+      : { source_type: 1, source_id: this.userId };
+  }
+
+  private async run(signal: AbortSignal): Promise<void> {
+    try {
+      await sleep(this.between(this.timing.startupDelay) * 1000, signal);
+      await this.sendEvents([this.payloads.login(this.userId, this.sessionId)]);
+      while (!signal.aborted) {
+        this.sessionId += 1;
+        await this.sendEvents(await this.collectSessionEvents(this.planner.newProfile(), signal));
+        this.planner.resetToBackground();
+        await sleep(this.between(this.timing.sessionIdleDelay) * 1000, signal);
+      }
+    } catch (error) {
+      if (!signal.aborted) getLogger().debug("telemetry loop stopped", { error: String(error) });
+    }
+  }
+
+  private async collectSessionEvents(
+    profile: RouteProfile,
+    signal: AbortSignal,
+  ): Promise<TelemetryEvent[]> {
+    const events: TelemetryEvent[] = [];
+    for (let step = 0; step < profile.steps; step += 1) {
+      await sleep(this.planner.pause(profile) * 1000, signal);
+      if (!this.ready) return events;
+      const from = this.planner.currentScreen;
+      const to = this.planner.nextScreen(profile);
+      events.push(this.navigationEvent(from, to));
+      if (to === Screen.CHAT) {
+        await sleep(this.between(this.timing.renderDelay) * 1000, signal);
+        events.push(this.payloads.openChat(this.userId, this.sessionId));
+      } else if (to === Screen.CHATS && this.random.random() < this.timing.openChatsRenderChance) {
+        await sleep(this.between(this.timing.renderDelay) * 1000, signal);
+        events.push(this.payloads.openChats(this.userId, this.sessionId));
+      }
+    }
+    if (
+      this.planner.currentScreen !== Screen.BACKGROUND &&
+      this.random.random() < this.timing.returnToBackgroundChance
+    ) {
+      await sleep(this.between(this.timing.returnDelay) * 1000, signal);
+      const from = this.planner.currentScreen;
+      this.planner.resetToBackground();
+      events.push(this.navigationEvent(from, Screen.BACKGROUND));
+    }
+    return events;
+  }
+
+  private navigationEvent(from: Screen, to: Screen): TelemetryEvent {
+    this.actionId = (this.actionId + 1) >>> 0;
+    const event = this.payloads.navigation({
+      userId: this.userId,
+      sessionId: this.sessionId,
+      screenFrom: from,
+      screenTo: to,
+      prevTime: this.lastNavTime,
+      actionId: this.actionId,
+      extraParams: this.sourceParams(to),
+    });
+    this.lastNavTime = event.time;
+    return event;
+  }
+
+  private get userId(): MaxId {
+    if (!this.app.me) throw new Error("Telemetry requires an authenticated profile");
+    return this.app.me.contact.id;
+  }
+
+  private pickChat(): Chat | null {
+    if (this.app.chats.length === 0) return null;
+    return this.app.chats[Math.floor(this.random.random() * this.app.chats.length)] ?? null;
+  }
+
+  private between(range: readonly [number, number]): number {
+    return range[0] + this.random.random() * (range[1] - range[0]);
+  }
+}
+
+async function sleep(milliseconds: number, signal: AbortSignal): Promise<void> {
+  if (signal.aborted) throw signal.reason;
+  await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(resolve, milliseconds);
+    signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+      },
+      { once: true },
+    );
+  });
+}

package/src/transport/base.ts

@@ -0,0 +1,43 @@
+export interface Transport<Message extends string | Uint8Array = string | Uint8Array> {
+  readonly connected: boolean;
+  connect(): Promise<void>;
+  close(): Promise<void>;
+  send(data: Message): Promise<void>;
+  recv(length?: number): Promise<Message>;
+}
+
+export class AsyncQueue<T> {
+  private readonly values: T[] = [];
+  private readonly waiters: Array<{
+    resolve(value: T): void;
+    reject(reason: unknown): void;
+  }> = [];
+  private failure: Error | null = null;
+
+  push(value: T): void {
+    const waiter = this.waiters.shift();
+    if (waiter) waiter.resolve(value);
+    else this.values.push(value);
+  }
+
+  async shift(): Promise<T> {
+    const value = this.values.shift();
+    if (value !== undefined) return value;
+    if (this.failure) throw this.failure;
+    return await new Promise<T>((resolve, reject) => this.waiters.push({ resolve, reject }));
+  }
+
+  fail(reason: Error): void {
+    this.failure = reason;
+    for (const waiter of this.waiters.splice(0)) waiter.reject(reason);
+  }
+
+  clear(): void {
+    this.values.length = 0;
+  }
+
+  reset(): void {
+    this.clear();
+    this.failure = null;
+  }
+}

package/src/transport/index.ts

@@ -0,0 +1,3 @@
+export * from "./base.ts";
+export * from "./tcp.ts";
+export * from "./websocket.ts";