@agentunion/fastaun 0.5.10 → 0.5.11

package/dist/transport.d.ts

@@ -56,6 +56,9 @@ export declare class RPCTransport {
     private _actorTail;
     private _actorBusy;
     private _worker;
+    private _workerReady;
+    private _workerReadyTimer;
+    private _workerDisabled;
     private _workerPending;
     private _workerSeq;
     private _workerConnected;
@@ -72,6 +75,7 @@ export declare class RPCTransport {
         dnsNet?: import('./net.js').DnsResilientNet | null;
     });
     private _startNetworkWorker;
+    private _disableNetworkWorker;
     private _ensureNetworkWorker;
     private _dnsFallbackSnapshot;
     private _handleWorkerEvent;

package/dist/transport.js

@@ -15,6 +15,8 @@ import { isJsonObject } from './types.js';
 const MAX_WS_PAYLOAD_SIZE = 1_000_000;
 const MAX_RPC_INFLIGHT = 16;
 const MAX_BACKGROUND_RPC_INFLIGHT = 8;
+const WORKER_START_TIMEOUT_MS = 2_000;
+const SHORT_RPC_WORKER_START_TIMEOUT_MS = 2_000;
 const _noopLogger = {
     error: () => { },
     warn: () => { },
@@ -402,6 +404,9 @@ export function shortRpcViaNetworkActor(url, method, params) {
     }
     const id = `short-rpc-${crypto.randomUUID()}`;
     let worker = null;
+    let workerReady = false;
+    let workerReadyTimer = null;
+    let localController = null;
     let settled = false;
     let resolveResult;
     let rejectResult;
@@ -410,6 +415,10 @@ export function shortRpcViaNetworkActor(url, method, params) {
         rejectResult = reject;
     });
     const cleanup = () => {
+        if (workerReadyTimer !== null) {
+            clearTimeout(workerReadyTimer);
+            workerReadyTimer = null;
+        }
         const current = worker;
         worker = null;
         if (!current)
@@ -431,12 +440,31 @@ export function shortRpcViaNetworkActor(url, method, params) {
         cleanup();
         rejectResult(error);
     };
+    const fallbackToLocal = () => {
+        if (settled || localController)
+            return;
+        cleanup();
+        localController = new AbortController();
+        void executeShortRpcEnvelope(url, method, params, localController.signal).then(resolveOnce, rejectOnce);
+    };
     try {
         worker = new Worker(new URL(import.meta.url), {
             execArgv: process.execArgv.filter((arg) => !arg.startsWith('--input-type')),
             workerData: { aunShortRpcWorker: true, id, url, method, params },
         });
+        workerReadyTimer = setTimeout(() => {
+            if (!workerReady && !settled)
+                fallbackToLocal();
+        }, SHORT_RPC_WORKER_START_TIMEOUT_MS);
         worker.on('message', (message) => {
+            if (message.type === 'ready' && message.id === id) {
+                workerReady = true;
+                if (workerReadyTimer !== null) {
+                    clearTimeout(workerReadyTimer);
+                    workerReadyTimer = null;
+                }
+                return;
+            }
             if (message.type !== 'reply' || message.id !== id)
                 return;
             if (message.ok && isJsonObject(message.result))
@@ -444,17 +472,29 @@ export function shortRpcViaNetworkActor(url, method, params) {
             else
                 rejectOnce(deserializeWorkerError(message.error));
         });
-        worker.on('error', (error) => rejectOnce(new AuthError(`short RPC worker error: ${error.message}`)));
+        worker.on('error', (error) => {
+            if (!workerReady)
+                fallbackToLocal();
+            else
+                rejectOnce(new AuthError(`short RPC worker error: ${error.message}`));
+        });
         worker.on('exit', (code) => {
-            if (!settled)
+            if (settled)
+                return;
+            if (!workerReady)
+                fallbackToLocal();
+            else
                 rejectOnce(new AuthError(`short RPC worker exited: ${code}`));
         });
     }
     catch (error) {
-        rejectOnce(new AuthError(`short RPC worker unavailable: ${error instanceof Error ? error.message : String(error)}`));
+        fallbackToLocal();
     }
     return Object.assign(promise, {
-        cancel: () => rejectOnce(new AuthError('short RPC cancelled')),
+        cancel: () => {
+            localController?.abort();
+            rejectOnce(new AuthError('short RPC cancelled'));
+        },
     });
 }
 /**
@@ -498,6 +538,9 @@ export class RPCTransport {
     _actorTail = Promise.resolve();
     _actorBusy = false;
     _worker = null;
+    _workerReady = false;
+    _workerReadyTimer = null;
+    _workerDisabled = false;
     _workerPending = new Map();
     _workerSeq = 0;
     _workerConnected = false;
@@ -538,6 +581,8 @@ export class RPCTransport {
         }
     }
     _startNetworkWorker(opts) {
+        if (this._workerDisabled)
+            return;
         try {
             const worker = new Worker(new URL(import.meta.url), {
                 execArgv: process.execArgv.filter((arg) => !arg.startsWith('--input-type')),
@@ -548,9 +593,23 @@ export class RPCTransport {
                 },
             });
             this._worker = worker;
+            this._workerReady = false;
+            this._workerReadyTimer = setTimeout(() => {
+                if (this._worker === worker && !this._workerReady) {
+                    this._disableNetworkWorker(worker, new ConnectionError('transport worker startup timeout'));
+                }
+            }, WORKER_START_TIMEOUT_MS);
             worker.on('message', (message) => {
                 if (this._worker !== worker)
                     return;
+                if (message.type === 'ready') {
+                    this._workerReady = true;
+                    if (this._workerReadyTimer !== null) {
+                        clearTimeout(this._workerReadyTimer);
+                        this._workerReadyTimer = null;
+                    }
+                    return;
+                }
                 if (message.type === 'event') {
                     this._handleWorkerEvent(message);
                     return;
@@ -588,55 +647,69 @@ export class RPCTransport {
                 }
             });
             worker.on('error', (error) => {
-                if (this._worker !== worker)
-                    return;
-                this._worker = null;
-                this._workerConnected = false;
-                this._workerConnecting = false;
-                this._workerGeneration = null;
-                this._workerBufferedEvents = [];
-                for (const pending of this._workerPending.values()) {
-                    if (pending.timer !== null)
-                        clearTimeout(pending.timer);
-                    pending.reject(error);
-                }
-                this._workerPending.clear();
-                this._dispatcher.enqueue('connection.error', { error });
+                this._disableNetworkWorker(worker, error);
             });
             worker.on('exit', (code) => {
-                if (this._worker !== worker)
-                    return;
-                this._worker = null;
-                this._workerConnected = false;
-                this._workerConnecting = false;
-                this._workerGeneration = null;
-                this._workerBufferedEvents = [];
                 const error = new ConnectionError(`transport worker exited: ${code}`);
-                for (const pending of this._workerPending.values()) {
-                    if (pending.timer !== null)
-                        clearTimeout(pending.timer);
-                    pending.reject(error);
-                }
-                this._workerPending.clear();
-                if (code !== 0)
-                    this._dispatcher.enqueue('connection.error', { error: new Error(`transport worker exited: ${code}`) });
+                this._disableNetworkWorker(worker, error);
             });
         }
         catch (error) {
             this._worker = null;
+            this._workerReady = false;
+            if (this._workerReadyTimer !== null) {
+                clearTimeout(this._workerReadyTimer);
+                this._workerReadyTimer = null;
+            }
+            this._workerDisabled = true;
             this._logger.warn(`transport worker unavailable; using local transport: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    _disableNetworkWorker(worker, error) {
+        if (this._worker !== worker)
+            return;
+        const wasConnected = this._workerConnected;
+        this._worker = null;
+        this._workerReady = false;
+        if (this._workerReadyTimer !== null) {
+            clearTimeout(this._workerReadyTimer);
+            this._workerReadyTimer = null;
+        }
+        this._workerDisabled = true;
+        this._workerConnected = false;
+        this._workerConnecting = false;
+        this._workerGeneration = null;
+        this._workerBufferedEvents = [];
+        for (const pending of this._workerPending.values()) {
+            if (pending.timer !== null)
+                clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this._workerPending.clear();
+        void worker.terminate().catch(() => { });
+        if (wasConnected) {
+            this._dispatcher.enqueue('connection.error', { error });
+            this._dispatcher.enqueue('_transport.disconnect', { error, closeCode: 1006 });
+        }
+        else {
+            this._logger.warn(`transport worker unavailable; using local transport: ${error.message}`);
+        }
+    }
     _ensureNetworkWorker() {
-        if (this._worker || !isMainThread || process.env.VITEST || process.env.AUN_TRANSPORT_LOCAL === '1')
+        if (this._worker || this._workerDisabled || !isMainThread || process.env.VITEST || process.env.AUN_TRANSPORT_LOCAL === '1')
             return;
         this._startNetworkWorker(this._workerOptions);
         const worker = this._worker;
         if (!worker)
             return;
-        worker.postMessage({ type: 'set_timeout', value: this._timeout });
-        worker.postMessage({ type: 'set_connect_timeout', value: this._connectTimeout });
-        worker.postMessage({ type: 'set_trace_mode', value: this._traceMode });
+        try {
+            worker.postMessage({ type: 'set_timeout', value: this._timeout });
+            worker.postMessage({ type: 'set_connect_timeout', value: this._connectTimeout });
+            worker.postMessage({ type: 'set_trace_mode', value: this._traceMode });
+        }
+        catch (error) {
+            this._disableNetworkWorker(worker, error instanceof Error ? error : new Error(String(error)));
+        }
     }
     _dnsFallbackSnapshot(url) {
         if (!this._dnsNet)
@@ -702,6 +775,10 @@ export class RPCTransport {
         let posted = false;
         const promise = new Promise((resolve, reject) => {
             const timer = timeoutMs === null ? null : setTimeout(() => {
+                if (!this._workerReady && this._worker === worker) {
+                    this._disableNetworkWorker(worker, new ConnectionError('transport worker startup timeout'));
+                    return;
+                }
                 this._workerPending.delete(id);
                 if (posted) {
                     try {
@@ -720,10 +797,7 @@ export class RPCTransport {
                     posted = true;
                 }
                 catch (error) {
-                    this._workerPending.delete(id);
-                    if (timer !== null)
-                        clearTimeout(timer);
-                    reject(error);
+                    this._disableNetworkWorker(worker, error instanceof Error ? error : new Error(String(error)));
                 }
             };
             if (command.type === 'call')
@@ -753,7 +827,13 @@ export class RPCTransport {
     setTimeout(timeout) {
         this._timeout = timeout;
         if (this._worker) {
-            this._worker.postMessage({ type: 'set_timeout', value: timeout });
+            const worker = this._worker;
+            try {
+                worker.postMessage({ type: 'set_timeout', value: timeout });
+            }
+            catch (error) {
+                this._disableNetworkWorker(worker, error instanceof Error ? error : new Error(String(error)));
+            }
             return;
         }
     }
@@ -761,7 +841,13 @@ export class RPCTransport {
     setConnectTimeout(timeout) {
         this._connectTimeout = timeout;
         if (this._worker) {
-            this._worker.postMessage({ type: 'set_connect_timeout', value: timeout });
+            const worker = this._worker;
+            try {
+                worker.postMessage({ type: 'set_connect_timeout', value: timeout });
+            }
+            catch (error) {
+                this._disableNetworkWorker(worker, error instanceof Error ? error : new Error(String(error)));
+            }
             return;
         }
     }
@@ -787,7 +873,13 @@ export class RPCTransport {
         }
         this._traceMode = mode;
         if (this._worker) {
-            this._worker.postMessage({ type: 'set_trace_mode', value: mode });
+            const worker = this._worker;
+            try {
+                worker.postMessage({ type: 'set_trace_mode', value: mode });
+            }
+            catch (error) {
+                this._disableNetworkWorker(worker, error instanceof Error ? error : new Error(String(error)));
+            }
             return;
         }
     }
@@ -920,6 +1012,9 @@ export class RPCTransport {
                 this._workerConnected = false;
                 this._workerGeneration = null;
                 this._workerBufferedEvents = [];
+                if (this._workerDisabled && this._worker === null) {
+                    return this._enqueueActorStart(() => this._connectLocal(url));
+                }
                 throw error;
             }
         }
@@ -1838,6 +1933,7 @@ export class RPCTransport {
 if (!isMainThread && Boolean(workerData?.aunShortRpcWorker) && parentPort) {
     const command = workerData;
     const controller = new AbortController();
+    parentPort.postMessage({ type: 'ready', id: command.id });
     void executeShortRpcEnvelope(command.url, command.method, command.params, controller.signal)
         .then((result) => parentPort.postMessage({
         type: 'reply', id: command.id, ok: true, result,
@@ -1946,5 +2042,6 @@ if (!isMainThread && Boolean(workerData?.aunTransportWorker) && parentPort) {
                 });
         }
     });
+    parentPort.postMessage({ type: 'ready' });
 }
 //# sourceMappingURL=transport.js.map