@signalapp/libsignal-client 0.67.2 → 0.67.3

package/dist/net/CDSI.d.ts

@@ -0,0 +1,29 @@
+import type { ReadonlyDeep } from 'type-fest';
+import * as Native from '../../Native';
+import { TokioAsyncContext, ServiceAuth } from '../net';
+export type CDSRequestOptionsType = {
+    e164s: Array<string>;
+    acisAndAccessKeys: Array<{
+        aci: string;
+        accessKey: string;
+    }>;
+    /**
+     * @deprecated this option is ignored by the server.
+     */
+    returnAcisWithoutUaks: boolean;
+    abortSignal?: AbortSignal;
+    useNewConnectLogic?: boolean;
+};
+export type CDSResponseEntryType<Aci, Pni> = {
+    aci: Aci | undefined;
+    pni: Pni | undefined;
+};
+export type CDSResponseEntries<Aci, Pni> = Map<string, CDSResponseEntryType<Aci, Pni>>;
+export interface CDSResponseType<Aci, Pni> {
+    entries: CDSResponseEntries<Aci, Pni>;
+    debugPermitsUsed: number;
+}
+export declare function cdsiLookup({ asyncContext, connectionManager, }: Readonly<{
+    asyncContext: TokioAsyncContext;
+    connectionManager: Native.Wrapper<Native.ConnectionManager>;
+}>, { username, password }: Readonly<ServiceAuth>, { e164s, acisAndAccessKeys, abortSignal, useNewConnectLogic, }: ReadonlyDeep<CDSRequestOptionsType>): Promise<CDSResponseType<string, string>>;

package/dist/net/CDSI.js

@@ -0,0 +1,27 @@
+"use strict";
+//
+// Copyright 2025 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cdsiLookup = void 0;
+const Native = require("../../Native");
+const Address_1 = require("../Address");
+const node_buffer_1 = require("node:buffer");
+const net_1 = require("../net");
+async function cdsiLookup({ asyncContext, connectionManager, }, { username, password }, { e164s, acisAndAccessKeys, abortSignal, useNewConnectLogic, }) {
+    const request = (0, net_1.newNativeHandle)(Native.LookupRequest_new());
+    e164s.forEach((e164) => {
+        Native.LookupRequest_addE164(request, e164);
+    });
+    acisAndAccessKeys.forEach(({ aci: aciStr, accessKey: accessKeyStr }) => {
+        Native.LookupRequest_addAciAndAccessKey(request, Address_1.Aci.parseFromServiceIdString(aciStr).getServiceIdFixedWidthBinary(), node_buffer_1.Buffer.from(accessKeyStr, 'base64'));
+    });
+    const startLookup = useNewConnectLogic
+        ? Native.CdsiLookup_new_routes
+        : Native.CdsiLookup_new;
+    const lookup = await asyncContext.makeCancellable(abortSignal, startLookup(asyncContext, connectionManager, username, password, request));
+    return await asyncContext.makeCancellable(abortSignal, Native.CdsiLookup_complete(asyncContext, (0, net_1.newNativeHandle)(lookup)));
+}
+exports.cdsiLookup = cdsiLookup;
+//# sourceMappingURL=CDSI.js.map

package/dist/net/Chat.d.ts

@@ -0,0 +1,121 @@
+/// <reference types="node" />
+import * as Native from '../../Native';
+import { LibSignalError } from '../Errors';
+import { Wrapper } from '../../Native';
+import { Buffer } from 'node:buffer';
+import { TokioAsyncContext } from '../net';
+export type ChatRequest = Readonly<{
+    verb: string;
+    path: string;
+    headers: ReadonlyArray<[string, string]>;
+    body?: Uint8Array;
+    timeoutMillis?: number;
+}>;
+type ConnectionManager = Wrapper<Native.ConnectionManager>;
+export declare class ChatServerMessageAck {
+    readonly _nativeHandle: Native.ServerMessageAck;
+    constructor(_nativeHandle: Native.ServerMessageAck);
+    send(statusCode: number): void;
+}
+export interface ConnectionEventsListener {
+    /**
+     * Called when the client gets disconnected from the server.
+     *
+     * This includes both deliberate disconnects as well as unexpected socket
+     * closures. If the closure was not due to a deliberate disconnect, the error
+     * will be provided.
+     */
+    onConnectionInterrupted(cause: LibSignalError | null): void;
+}
+export interface ChatServiceListener extends ConnectionEventsListener {
+    /**
+     * Called when the server delivers an incoming message to the client.
+     *
+     * `timestamp` is in milliseconds.
+     *
+     * If `ack`'s `send` method is not called, the server will leave this message in the message
+     * queue and attempt to deliver it again in the future.
+     */
+    onIncomingMessage(envelope: Buffer, timestamp: number, ack: ChatServerMessageAck): void;
+    /**
+     * Called when the server indicates that there are no further messages in the message queue.
+     *
+     * Note that further messages may still be delivered; this merely indicates that all messages that
+     * were in the queue *when the connection was established* have been delivered.
+     */
+    onQueueEmpty(): void;
+    /**
+     * Called when the server has alerts for the current device.
+     *
+     * In practice this happens as part of the connecting process.
+     */
+    onReceivedAlerts?(alerts: string[]): void;
+}
+/**
+ * A connection to the Chat Service.
+ *
+ * Provides API methods to communicate with the remote service. Make sure to
+ * call {@link #disconnect()} when the instance is no longer needed.
+ */
+export type ChatConnection = {
+    /**
+     * Initiates termination of the underlying connection to the Chat Service. After the service is
+     * disconnected, it cannot be used again.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Sends request to the Chat service.
+     */
+    fetch(chatRequest: ChatRequest, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<Native.ChatResponse>;
+    /**
+     * Information about the connection to the Chat service.
+     */
+    connectionInfo(): ConnectionInfo;
+};
+export interface ConnectionInfo {
+    localPort: number;
+    ipVersion: 'IPv4' | 'IPv6';
+    toString: () => string;
+}
+export declare class UnauthenticatedChatConnection implements ChatConnection {
+    private readonly asyncContext;
+    private readonly chatService;
+    private readonly chatListener;
+    static connect(asyncContext: TokioAsyncContext, connectionManager: ConnectionManager, listener: ConnectionEventsListener, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<UnauthenticatedChatConnection>;
+    private constructor();
+    fetch(chatRequest: ChatRequest, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<Native.ChatResponse>;
+    disconnect(): Promise<void>;
+    connectionInfo(): ConnectionInfo;
+}
+export declare class AuthenticatedChatConnection implements ChatConnection {
+    private readonly asyncContext;
+    private readonly chatService;
+    private readonly chatListener;
+    static connect(asyncContext: TokioAsyncContext, connectionManager: ConnectionManager, username: string, password: string, receiveStories: boolean, listener: ChatServiceListener, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<AuthenticatedChatConnection>;
+    /**
+     * Creates a chat connection backed by a fake remote end.
+     *
+     * @param asyncContext the async runtime to use
+     * @param listener the listener to send events to
+     * @param alerts alerts to send immediately upon connect
+     * @returns an {@link AuthenticatedChatConnection} and handle for the remote
+     * end of the fake connection.
+     */
+    static fakeConnect(asyncContext: TokioAsyncContext, listener: ChatServiceListener, alerts?: ReadonlyArray<string>): [AuthenticatedChatConnection, Wrapper<Native.FakeChatRemoteEnd>];
+    private constructor();
+    fetch(chatRequest: ChatRequest, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<Native.ChatResponse>;
+    disconnect(): Promise<void>;
+    connectionInfo(): ConnectionInfo;
+}
+export declare function buildHttpRequest(chatRequest: ChatRequest): Wrapper<Native.HttpRequest>;
+export {};

package/dist/net/Chat.js

@@ -0,0 +1,196 @@
+"use strict";
+//
+// Copyright 2025 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHttpRequest = exports.AuthenticatedChatConnection = exports.UnauthenticatedChatConnection = exports.ChatServerMessageAck = void 0;
+const Native = require("../../Native");
+const node_buffer_1 = require("node:buffer");
+const net_1 = require("../net");
+const DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS = 5000;
+class ChatServerMessageAck {
+    constructor(_nativeHandle) {
+        this._nativeHandle = _nativeHandle;
+    }
+    send(statusCode) {
+        Native.ServerMessageAck_SendStatus(this, statusCode);
+    }
+}
+exports.ChatServerMessageAck = ChatServerMessageAck;
+class ConnectionInfoImpl {
+    constructor(_nativeHandle) {
+        this._nativeHandle = _nativeHandle;
+    }
+    get localPort() {
+        return Native.ChatConnectionInfo_local_port(this);
+    }
+    get ipVersion() {
+        const value = Native.ChatConnectionInfo_ip_version(this);
+        switch (value) {
+            case 1:
+                return 'IPv4';
+            case 2:
+                return 'IPv6';
+            default:
+                throw new TypeError(`ip type was unexpectedly ${value}`);
+        }
+    }
+    toString() {
+        return Native.ChatConnectionInfo_description(this);
+    }
+}
+class UnauthenticatedChatConnection {
+    static async connect(asyncContext, connectionManager, listener, options) {
+        const nativeChatListener = makeNativeChatListener(asyncContext, listener);
+        const connect = Native.UnauthenticatedChatConnection_connect(asyncContext, connectionManager);
+        const chat = await asyncContext.makeCancellable(options?.abortSignal, connect);
+        const connection = (0, net_1.newNativeHandle)(chat);
+        Native.UnauthenticatedChatConnection_init_listener(connection, new WeakListenerWrapper(nativeChatListener));
+        return new UnauthenticatedChatConnection(asyncContext, connection, nativeChatListener);
+    }
+    constructor(asyncContext, chatService, 
+    // Unused except to keep the listener alive since the Rust code only holds a
+    // weak reference to the same object.
+    chatListener) {
+        this.asyncContext = asyncContext;
+        this.chatService = chatService;
+        this.chatListener = chatListener;
+    }
+    fetch(chatRequest, options) {
+        return this.asyncContext.makeCancellable(options?.abortSignal, Native.UnauthenticatedChatConnection_send(this.asyncContext, this.chatService, buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS));
+    }
+    disconnect() {
+        return Native.UnauthenticatedChatConnection_disconnect(this.asyncContext, this.chatService);
+    }
+    connectionInfo() {
+        return new ConnectionInfoImpl(Native.UnauthenticatedChatConnection_info(this.chatService));
+    }
+}
+exports.UnauthenticatedChatConnection = UnauthenticatedChatConnection;
+class AuthenticatedChatConnection {
+    static async connect(asyncContext, connectionManager, username, password, receiveStories, listener, options) {
+        const nativeChatListener = makeNativeChatListener(asyncContext, listener);
+        const connect = Native.AuthenticatedChatConnection_connect(asyncContext, connectionManager, username, password, receiveStories);
+        const chat = await asyncContext.makeCancellable(options?.abortSignal, connect);
+        const connection = (0, net_1.newNativeHandle)(chat);
+        Native.AuthenticatedChatConnection_init_listener(connection, new WeakListenerWrapper(nativeChatListener));
+        return new AuthenticatedChatConnection(asyncContext, connection, nativeChatListener);
+    }
+    /**
+     * Creates a chat connection backed by a fake remote end.
+     *
+     * @param asyncContext the async runtime to use
+     * @param listener the listener to send events to
+     * @param alerts alerts to send immediately upon connect
+     * @returns an {@link AuthenticatedChatConnection} and handle for the remote
+     * end of the fake connection.
+     */
+    static fakeConnect(asyncContext, listener, alerts) {
+        const nativeChatListener = makeNativeChatListener(asyncContext, listener);
+        const fakeChat = (0, net_1.newNativeHandle)(Native.TESTING_FakeChatConnection_Create(asyncContext, new WeakListenerWrapper(nativeChatListener), alerts?.join('\n') ?? ''));
+        const chat = (0, net_1.newNativeHandle)(Native.TESTING_FakeChatConnection_TakeAuthenticatedChat(fakeChat));
+        return [
+            new AuthenticatedChatConnection(asyncContext, chat, nativeChatListener),
+            (0, net_1.newNativeHandle)(Native.TESTING_FakeChatConnection_TakeRemote(fakeChat)),
+        ];
+    }
+    constructor(asyncContext, chatService, 
+    // Unused except to keep the listener alive since the Rust code only holds a
+    // weak reference to the same object.
+    chatListener) {
+        this.asyncContext = asyncContext;
+        this.chatService = chatService;
+        this.chatListener = chatListener;
+    }
+    fetch(chatRequest, options) {
+        return this.asyncContext.makeCancellable(options?.abortSignal, Native.AuthenticatedChatConnection_send(this.asyncContext, this.chatService, buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS));
+    }
+    disconnect() {
+        return Native.AuthenticatedChatConnection_disconnect(this.asyncContext, this.chatService);
+    }
+    connectionInfo() {
+        return new ConnectionInfoImpl(Native.AuthenticatedChatConnection_info(this.chatService));
+    }
+}
+exports.AuthenticatedChatConnection = AuthenticatedChatConnection;
+/**
+ * Holds a {@link Native.ChatListener} by {@link WeakRef} and delegates
+ * `ChatListener` calls to it.
+ *
+ * This lets us avoid passing anything across the bridge that has a normal
+ * (strong) reference to the app-side listener. The danger is that the passed-in
+ * listener might gain a reference to the JS connection object; that would
+ * result in a reference cycle that Node can't clean up because one of the
+ * references is through a Rust `Box`.
+ *
+ * When constructing a connection, calling code should wrap an app-side listener
+ * in this type and pass it across the bridge, then hold its own strong
+ * reference to the same listener as a field. This ensures that if there is a
+ * reference cycle between the connection and app-side listener, that cycle is
+ * visible to the Node runtime, while still ensuring the passed-in listener
+ * stays alive as long as the connection does.
+ */
+class WeakListenerWrapper {
+    constructor(listener) {
+        this.listener = new WeakRef(listener);
+    }
+    _connection_interrupted(reason) {
+        this.listener.deref()?._connection_interrupted(reason);
+    }
+    _incoming_message(envelope, timestamp, ack) {
+        this.listener.deref()?._incoming_message(envelope, timestamp, ack);
+    }
+    _queue_empty() {
+        this.listener.deref()?._queue_empty();
+    }
+    _received_alerts(alerts) {
+        this.listener.deref()?._received_alerts(alerts);
+    }
+}
+function makeNativeChatListener(asyncContext, listener) {
+    if ('onQueueEmpty' in listener) {
+        return {
+            _incoming_message(envelope, timestamp, ack) {
+                listener.onIncomingMessage(envelope, timestamp, new ChatServerMessageAck(ack));
+            },
+            _queue_empty() {
+                listener.onQueueEmpty();
+            },
+            _received_alerts(alerts) {
+                listener.onReceivedAlerts?.(alerts);
+            },
+            _connection_interrupted(cause) {
+                listener.onConnectionInterrupted(cause);
+            },
+        };
+    }
+    return {
+        _incoming_message(_envelope, _timestamp, _ack) {
+            throw new Error('Event not supported on unauthenticated connection');
+        },
+        _queue_empty() {
+            throw new Error('Event not supported on unauthenticated connection');
+        },
+        _received_alerts(_alerts) {
+            throw new Error('Event not supported on unauthenticated connection');
+        },
+        _connection_interrupted(cause) {
+            listener.onConnectionInterrupted(cause);
+        },
+    };
+}
+function buildHttpRequest(chatRequest) {
+    const { verb, path, body, headers } = chatRequest;
+    const bodyBuffer = body !== undefined ? node_buffer_1.Buffer.from(body) : null;
+    const httpRequest = {
+        _nativeHandle: Native.HttpRequest_new(verb, path, bodyBuffer),
+    };
+    headers.forEach((header) => {
+        const [name, value] = header;
+        Native.HttpRequest_add_header(httpRequest, name, value);
+    });
+    return httpRequest;
+}
+exports.buildHttpRequest = buildHttpRequest;
+//# sourceMappingURL=Chat.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalapp/libsignal-client",
-  "version": "0.67.2",
+  "version": "0.67.3",
   "license": "AGPL-3.0-only",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,6 +8,8 @@
     "dist/acknowledgments.md",
     "dist/*.js",
     "dist/*.d.ts",
+    "dist/net/**/*.js",
+    "dist/net/**/*.d.ts",
     "dist/zkgroup/**/*.js",
     "dist/zkgroup/**/*.d.ts",
     "Native.js",