byterover-cli 1.7.0 → 1.7.2

package/node_modules/engine.io-client/build/esm/globals.node.js

@@ -0,0 +1,91 @@
+export const nextTick = process.nextTick;
+export const globalThisShim = global;
+export const defaultBinaryType = "nodebuffer";
+export function createCookieJar() {
+    return new CookieJar();
+}
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie
+ */
+export function parse(setCookieString) {
+    const parts = setCookieString.split("; ");
+    const i = parts[0].indexOf("=");
+    if (i === -1) {
+        return;
+    }
+    const name = parts[0].substring(0, i).trim();
+    if (!name.length) {
+        return;
+    }
+    let value = parts[0].substring(i + 1).trim();
+    if (value.charCodeAt(0) === 0x22) {
+        // remove double quotes
+        value = value.slice(1, -1);
+    }
+    const cookie = {
+        name,
+        value,
+    };
+    for (let j = 1; j < parts.length; j++) {
+        const subParts = parts[j].split("=");
+        if (subParts.length !== 2) {
+            continue;
+        }
+        const key = subParts[0].trim();
+        const value = subParts[1].trim();
+        switch (key) {
+            case "Expires":
+                cookie.expires = new Date(value);
+                break;
+            case "Max-Age":
+                const expiration = new Date();
+                expiration.setUTCSeconds(expiration.getUTCSeconds() + parseInt(value, 10));
+                cookie.expires = expiration;
+                break;
+            default:
+            // ignore other keys
+        }
+    }
+    return cookie;
+}
+export class CookieJar {
+    constructor() {
+        this._cookies = new Map();
+    }
+    parseCookies(values) {
+        if (!values) {
+            return;
+        }
+        values.forEach((value) => {
+            const parsed = parse(value);
+            if (parsed) {
+                this._cookies.set(parsed.name, parsed);
+            }
+        });
+    }
+    get cookies() {
+        const now = Date.now();
+        this._cookies.forEach((cookie, name) => {
+            var _a;
+            if (((_a = cookie.expires) === null || _a === void 0 ? void 0 : _a.getTime()) < now) {
+                this._cookies.delete(name);
+            }
+        });
+        return this._cookies.entries();
+    }
+    addCookies(xhr) {
+        const cookies = [];
+        for (const [name, cookie] of this.cookies) {
+            cookies.push(`${name}=${cookie.value}`);
+        }
+        if (cookies.length) {
+            xhr.setDisableHeaderCheck(true);
+            xhr.setRequestHeader("cookie", cookies.join("; "));
+        }
+    }
+    appendCookies(headers) {
+        for (const [name, cookie] of this.cookies) {
+            headers.append("cookie", `${name}=${cookie.value}`);
+        }
+    }
+}

package/node_modules/engine.io-client/build/esm/index.d.ts

@@ -0,0 +1,15 @@
+import { Socket } from "./socket.js";
+export { Socket };
+export { SocketOptions, SocketWithoutUpgrade, SocketWithUpgrade, } from "./socket.js";
+export declare const protocol: number;
+export { Transport, TransportError } from "./transport.js";
+export { transports } from "./transports/index.js";
+export { installTimerFunctions } from "./util.js";
+export { parse } from "./contrib/parseuri.js";
+export { nextTick } from "./globals.node.js";
+export { Fetch } from "./transports/polling-fetch.js";
+export { XHR as NodeXHR } from "./transports/polling-xhr.node.js";
+export { XHR } from "./transports/polling-xhr.js";
+export { WS as NodeWebSocket } from "./transports/websocket.node.js";
+export { WS as WebSocket } from "./transports/websocket.js";
+export { WT as WebTransport } from "./transports/webtransport.js";

package/node_modules/engine.io-client/build/esm/index.js

@@ -0,0 +1,15 @@
+import { Socket } from "./socket.js";
+export { Socket };
+export { SocketWithoutUpgrade, SocketWithUpgrade, } from "./socket.js";
+export const protocol = Socket.protocol;
+export { Transport, TransportError } from "./transport.js";
+export { transports } from "./transports/index.js";
+export { installTimerFunctions } from "./util.js";
+export { parse } from "./contrib/parseuri.js";
+export { nextTick } from "./globals.node.js";
+export { Fetch } from "./transports/polling-fetch.js";
+export { XHR as NodeXHR } from "./transports/polling-xhr.node.js";
+export { XHR } from "./transports/polling-xhr.js";
+export { WS as NodeWebSocket } from "./transports/websocket.node.js";
+export { WS as WebSocket } from "./transports/websocket.js";
+export { WT as WebTransport } from "./transports/webtransport.js";

package/node_modules/engine.io-client/build/esm/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "engine.io-client",
+  "type": "module",
+  "browser": {
+    "ws": false,
+    "./transports/polling-xhr.node.js": "./transports/polling-xhr.js",
+    "./transports/websocket.node.js": "./transports/websocket.js",
+    "./globals.node.js": "./globals.js"
+  }
+}

package/node_modules/engine.io-client/build/esm/socket.d.ts

@@ -0,0 +1,482 @@
+import { Emitter } from "@socket.io/component-emitter";
+import type { Packet, BinaryType, RawData } from "engine.io-parser";
+import { CloseDetails, Transport } from "./transport.js";
+import { CookieJar } from "./globals.node.js";
+export interface SocketOptions {
+    /**
+     * The host that we're connecting to. Set from the URI passed when connecting
+     */
+    host?: string;
+    /**
+     * The hostname for our connection. Set from the URI passed when connecting
+     */
+    hostname?: string;
+    /**
+     * If this is a secure connection. Set from the URI passed when connecting
+     */
+    secure?: boolean;
+    /**
+     * The port for our connection. Set from the URI passed when connecting
+     */
+    port?: string | number;
+    /**
+     * Any query parameters in our uri. Set from the URI passed when connecting
+     */
+    query?: {
+        [key: string]: any;
+    };
+    /**
+     * `http.Agent` to use, defaults to `false` (NodeJS only)
+     *
+     * Note: the type should be "undefined | http.Agent | https.Agent | false", but this would break browser-only clients.
+     *
+     * @see https://nodejs.org/api/http.html#httprequestoptions-callback
+     */
+    agent?: string | boolean;
+    /**
+     * Whether the client should try to upgrade the transport from
+     * long-polling to something better.
+     * @default true
+     */
+    upgrade?: boolean;
+    /**
+     * Forces base 64 encoding for polling transport even when XHR2
+     * responseType is available and WebSocket even if the used standard
+     * supports binary.
+     */
+    forceBase64?: boolean;
+    /**
+     * The param name to use as our timestamp key
+     * @default 't'
+     */
+    timestampParam?: string;
+    /**
+     * Whether to add the timestamp with each transport request. Note: this
+     * is ignored if the browser is IE or Android, in which case requests
+     * are always stamped
+     * @default false
+     */
+    timestampRequests?: boolean;
+    /**
+     * A list of transports to try (in order). Engine.io always attempts to
+     * connect directly with the first one, provided the feature detection test
+     * for it passes.
+     *
+     * @default ['polling','websocket', 'webtransport']
+     */
+    transports?: ("polling" | "websocket" | "webtransport" | string)[] | TransportCtor[];
+    /**
+     * Whether all the transports should be tested, instead of just the first one.
+     *
+     * If set to `true`, the client will first try to connect with HTTP long-polling, and then with WebSocket in case of
+     * failure, and finally with WebTransport if the previous attempts have failed.
+     *
+     * If set to `false` (default), if the connection with HTTP long-polling fails, then the client will not test the
+     * other transports and will abort the connection.
+     *
+     * @default false
+     */
+    tryAllTransports?: boolean;
+    /**
+     * If true and if the previous websocket connection to the server succeeded,
+     * the connection attempt will bypass the normal upgrade process and will
+     * initially try websocket. A connection attempt following a transport error
+     * will use the normal upgrade process. It is recommended you turn this on
+     * only when using SSL/TLS connections, or if you know that your network does
+     * not block websockets.
+     * @default false
+     */
+    rememberUpgrade?: boolean;
+    /**
+     * Timeout for xhr-polling requests in milliseconds (0) (only for polling transport)
+     */
+    requestTimeout?: number;
+    /**
+     * Transport options for Node.js client (headers etc)
+     */
+    transportOptions?: Object;
+    /**
+     * (SSL) Certificate, Private key and CA certificates to use for SSL.
+     * Can be used in Node.js client environment to manually specify
+     * certificate information.
+     */
+    pfx?: string;
+    /**
+     * (SSL) Private key to use for SSL. Can be used in Node.js client
+     * environment to manually specify certificate information.
+     */
+    key?: string;
+    /**
+     * (SSL) A string or passphrase for the private key or pfx. Can be
+     * used in Node.js client environment to manually specify certificate
+     * information.
+     */
+    passphrase?: string;
+    /**
+     * (SSL) Public x509 certificate to use. Can be used in Node.js client
+     * environment to manually specify certificate information.
+     */
+    cert?: string;
+    /**
+     * (SSL) An authority certificate or array of authority certificates to
+     * check the remote host against.. Can be used in Node.js client
+     * environment to manually specify certificate information.
+     */
+    ca?: string | string[];
+    /**
+     * (SSL) A string describing the ciphers to use or exclude. Consult the
+     * [cipher format list]
+     * (http://www.openssl.org/docs/apps/ciphers.html#CIPHER_LIST_FORMAT) for
+     * details on the format.. Can be used in Node.js client environment to
+     * manually specify certificate information.
+     */
+    ciphers?: string;
+    /**
+     * (SSL) If true, the server certificate is verified against the list of
+     * supplied CAs. An 'error' event is emitted if verification fails.
+     * Verification happens at the connection level, before the HTTP request
+     * is sent. Can be used in Node.js client environment to manually specify
+     * certificate information.
+     */
+    rejectUnauthorized?: boolean;
+    /**
+     * Headers that will be passed for each request to the server (via xhr-polling and via websockets).
+     * These values then can be used during handshake or for special proxies.
+     */
+    extraHeaders?: {
+        [header: string]: string;
+    };
+    /**
+     * Whether to include credentials (cookies, authorization headers, TLS
+     * client certificates, etc.) with cross-origin XHR polling requests
+     * @default false
+     */
+    withCredentials?: boolean;
+    /**
+     * Whether to automatically close the connection whenever the beforeunload event is received.
+     * @default false
+     */
+    closeOnBeforeunload?: boolean;
+    /**
+     * Whether to always use the native timeouts. This allows the client to
+     * reconnect when the native timeout functions are overridden, such as when
+     * mock clocks are installed.
+     * @default false
+     */
+    useNativeTimers?: boolean;
+    /**
+     * Whether the heartbeat timer should be unref'ed, in order not to keep the Node.js event loop active.
+     *
+     * @see https://nodejs.org/api/timers.html#timeoutunref
+     * @default false
+     */
+    autoUnref?: boolean;
+    /**
+     * parameters of the WebSocket permessage-deflate extension (see ws module api docs). Set to false to disable.
+     * @default false
+     */
+    perMessageDeflate?: {
+        threshold: number;
+    };
+    /**
+     * The path to get our client file from, in the case of the server
+     * serving it
+     * @default '/engine.io'
+     */
+    path?: string;
+    /**
+     * Whether we should add a trailing slash to the request path.
+     * @default true
+     */
+    addTrailingSlash?: boolean;
+    /**
+     * Either a single protocol string or an array of protocol strings. These strings are used to indicate sub-protocols,
+     * so that a single server can implement multiple WebSocket sub-protocols (for example, you might want one server to
+     * be able to handle different types of interactions depending on the specified protocol)
+     * @default []
+     */
+    protocols?: string | string[];
+}
+type TransportCtor = {
+    new (o: any): Transport;
+};
+type BaseSocketOptions = Omit<SocketOptions, "transports"> & {
+    transports: TransportCtor[];
+};
+interface HandshakeData {
+    sid: string;
+    upgrades: string[];
+    pingInterval: number;
+    pingTimeout: number;
+    maxPayload: number;
+}
+interface SocketReservedEvents {
+    open: () => void;
+    handshake: (data: HandshakeData) => void;
+    packet: (packet: Packet) => void;
+    packetCreate: (packet: Packet) => void;
+    data: (data: RawData) => void;
+    message: (data: RawData) => void;
+    drain: () => void;
+    flush: () => void;
+    heartbeat: () => void;
+    ping: () => void;
+    pong: () => void;
+    error: (err: string | Error) => void;
+    upgrading: (transport: Transport) => void;
+    upgrade: (transport: Transport) => void;
+    upgradeError: (err: Error) => void;
+    close: (reason: string, description?: CloseDetails | Error) => void;
+}
+type SocketState = "opening" | "open" | "closing" | "closed";
+interface WriteOptions {
+    compress?: boolean;
+}
+/**
+ * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
+ * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
+ *
+ * This class comes without upgrade mechanism, which means that it will keep the first low-level transport that
+ * successfully establishes the connection.
+ *
+ * In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.
+ *
+ * @example
+ * import { SocketWithoutUpgrade, WebSocket } from "engine.io-client";
+ *
+ * const socket = new SocketWithoutUpgrade({
+ *   transports: [WebSocket]
+ * });
+ *
+ * socket.on("open", () => {
+ *   socket.send("hello");
+ * });
+ *
+ * @see SocketWithUpgrade
+ * @see Socket
+ */
+export declare class SocketWithoutUpgrade extends Emitter<Record<never, never>, Record<never, never>, SocketReservedEvents> {
+    id: string;
+    transport: Transport;
+    binaryType: BinaryType;
+    readyState: SocketState;
+    writeBuffer: Packet[];
+    protected readonly opts: BaseSocketOptions;
+    protected readonly transports: string[];
+    protected upgrading: boolean;
+    protected setTimeoutFn: typeof setTimeout;
+    private _prevBufferLen;
+    private _pingInterval;
+    private _pingTimeout;
+    private _maxPayload?;
+    private _pingTimeoutTimer;
+    /**
+     * The expiration timestamp of the {@link _pingTimeoutTimer} object is tracked, in case the timer is throttled and the
+     * callback is not fired on time. This can happen for example when a laptop is suspended or when a phone is locked.
+     */
+    private _pingTimeoutTime;
+    private clearTimeoutFn;
+    private readonly _beforeunloadEventListener;
+    private readonly _offlineEventListener;
+    private readonly secure;
+    private readonly hostname;
+    private readonly port;
+    private readonly _transportsByName;
+    /**
+     * The cookie jar will store the cookies sent by the server (Node. js only).
+     */
+    readonly _cookieJar: CookieJar;
+    static priorWebsocketSuccess: boolean;
+    static protocol: number;
+    /**
+     * Socket constructor.
+     *
+     * @param {String|Object} uri - uri or options
+     * @param {Object} opts - options
+     */
+    constructor(uri: string | BaseSocketOptions, opts: BaseSocketOptions);
+    /**
+     * Creates transport of the given type.
+     *
+     * @param {String} name - transport name
+     * @return {Transport}
+     * @private
+     */
+    protected createTransport(name: string): Transport;
+    /**
+     * Initializes transport to use and starts probe.
+     *
+     * @private
+     */
+    private _open;
+    /**
+     * Sets the current transport. Disables the existing one (if any).
+     *
+     * @private
+     */
+    protected setTransport(transport: Transport): void;
+    /**
+     * Called when connection is deemed open.
+     *
+     * @private
+     */
+    protected onOpen(): void;
+    /**
+     * Handles a packet.
+     *
+     * @private
+     */
+    private _onPacket;
+    /**
+     * Called upon handshake completion.
+     *
+     * @param {Object} data - handshake obj
+     * @private
+     */
+    protected onHandshake(data: HandshakeData): void;
+    /**
+     * Sets and resets ping timeout timer based on server pings.
+     *
+     * @private
+     */
+    private _resetPingTimeout;
+    /**
+     * Called on `drain` event
+     *
+     * @private
+     */
+    private _onDrain;
+    /**
+     * Flush write buffers.
+     *
+     * @private
+     */
+    protected flush(): void;
+    /**
+     * Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP
+     * long-polling)
+     *
+     * @private
+     */
+    private _getWritablePackets;
+    /**
+     * Checks whether the heartbeat timer has expired but the socket has not yet been notified.
+     *
+     * Note: this method is private for now because it does not really fit the WebSocket API, but if we put it in the
+     * `write()` method then the message would not be buffered by the Socket.IO client.
+     *
+     * @return {boolean}
+     * @private
+     */
+    _hasPingExpired(): boolean;
+    /**
+     * Sends a message.
+     *
+     * @param {String} msg - message.
+     * @param {Object} options.
+     * @param {Function} fn - callback function.
+     * @return {Socket} for chaining.
+     */
+    write(msg: RawData, options?: WriteOptions, fn?: () => void): this;
+    /**
+     * Sends a message. Alias of {@link Socket#write}.
+     *
+     * @param {String} msg - message.
+     * @param {Object} options.
+     * @param {Function} fn - callback function.
+     * @return {Socket} for chaining.
+     */
+    send(msg: RawData, options?: WriteOptions, fn?: () => void): this;
+    /**
+     * Sends a packet.
+     *
+     * @param {String} type: packet type.
+     * @param {String} data.
+     * @param {Object} options.
+     * @param {Function} fn - callback function.
+     * @private
+     */
+    private _sendPacket;
+    /**
+     * Closes the connection.
+     */
+    close(): this;
+    /**
+     * Called upon transport error
+     *
+     * @private
+     */
+    private _onError;
+    /**
+     * Called upon transport close.
+     *
+     * @private
+     */
+    private _onClose;
+}
+/**
+ * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
+ * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
+ *
+ * This class comes with an upgrade mechanism, which means that once the connection is established with the first
+ * low-level transport, it will try to upgrade to a better transport.
+ *
+ * In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.
+ *
+ * @example
+ * import { SocketWithUpgrade, WebSocket } from "engine.io-client";
+ *
+ * const socket = new SocketWithUpgrade({
+ *   transports: [WebSocket]
+ * });
+ *
+ * socket.on("open", () => {
+ *   socket.send("hello");
+ * });
+ *
+ * @see SocketWithoutUpgrade
+ * @see Socket
+ */
+export declare class SocketWithUpgrade extends SocketWithoutUpgrade {
+    private _upgrades;
+    onOpen(): void;
+    /**
+     * Probes a transport.
+     *
+     * @param {String} name - transport name
+     * @private
+     */
+    private _probe;
+    onHandshake(data: HandshakeData): void;
+    /**
+     * Filters upgrades, returning only those matching client transports.
+     *
+     * @param {Array} upgrades - server upgrades
+     * @private
+     */
+    private _filterUpgrades;
+}
+/**
+ * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
+ * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
+ *
+ * This class comes with an upgrade mechanism, which means that once the connection is established with the first
+ * low-level transport, it will try to upgrade to a better transport.
+ *
+ * @example
+ * import { Socket } from "engine.io-client";
+ *
+ * const socket = new Socket();
+ *
+ * socket.on("open", () => {
+ *   socket.send("hello");
+ * });
+ *
+ * @see SocketWithoutUpgrade
+ * @see SocketWithUpgrade
+ */
+export declare class Socket extends SocketWithUpgrade {
+    constructor(uri?: string, opts?: SocketOptions);
+    constructor(opts: SocketOptions);
+}
+export {};