@abot-ai/runtime 1.3.1 → 1.5.0

package/dist/src/computer-access/companion/native-replacement.js

@@ -0,0 +1,120 @@
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { promisify } from "node:util";
+import { readLockSnapshot } from "../../runtime/adapters/long-term-memory/file-lock/snapshot.js";
+import { hasSameProcessOwnerIdentity, isProcessOwnerAlive, readProcessOwnerIdentity, } from "./process-owner-identity.js";
+const executeFile = promisify(execFile);
+const STOP_WAIT_MS = 10_000;
+function replacementFailure(reason) {
+    return new Error(`The running Host Companion could not be safely replaced (${reason}). Close the existing Host Companion, then run the updated setup again. The saved pairing was not changed.`);
+}
+async function readReplacementLock(path, dependencies) {
+    try {
+        return await dependencies.readLock(path);
+    }
+    catch {
+        throw replacementFailure("ownership lock unreadable");
+    }
+}
+function requireRecordedOwner(snapshot) {
+    if (snapshot.kind !== "directory")
+        throw replacementFailure("legacy ownership lock");
+    if (!snapshot.record)
+        throw replacementFailure("ownership record unavailable");
+    return snapshot.record;
+}
+function isReclaimableLockWithoutRecord(snapshot) {
+    if (snapshot.kind !== "directory")
+        return false;
+    if (!snapshot.reclaimable)
+        return false;
+    return snapshot.record === undefined;
+}
+function isSameCompanionOwner(snapshot, owner) {
+    if (snapshot.kind !== "directory")
+        return false;
+    if (!snapshot.record)
+        return false;
+    if (snapshot.record.pid !== owner.pid)
+        return false;
+    if (snapshot.record.token !== owner.token)
+        return false;
+    return snapshot.record.ownerIdentity === owner.ownerIdentity;
+}
+async function verifyLiveCompanionOwner(owner, dependencies) {
+    if (!Number.isSafeInteger(owner.pid) || owner.pid <= 0)
+        throw replacementFailure("invalid owner PID");
+    if (owner.pid === dependencies.currentPid)
+        throw replacementFailure("setup owns the companion lock");
+    if (!(await dependencies.isAlive(owner.pid)))
+        return false;
+    if (!owner.ownerIdentity)
+        throw replacementFailure("process identity unavailable");
+    const observed = await dependencies.readIdentity(owner.pid);
+    if (!observed)
+        throw replacementFailure("process identity unreadable");
+    if (!hasSameProcessOwnerIdentity(owner.ownerIdentity, observed))
+        throw replacementFailure("process identity changed");
+    return true;
+}
+async function stopCompanionProcess(owner, dependencies) {
+    try {
+        if (dependencies.platform === "win32") {
+            await dependencies.execute("taskkill.exe", ["/PID", String(owner.pid), "/T", "/F"], {
+                windowsHide: true,
+                timeout: STOP_WAIT_MS,
+                maxBuffer: 4096,
+            });
+            return;
+        }
+        dependencies.signal(owner.pid, "SIGTERM");
+    }
+    catch {
+        if (!(await dependencies.isAlive(owner.pid, owner.ownerIdentity)))
+            return;
+        throw replacementFailure("process could not be stopped");
+    }
+}
+/** Retire only the lock's verified process incarnation; the new owner reclaims its own lock. */
+export async function stopOwnedNativeCompanion(stateDir, overrides = {}) {
+    const dependencies = {
+        platform: process.platform,
+        currentPid: process.pid,
+        readLock: readLockSnapshot,
+        readIdentity: readProcessOwnerIdentity,
+        isAlive: isProcessOwnerAlive,
+        signal: (pid, signal) => {
+            process.kill(pid, signal);
+        },
+        execute: async (file, args, options) => {
+            await executeFile(file, [...args], options);
+        },
+        now: Date.now,
+        delay,
+        ...overrides,
+    };
+    const lockPath = join(stateDir, "agent");
+    const initial = await readReplacementLock(lockPath, dependencies);
+    if (!initial)
+        return;
+    if (isReclaimableLockWithoutRecord(initial))
+        return;
+    const owner = requireRecordedOwner(initial);
+    if (!(await verifyLiveCompanionOwner(owner, dependencies)))
+        return;
+    const current = await readReplacementLock(lockPath, dependencies);
+    if (!current)
+        return;
+    if (!isSameCompanionOwner(current, owner))
+        throw replacementFailure("ownership changed during setup");
+    if (!(await verifyLiveCompanionOwner(owner, dependencies)))
+        return;
+    await stopCompanionProcess(owner, dependencies);
+    const deadline = dependencies.now() + STOP_WAIT_MS;
+    while (await dependencies.isAlive(owner.pid, owner.ownerIdentity)) {
+        if (dependencies.now() >= deadline)
+            throw replacementFailure("process did not stop in time");
+        await dependencies.delay(100);
+    }
+}

package/dist/src/computer-access/companion/native-runtime-installation.d.ts

@@ -0,0 +1,15 @@
+import type { NativeAutostartOptions } from "./autostart.js";
+export declare const NATIVE_RUNTIME_INSTALLATION_FAILURE = "The Mac companion runtime could not be prepared safely. The saved pairing was not changed. Check the local Node.js installation and run setup again.";
+type RuntimeVersionOptions = Readonly<{
+    encoding: "utf8";
+    timeout: number;
+    maxBuffer: number;
+    killSignal: "SIGKILL";
+    windowsHide: true;
+}>;
+export type NativeRuntimeInstallationDependencies = Readonly<{
+    execute(file: string, args: readonly string[], options: RuntimeVersionOptions): Promise<string>;
+}>;
+/** The stopped Mac companion uses one private executable path across Node upgrades. */
+export declare function prepareNativeCompanionRuntime(startup: NativeAutostartOptions, overrides?: Partial<NativeRuntimeInstallationDependencies>): Promise<NativeAutostartOptions>;
+export {};

package/dist/src/computer-access/companion/native-runtime-installation.js

@@ -0,0 +1,218 @@
+import { execFile } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, open, rename, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { assertPrivateRuntimeAccess } from "../../runtime/local-host/private-access.js";
+import { ensurePrivateRuntimeDirectory } from "../../runtime/local-host/private-directory.js";
+const executeFile = promisify(execFile);
+export const NATIVE_RUNTIME_INSTALLATION_FAILURE = "The Mac companion runtime could not be prepared safely. The saved pairing was not changed. Check the local Node.js installation and run setup again.";
+function runtimeInstallationFailure() {
+    return new Error(NATIVE_RUNTIME_INSTALLATION_FAILURE);
+}
+function isAbsentRuntimePath(error) {
+    if (!error || typeof error !== "object" || !("code" in error))
+        return false;
+    return error.code === "ENOENT";
+}
+function hasSameRuntimeIdentity(left, right) {
+    if (left.dev !== right.dev)
+        return false;
+    if (left.ino !== right.ino)
+        return false;
+    if (left.size !== right.size)
+        return false;
+    if (left.mtimeMs !== right.mtimeMs)
+        return false;
+    return left.ctimeMs === right.ctimeMs;
+}
+function hasTrustedRuntimeSource(stat) {
+    if (!stat.isFile())
+        return false;
+    if (stat.isSymbolicLink())
+        return false;
+    if ((stat.mode & 0o111) === 0)
+        return false;
+    if ((stat.mode & 0o022) !== 0)
+        return false;
+    if (stat.uid === 0)
+        return true;
+    return stat.uid === process.getuid?.();
+}
+async function requireManagedRuntimeFile(path, stat) {
+    if (!stat.isFile())
+        throw runtimeInstallationFailure();
+    if (stat.isSymbolicLink())
+        throw runtimeInstallationFailure();
+    if (stat.nlink !== 1)
+        throw runtimeInstallationFailure();
+    if ((stat.mode & 0o777) !== 0o500)
+        throw runtimeInstallationFailure();
+    await assertPrivateRuntimeAccess(path, stat, NATIVE_RUNTIME_INSTALLATION_FAILURE);
+}
+async function streamRuntimeDigest(handle) {
+    const hash = createHash("sha256");
+    for await (const chunk of handle.createReadStream({
+        start: 0,
+        autoClose: false,
+    }))
+        hash.update(chunk);
+    return hash.digest("hex");
+}
+async function readRuntimeFile(path, managed) {
+    const stat = await lstat(path).catch((error) => {
+        if (isAbsentRuntimePath(error))
+            return undefined;
+        throw error;
+    });
+    if (!stat)
+        return undefined;
+    if (managed)
+        await requireManagedRuntimeFile(path, stat);
+    if (!managed && !hasTrustedRuntimeSource(stat))
+        throw runtimeInstallationFailure();
+    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        if (!hasSameRuntimeIdentity(stat, await handle.stat()))
+            throw runtimeInstallationFailure();
+        const digest = await streamRuntimeDigest(handle);
+        if (!hasSameRuntimeIdentity(stat, await handle.stat()))
+            throw runtimeInstallationFailure();
+        if (!hasSameRuntimeIdentity(stat, await lstat(path)))
+            throw runtimeInstallationFailure();
+        return { stat, digest };
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function runtimeVersion(path, dependencies) {
+    const version = (await dependencies.execute(path, ["--version"], {
+        encoding: "utf8",
+        timeout: 5_000,
+        maxBuffer: 1_024,
+        killSignal: "SIGKILL",
+        windowsHide: true,
+    })).trim();
+    if (!/^v\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/u.test(version))
+        throw runtimeInstallationFailure();
+    return version;
+}
+async function requireRuntimeVersion(path, expected, dependencies) {
+    if ((await runtimeVersion(path, dependencies)) !== expected)
+        throw runtimeInstallationFailure();
+}
+async function copyRuntimeSource(source, staged, expected) {
+    const input = await open(source, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        if (!hasSameRuntimeIdentity(expected.stat, await input.stat()))
+            throw runtimeInstallationFailure();
+        const output = await open(staged, constants.O_WRONLY |
+            constants.O_CREAT |
+            constants.O_EXCL |
+            constants.O_NOFOLLOW, 0o600);
+        try {
+            const hash = createHash("sha256");
+            for await (const chunk of input.createReadStream({
+                start: 0,
+                autoClose: false,
+            })) {
+                hash.update(chunk);
+                await output.writeFile(chunk);
+            }
+            if (hash.digest("hex") !== expected.digest)
+                throw runtimeInstallationFailure();
+            if (!hasSameRuntimeIdentity(expected.stat, await input.stat()))
+                throw runtimeInstallationFailure();
+            await output.chmod(0o500);
+            await output.sync();
+        }
+        finally {
+            await output.close();
+        }
+    }
+    finally {
+        await input.close();
+    }
+}
+async function requireUnchangedRuntimeTarget(path, expected) {
+    const current = await readRuntimeFile(path, true);
+    if (!expected) {
+        if (current)
+            throw runtimeInstallationFailure();
+        return;
+    }
+    if (!current)
+        throw runtimeInstallationFailure();
+    if (!hasSameRuntimeIdentity(expected.stat, current.stat))
+        throw runtimeInstallationFailure();
+    if (current.digest !== expected.digest)
+        throw runtimeInstallationFailure();
+}
+async function requireUnchangedRuntimeDirectory(path, expected) {
+    await ensurePrivateRuntimeDirectory(path);
+    const current = await lstat(path);
+    if (expected.dev !== current.dev)
+        throw runtimeInstallationFailure();
+    if (expected.ino !== current.ino)
+        throw runtimeInstallationFailure();
+}
+async function installManagedRuntime(startup, dependencies) {
+    await ensurePrivateRuntimeDirectory(startup.stateDir);
+    const stateIdentity = await lstat(startup.stateDir);
+    const directory = join(startup.stateDir, "runtime");
+    await ensurePrivateRuntimeDirectory(directory);
+    const directoryIdentity = await lstat(directory);
+    const target = join(directory, "node");
+    const source = await readRuntimeFile(startup.nodePath, false);
+    if (!source)
+        throw runtimeInstallationFailure();
+    const existing = await readRuntimeFile(target, true);
+    const expectedVersion = await runtimeVersion(startup.nodePath, dependencies);
+    if (existing?.digest === source.digest) {
+        await requireRuntimeVersion(target, expectedVersion, dependencies);
+        await requireUnchangedRuntimeDirectory(startup.stateDir, stateIdentity);
+        await requireUnchangedRuntimeDirectory(directory, directoryIdentity);
+        await requireUnchangedRuntimeTarget(target, existing);
+        return target;
+    }
+    const staged = join(directory, ".node-" + randomUUID() + ".tmp");
+    try {
+        await copyRuntimeSource(startup.nodePath, staged, source);
+        const stagedFile = await readRuntimeFile(staged, true);
+        if (stagedFile?.digest !== source.digest)
+            throw runtimeInstallationFailure();
+        await requireRuntimeVersion(staged, expectedVersion, dependencies);
+        await requireUnchangedRuntimeTarget(staged, stagedFile);
+        await requireUnchangedRuntimeDirectory(startup.stateDir, stateIdentity);
+        await requireUnchangedRuntimeDirectory(directory, directoryIdentity);
+        await requireUnchangedRuntimeTarget(target, existing);
+        await rename(staged, target);
+        return target;
+    }
+    finally {
+        await unlink(staged).catch((error) => {
+            if (!isAbsentRuntimePath(error))
+                throw error;
+        });
+    }
+}
+/** The stopped Mac companion uses one private executable path across Node upgrades. */
+export async function prepareNativeCompanionRuntime(startup, overrides = {}) {
+    if (startup.platform !== "darwin")
+        return startup;
+    const dependencies = {
+        execute: async (file, args, options) => (await executeFile(file, [...args], options)).stdout,
+        ...overrides,
+    };
+    try {
+        return {
+            ...startup,
+            nodePath: await installManagedRuntime(startup, dependencies),
+        };
+    }
+    catch {
+        throw runtimeInstallationFailure();
+    }
+}

package/dist/src/computer-access/companion/native-session.d.ts

@@ -0,0 +1,23 @@
+import { type NativeNotificationSession } from "./native-notifications.js";
+import { type ObservationCollectorFactory } from "./native-observations.js";
+import type { ToolImplementation } from "../../plugin-sdk/index.js";
+import { type NativeHostResolver } from "./native-address.js";
+import { type HostIdentity } from "./protocol.js";
+export type NativeSessionOutcome = "disconnected" | "authorization_rejected" | "protocol_rejected" | "stopped";
+export type NativeSessionOptions = Readonly<{
+    url: string;
+    authorization: string;
+    identity: HostIdentity;
+    hostId?: string;
+    signal: AbortSignal;
+    onPaired(hostId: string, credential: string): Promise<void>;
+    onReady(hostId: string): void | Promise<void>;
+    resolveHost?: NativeHostResolver;
+    handlers?: Record<string, ToolImplementation>;
+    heartbeatMs?: number;
+    operationLimit?: number;
+    observationCollector?: ObservationCollectorFactory;
+    notifications?: NativeNotificationSession;
+}>;
+/** One connection lifetime. Its pending actions are never retried or replayed. */
+export declare function connectNativeHost(options: NativeSessionOptions): Promise<NativeSessionOutcome>;

package/dist/src/computer-access/companion/native-session.js

@@ -0,0 +1,292 @@
+import WebSocket from "ws";
+import { nativeLoopbackSocketOptions } from "./native-loopback-lookup.js";
+import { DESKTOP_NOTIFICATION_CAPABILITY } from "./notification-protocol.js";
+import { createNativeNotificationSession, } from "./native-notifications.js";
+import { COMPANION_RELEASE_VERSION } from "./release-version.js";
+import { CompanionComputerSessions } from "../computer/companion-sessions.js";
+import { COMPUTER_CAPABILITY } from "../computer/native-validation.js";
+import { NativeObservationSession, } from "./native-observations.js";
+import { OBSERVATION_CAPABILITY, OBSERVATION_WIRE_LIMIT, } from "./observation-protocol.js";
+import { createSystemHandlers } from "../handlers.js";
+import { resolveNativeRuntimeAddress, } from "./native-address.js";
+import { assertNativeOperationTarget, NativeOperationInputError, readNativeServerMessage, } from "./native-messages.js";
+import { HOST_PROTOCOL_VERSION, HOST_WIRE_MAX_BYTES, } from "./protocol.js";
+function operationFailure(message, code) {
+    return {
+        ok: false,
+        output: message,
+        errorCode: code,
+        producedNewInformation: false,
+    };
+}
+function hasHeaderSafeAuthorization(value) {
+    if (value.length < 6 || value.length > 256)
+        return false;
+    return /^[A-Za-z0-9_-]+$/u.test(value);
+}
+/** One connection lifetime. Its pending actions are never retried or replayed. */
+export async function connectNativeHost(options) {
+    if (!hasHeaderSafeAuthorization(options.authorization))
+        throw new Error("Invalid host pairing credential.");
+    options.signal.throwIfAborted();
+    const endpoint = await resolveNativeRuntimeAddress(options.url, options.resolveHost);
+    options.signal.throwIfAborted();
+    const computers = new CompanionComputerSessions(options.identity.os);
+    const notifications = options.notifications ??
+        (await createNativeNotificationSession(options.identity.os, options.url, undefined, options.signal));
+    const ownedNotifications = options.notifications ? undefined : notifications;
+    if (options.signal.aborted) {
+        await ownedNotifications?.close();
+        options.signal.throwIfAborted();
+    }
+    const handlers = options.handlers ?? {
+        ...createSystemHandlers(),
+        ...computers.handlers(),
+        ...notifications.handlers(),
+    };
+    return new Promise((resolve) => {
+        const socket = new WebSocket(endpoint.url, {
+            headers: { Authorization: `Bearer ${options.authorization}` },
+            followRedirects: false,
+            handshakeTimeout: 10_000,
+            maxPayload: HOST_WIRE_MAX_BYTES,
+            perMessageDeflate: false,
+            ...nativeLoopbackSocketOptions(endpoint),
+        });
+        const active = new Map();
+        const seen = new Set();
+        const observations = new NativeObservationSession((message) => {
+            if (socket.bufferedAmount > OBSERVATION_WIRE_LIMIT * 2) {
+                observations.close();
+                stop("disconnected");
+                return;
+            }
+            send(message);
+        }, options.observationCollector);
+        let hostId = options.hostId;
+        let ready = false;
+        let advertisedNotificationReady = false;
+        let stopped = false;
+        let retiring = false;
+        let outcome = "disconnected";
+        let incoming = Promise.resolve();
+        let pendingInbound = 0;
+        let awaitingPong = false;
+        let retirement;
+        const handshake = setTimeout(() => stop("protocol_rejected"), 12_000);
+        const heartbeat = setInterval(() => {
+            if (socket.readyState !== WebSocket.OPEN)
+                return;
+            refreshNotificationCapabilitiesWhenIdle();
+            if (retiring)
+                return;
+            if (awaitingPong) {
+                stop("disconnected");
+                return;
+            }
+            awaitingPong = true;
+            socket.ping();
+        }, options.heartbeatMs ?? 15_000);
+        function stop(reason) {
+            if (stopped)
+                return;
+            stopped = true;
+            outcome = reason;
+            clearTimeout(handshake);
+            clearInterval(heartbeat);
+            if (retirement)
+                clearTimeout(retirement);
+            observations.close();
+            void computers.close();
+            if (!options.notifications)
+                void notifications.close();
+            for (const controller of active.values())
+                controller.abort();
+            socket.terminate();
+        }
+        const abort = () => stop("stopped");
+        options.signal.addEventListener("abort", abort, { once: true });
+        function send(value) {
+            if (stopped || socket.readyState !== WebSocket.OPEN)
+                return;
+            socket.send(JSON.stringify(value));
+        }
+        function sendResult(id, result) {
+            const envelope = { type: "result", id, result };
+            if (Buffer.byteLength(JSON.stringify(envelope)) <= HOST_WIRE_MAX_BYTES) {
+                send(envelope);
+                return;
+            }
+            send({
+                type: "result",
+                id,
+                result: operationFailure("The native operation settled but its result exceeded the transport limit. Inspect the target before repeating an action.", "system_host_result_too_large"),
+            });
+        }
+        function retireConnection(id) {
+            retiring = true;
+            retirement = setTimeout(() => stop("disconnected"), 1_000);
+            socket.send(JSON.stringify({
+                type: "result",
+                id,
+                result: operationFailure("The host connection reached its operation limit. This operation was not dispatched; the companion is reconnecting for future work.", "system_host_connection_refresh"),
+            }), () => socket.close(1012, "operation_limit"));
+        }
+        function canRefreshNotificationCapabilities() {
+            if (!ready)
+                return false;
+            if (stopped)
+                return false;
+            if (retiring)
+                return false;
+            if (pendingInbound !== 0)
+                return false;
+            if (active.size !== 0)
+                return false;
+            if (computers.hasActiveSessions())
+                return false;
+            if (advertisedNotificationReady)
+                return false;
+            return notifications.ready;
+        }
+        function refreshNotificationCapabilitiesWhenIdle() {
+            if (!canRefreshNotificationCapabilities())
+                return;
+            retiring = true;
+            retirement = setTimeout(() => stop("disconnected"), 1_000);
+            // A close frame follows already queued results; active operations finish first.
+            socket.close(1012, "capabilities_changed");
+        }
+        function execute(message) {
+            if (!ready || message.hostId !== hostId)
+                throw new Error("Unbound native operation.");
+            if (seen.has(message.id))
+                throw new Error("Repeated native operation identity.");
+            if (seen.size >= (options.operationLimit ?? 4_096)) {
+                retireConnection(message.id);
+                return;
+            }
+            seen.add(message.id);
+            if (active.size >= 4) {
+                sendResult(message.id, operationFailure("The host companion is busy.", "system_host_busy"));
+                return;
+            }
+            try {
+                assertNativeOperationTarget(message, options.identity.os);
+            }
+            catch (error) {
+                if (!(error instanceof NativeOperationInputError))
+                    throw error;
+                sendResult(message.id, operationFailure(error.message, error.code));
+                return;
+            }
+            const handler = handlers[message.operation];
+            if (!handler)
+                throw new Error("Native operation handler is unavailable.");
+            const controller = new AbortController();
+            active.set(message.id, controller);
+            void Promise.resolve()
+                .then(() => {
+                controller.signal.throwIfAborted();
+                return handler(message.params, { abortSignal: controller.signal });
+            })
+                .then((result) => sendResult(message.id, result), () => {
+                sendResult(message.id, operationFailure("Native operation observation failed; inspect the target before retrying.", "system_host_native_failed"));
+            })
+                .finally(() => {
+                active.delete(message.id);
+                refreshNotificationCapabilitiesWhenIdle();
+            });
+        }
+        async function receive(text) {
+            const message = readNativeServerMessage(text);
+            // A pairing receipt already received on the socket must reach private storage
+            // even if its server closes while the asynchronous write is still pending.
+            if ((stopped || retiring) && message.type !== "paired")
+                return;
+            if (message.type === "paired") {
+                if (hostId || ready)
+                    throw new Error("Unexpected native pairing response.");
+                hostId = message.hostId;
+                await options.onPaired(message.hostId, message.credential);
+                return;
+            }
+            if (message.type === "ready") {
+                if (ready || hostId !== message.hostId)
+                    throw new Error("Native readiness identity mismatch.");
+                ready = true;
+                clearTimeout(handshake);
+                await options.onReady(message.hostId);
+                return;
+            }
+            if (message.type === "cancel") {
+                active.get(message.id)?.abort();
+                return;
+            }
+            if (message.type === "observe_start" ||
+                message.type === "observe_renew" ||
+                message.type === "observe_stop") {
+                if (!ready)
+                    throw new Error("Unbound native observation.");
+                observations.receive(message);
+                return;
+            }
+            if (message.type === "execute")
+                execute(message);
+        }
+        socket.on("open", () => {
+            advertisedNotificationReady = notifications.ready;
+            send({
+                type: "hello",
+                version: HOST_PROTOCOL_VERSION,
+                identity: options.identity,
+                capabilities: [
+                    OBSERVATION_CAPABILITY,
+                    COMPUTER_CAPABILITY,
+                    ...(advertisedNotificationReady
+                        ? [DESKTOP_NOTIFICATION_CAPABILITY]
+                        : []),
+                ],
+                companionVersion: COMPANION_RELEASE_VERSION,
+                ...(hostId ? { hostId } : {}),
+            });
+        });
+        socket.on("message", (data, binary) => {
+            if (binary) {
+                stop("protocol_rejected");
+                return;
+            }
+            pendingInbound++;
+            incoming = incoming
+                .then(() => receive(data.toString()))
+                .catch(() => {
+                outcome = "protocol_rejected";
+                stop("protocol_rejected");
+            })
+                .finally(() => {
+                pendingInbound--;
+                refreshNotificationCapabilitiesWhenIdle();
+            });
+        });
+        socket.on("pong", () => {
+            awaitingPong = false;
+        });
+        socket.on("unexpected-response", (_request, response) => {
+            const rejected = response.statusCode === 401 || response.statusCode === 403;
+            response.destroy();
+            stop(rejected ? "authorization_rejected" : "protocol_rejected");
+        });
+        socket.on("error", () => stop("disconnected"));
+        socket.on("close", (code, reason) => {
+            if (!stopped && code === 1008) {
+                const revoked = ["host_disconnected", "host_revoked"].includes(reason.toString());
+                outcome = revoked ? "authorization_rejected" : "protocol_rejected";
+            }
+            stop(outcome);
+            options.signal.removeEventListener("abort", abort);
+            void incoming.then(() => resolve(outcome));
+        });
+        if (options.signal.aborted)
+            abort();
+    });
+}