@pdpp/local-collector 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/polyfill-connectors/src/connector-runtime.js

@@ -2,7 +2,8 @@ import { rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { createInterface } from "node:readline";
 import { resolveAuth } from "./auth.js";
-import { manualAction } from "./browser-handoff.js";
+import { DEADLINE_TIMEOUT, manualAction, prepareBrowserInteractionTarget, withDeadline } from "./browser-handoff.js";
+import { flushAndExitAfterRuntimeAck } from "./connector-exit.js";
 import { createCaptureSession } from "./fixture-capture.js";
 import { emitToStdout } from "./safe-emit.js";
 import { resourceSet } from "./scope-filters.js";
@@ -38,6 +39,55 @@ function makeShapeCheckSkip(stream, data, issues) {
         diagnostics: { id: data.id, issues, record: data },
     };
 }
+export function buildDetailCoverageMessage(params) {
+    const { stream, stateStream, requiredKeys, hydratedKeys, gapKeys, optionalSkipKeys, considered, covered } = params;
+    return {
+        type: "DETAIL_COVERAGE",
+        reference_only: true,
+        stream,
+        state_stream: stateStream,
+        required_keys: [...requiredKeys],
+        hydrated_keys: [...hydratedKeys],
+        ...(typeof considered === "number" && Number.isInteger(considered) && considered >= 0 ? { considered } : {}),
+        ...(typeof covered === "number" && Number.isInteger(covered) && covered >= 0 ? { covered } : {}),
+        ...(gapKeys?.length ? { gap_keys: [...gapKeys] } : {}),
+        ...(optionalSkipKeys?.length ? { optional_skip_keys: [...optionalSkipKeys] } : {}),
+    };
+}
+export function emitDetailCoverage(ctx, params) {
+    return ctx.emit(buildDetailCoverageMessage(params));
+}
+export function buildDetailGap(params) {
+    const { stream, recordKey, reason, locator, parentStream, listCursor, error } = params;
+    let errorBlocks = {};
+    if (error) {
+        const sharedBlock = {
+            class: error.class,
+            ...(error.httpStatus == null ? {} : { http_status: error.httpStatus }),
+            ...(error.networkPressure == null ? {} : { network_pressure: error.networkPressure }),
+        };
+        errorBlocks = {
+            detail: sharedBlock,
+            last_error: error.message == null ? sharedBlock : { ...sharedBlock, message: error.message },
+        };
+    }
+    return {
+        type: "DETAIL_GAP",
+        stream,
+        ...(parentStream == null ? {} : { parent_stream: parentStream }),
+        record_key: recordKey,
+        status: "pending",
+        reason,
+        detail_locator: locator,
+        ...(listCursor === undefined ? {} : { list_cursor: listCursor }),
+        retryable: true,
+        reference_only: true,
+        ...errorBlocks,
+    };
+}
+export function emitDetailGap(ctx, params) {
+    return ctx.emit(buildDetailGap(params));
+}
 export const nowIso = () => new Date().toISOString();
 export const politeDelay = (ms) => new Promise((r) => setTimeout(r, ms));
 export function runConnector(config) {
@@ -66,13 +116,7 @@ export function runConnector(config) {
         process.stderr.write(`[capture] ${modeLabel}; writing to ${capture.baseDir}\n`);
     }
     const flushAndExit = (code) => {
-        if (process.stdout.writableLength > 0) {
-            process.stdout.once("drain", () => process.exit(code));
-            setTimeout(() => process.exit(code), 3000).unref();
-        }
-        else {
-            process.exit(code);
-        }
+        flushAndExitAfterRuntimeAck(code);
     };
     let observedCounters = null;
     const emitFailed = (message, retryable = false, records_emitted = observedCounters?.totalEmitted ?? 0) => {
@@ -86,6 +130,8 @@ export function runConnector(config) {
     };
     let interactionCounter = 0;
     const nextInteractionId = () => `int_${Date.now()}_${++interactionCounter}`;
+    let detailGapPageCounter = 0;
+    const nextDetailGapPageRequestId = () => `dgp_${Date.now()}_${++detailGapPageCounter}`;
     let assistanceCounter = 0;
     const nextAssistanceId = () => `asst_${Date.now()}_${++assistanceCounter}`;
     const sendInteraction = (req) => {
@@ -125,6 +171,43 @@ export function runConnector(config) {
             }
         });
     });
+    const requestDetailGapPage = (req = {}) => {
+        const request_id = nextDetailGapPageRequestId();
+        const streams = Array.isArray(req.streams)
+            ? req.streams.filter((stream) => typeof stream === "string" && stream.length > 0)
+            : undefined;
+        const maxBytes = typeof req.maxBytes === "number" && Number.isFinite(req.maxBytes) && req.maxBytes > 0
+            ? Math.floor(req.maxBytes)
+            : undefined;
+        emit({
+            type: "DETAIL_GAPS_PAGE_REQUEST",
+            reference_only: true,
+            request_id,
+            ...(streams && streams.length > 0 ? { streams } : {}),
+            ...(maxBytes ? { max_bytes: maxBytes } : {}),
+        }).catch(() => undefined);
+        return new Promise((resolve, reject) => {
+            const onLine = (line) => {
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed.type !== "DETAIL_GAPS_PAGE_RESPONSE" || parsed.request_id !== request_id) {
+                        return;
+                    }
+                    rl.off("line", onLine);
+                    if (parsed.reference_only !== true || !Array.isArray(parsed.detail_gaps)) {
+                        reject(new Error("Invalid DETAIL_GAPS_PAGE_RESPONSE envelope"));
+                        return;
+                    }
+                    resolve(parsed.detail_gaps);
+                }
+                catch (err) {
+                    rl.off("line", onLine);
+                    reject(err instanceof Error ? err : new Error(String(err)));
+                }
+            };
+            rl.on("line", onLine);
+        });
+    };
     const progress = (message, extra = {}) => emit({ type: "PROGRESS", message, ...extra });
     const assist = async (req) => {
         const assistance_request_id = req.assistance_request_id ?? nextAssistanceId();
@@ -171,6 +254,7 @@ export function runConnector(config) {
             sendInteraction,
             emittedAt,
             detailGaps: startMsg.detail_gaps ?? [],
+            requestDetailGapPage,
         };
         if (browser) {
             await runInBrowser({
@@ -272,12 +356,6 @@ async function runInBrowser(args) {
     const { browser, name, sendInteraction, assist, completeAssistance, progress, ensureSession, probeSession, collect, baseCtx, } = args;
     const { context: ctx, release } = await acquireBrowser(browser, name);
     const visibility = resolveBrowserRuntimeVisibility(browser, name);
-    const browserSendInteraction = makeBrowserInteractionKeepalive({
-        context: ctx,
-        diagnostics: process.env.PDPP_BROWSER_SURFACE_DIAGNOSTICS === "1",
-        progress,
-        sendInteraction: (req) => sendInteraction(decorateBrowserManualAction(req, visibility)),
-    });
     const { withShutdownRelease } = await import("./shutdown-hook.js");
     const tracer = makeTracer(ctx, name, baseCtx.capture);
     let traceFinalized = false;
@@ -295,18 +373,41 @@ async function runInBrowser(args) {
     let page = null;
     try {
         page = await ctx.newPage();
+        const browserSendInteraction = makeBrowserInteractionKeepalive({
+            context: ctx,
+            diagnostics: process.env.PDPP_BROWSER_SURFACE_DIAGNOSTICS === "1",
+            progress,
+            sendInteraction: async (req) => {
+                const decorated = decorateBrowserManualAction(req, visibility);
+                if (decorated.kind !== "otp") {
+                    return sendInteraction(decorated);
+                }
+                const { interactionId } = await prepareBrowserInteractionTarget({
+                    page: page,
+                    reason: "2fa",
+                    ...(decorated.request_id ? { interactionId: decorated.request_id } : {}),
+                });
+                return sendInteraction({ ...decorated, request_id: interactionId });
+            },
+        });
         await captureBrowserPage(baseCtx.capture, page, "runtime-new-page");
         await closeBrowserContextPagesExcept(ctx, page);
-        await establishSession({ ensureSession, probeSession }, {
+        const watchdog = makeSessionEstablishWatchdog({
+            capture: baseCtx.capture,
+            name,
+            page,
+        });
+        await watchdog.run(() => establishSession({ ensureSession, probeSession }, {
             assist,
             capture: baseCtx.capture,
+            checkpoint: watchdog.checkpoint,
             completeAssistance,
             context: ctx,
-            page,
+            page: page,
             name,
             progress,
-            sendInteraction: browserSendInteraction,
-        });
+            sendInteraction: watchdog.wrapSendInteraction(browserSendInteraction),
+        }));
         await captureBrowserPage(baseCtx.capture, page, "runtime-session-established");
         await captureBrowserPage(baseCtx.capture, page, "runtime-collect-start");
         await collect({ ...baseCtx, context: ctx, page, sendInteraction: browserSendInteraction });
@@ -328,7 +429,9 @@ async function runInBrowser(args) {
         baseCtx.capture?.finalize?.();
     }
 }
-export async function captureBrowserPage(capture, page, label) {
+const CAPTURE_DOM_DEADLINE_MS = 10_000;
+const PAGE_CLOSE_DEADLINE_MS = 10_000;
+export async function captureBrowserPage(capture, page, label, deadlineMs = CAPTURE_DOM_DEADLINE_MS) {
     if (!capture) {
         return;
     }
@@ -336,9 +439,13 @@ export async function captureBrowserPage(capture, page, label) {
         process.stderr.write(`[capture] page already closed at ${label}; skipping dom snapshot\n`);
         return;
     }
-    await capture.captureDom(page, label);
+    const captureWork = capture.captureDom(page, label);
+    captureWork.catch(() => undefined);
+    await withDeadline(captureWork, deadlineMs, () => {
+        process.stderr.write(`[capture] dom snapshot for ${label} exceeded ${String(deadlineMs)}ms (wedged renderer?); abandoning this capture.\n`);
+    });
 }
-export async function closeBrowserContextPagesExcept(context, keepPage) {
+export async function closeBrowserContextPagesExcept(context, keepPage, deadlineMs = PAGE_CLOSE_DEADLINE_MS) {
     let pages;
     try {
         pages = context.pages();
@@ -351,22 +458,23 @@ export async function closeBrowserContextPagesExcept(context, keepPage) {
         if (page === keepPage || page.isClosed()) {
             continue;
         }
-        try {
-            await page.close();
+        if (await closeBrowserPage(page, deadlineMs)) {
             closed++;
         }
-        catch {
-        }
     }
     return closed;
 }
-export async function closeBrowserPage(page) {
+export async function closeBrowserPage(page, deadlineMs = PAGE_CLOSE_DEADLINE_MS) {
     if (!page || page.isClosed()) {
         return false;
     }
     try {
-        await page.close();
-        return true;
+        const closeWork = page.close();
+        closeWork.catch(() => undefined);
+        const result = await withDeadline(closeWork, deadlineMs, () => {
+            process.stderr.write(`[browser-runtime] page.close() exceeded ${String(deadlineMs)}ms (wedged renderer?); abandoning close.\n`);
+        });
+        return result !== DEADLINE_TIMEOUT;
     }
     catch {
         return false;
@@ -670,12 +778,113 @@ async function acquireBrowser(browser, name) {
         throw new TerminalError(`could not open browser profile: ${message}`, false);
     }
 }
+const DEFAULT_SESSION_ESTABLISH_WATCHDOG_MS = 120_000;
+const SESSION_ESTABLISH_WATCHDOG_ENV = "PDPP_SESSION_ESTABLISH_WATCHDOG_MS";
+export function resolveSessionEstablishWatchdogMs(env = process.env) {
+    const raw = env[SESSION_ESTABLISH_WATCHDOG_ENV]?.trim();
+    if (!raw) {
+        return DEFAULT_SESSION_ESTABLISH_WATCHDOG_MS;
+    }
+    const parsed = Number.parseInt(raw, 10);
+    if (!(Number.isFinite(parsed) && parsed > 0)) {
+        return DEFAULT_SESSION_ESTABLISH_WATCHDOG_MS;
+    }
+    return parsed;
+}
+export function makeSessionEstablishWatchdog(args) {
+    const now = args.now ?? Date.now;
+    const deadlineMs = args.deadlineMs ?? resolveSessionEstablishWatchdogMs();
+    const pollIntervalMs = args.pollIntervalMs ?? Math.max(1, Math.min(1000, Math.floor(deadlineMs / 4)));
+    let lastProgressAt = now();
+    let lastLabel = null;
+    let openInteractions = 0;
+    let tripped = false;
+    const markProgress = (label) => {
+        lastProgressAt = now();
+        if (label !== null) {
+            lastLabel = label;
+        }
+    };
+    const checkpoint = async (label) => {
+        markProgress(label);
+        try {
+            await captureBrowserPage(args.capture, args.page, `session-establish-${label}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[session-watchdog] checkpoint capture failed for ${label}: ${message}\n`);
+        }
+    };
+    const wrapSendInteraction = (send) => async (req) => {
+        openInteractions++;
+        markProgress(null);
+        try {
+            return await send(req);
+        }
+        finally {
+            openInteractions--;
+            markProgress(null);
+        }
+    };
+    const run = async (work) => {
+        let timer;
+        let tripInfo = null;
+        const TRIP = Symbol("session-establish-trip");
+        const tripPromise = new Promise((resolve) => {
+            const onTick = () => {
+                if (tripped || openInteractions > 0) {
+                    return;
+                }
+                const sinceMs = now() - lastProgressAt;
+                if (sinceMs <= deadlineMs) {
+                    return;
+                }
+                tripped = true;
+                if (timer) {
+                    clearInterval(timer);
+                }
+                tripInfo = { lastLabel, sinceMs };
+                args.onTrip?.(tripInfo);
+                resolve(TRIP);
+            };
+            timer = setInterval(onTick, pollIntervalMs);
+        });
+        const workPromise = work();
+        workPromise.catch(() => undefined);
+        try {
+            const outcome = await Promise.race([workPromise, tripPromise]);
+            if (outcome === TRIP) {
+                const info = tripInfo;
+                const sinceMs = info?.sinceMs ?? deadlineMs;
+                const lastCheckpoint = info?.lastLabel ?? "<none>";
+                throw new TerminalError(`${args.name}_session_establish_timeout: no session-establishment progress for ${String(sinceMs)}ms ` +
+                    `(last checkpoint: ${lastCheckpoint}); failing run closed`, true);
+            }
+        }
+        finally {
+            if (timer) {
+                clearInterval(timer);
+            }
+        }
+    };
+    return { checkpoint, wrapSendInteraction, run };
+}
 async function establishSession(hooks, args) {
     const { ensureSession, probeSession } = hooks;
-    const { assist, capture, completeAssistance, context, page, name, sendInteraction, progress } = args;
+    const { assist, capture, checkpoint, completeAssistance, context, page, name, sendInteraction, progress } = args;
+    await checkpoint("session-establish:begin");
     if (typeof ensureSession === "function") {
         try {
-            await ensureSession({ assist, capture, completeAssistance, context, page, sendInteraction, progress });
+            await ensureSession({
+                assist,
+                capture,
+                checkpoint,
+                completeAssistance,
+                context,
+                page,
+                sendInteraction,
+                progress,
+            });
             return;
         }
         catch (err) {
@@ -686,6 +895,7 @@ async function establishSession(hooks, args) {
     if (typeof probeSession !== "function") {
         return;
     }
+    await checkpoint("session-establish:probe");
     if (await probeSession({ context, page })) {
         return;
     }
@@ -695,6 +905,7 @@ async function establishSession(hooks, args) {
         message: `${name} session expired. Open the browser and re-authenticate, then continue.`,
         timeoutSeconds: 1800,
     }, sendInteraction);
+    await checkpoint("session-establish:probe-after-manual");
     if (await probeSession({ context, page })) {
         return;
     }

package/dist/polyfill-connectors/src/fingerprint-cursor.js

@@ -0,0 +1,107 @@
+import { createHash } from "node:crypto";
+export function openCarryForwardCursor(prior) {
+    const next = new Map(prior);
+    const seen = new Set();
+    return {
+        prior(id) {
+            return prior.get(id);
+        },
+        note(id, value) {
+            next.set(id, value);
+            seen.add(id);
+        },
+        pruneStale() {
+            for (const id of next.keys()) {
+                if (!seen.has(id)) {
+                    next.delete(id);
+                }
+            }
+        },
+        size() {
+            return next.size;
+        },
+        toState() {
+            const out = {};
+            for (const [id, value] of next) {
+                out[id] = value;
+            }
+            return out;
+        },
+    };
+}
+export function recordFingerprint(record, excludeKeys = []) {
+    const exclude = new Set(excludeKeys);
+    return createHash("sha1").update(stableStringify(record, exclude)).digest("hex");
+}
+export function openFingerprintCursor(priorState, options = {}) {
+    const staticExcludeKeys = options.excludeFromFingerprint ?? [];
+    const resolveExcludeKeys = options.resolveExcludeFromFingerprint;
+    const prior = options.priorFingerprints ?? decodePriorFingerprints(priorState);
+    const cursor = openCarryForwardCursor(prior);
+    return {
+        shouldEmit(data) {
+            const rawId = data.id;
+            if (rawId == null) {
+                return true;
+            }
+            const id = String(rawId);
+            if (id.length === 0) {
+                return true;
+            }
+            const record = data;
+            const excludeKeys = resolveExcludeKeys ? resolveExcludeKeys(record) : staticExcludeKeys;
+            const fingerprint = recordFingerprint(record, excludeKeys);
+            cursor.note(id, fingerprint);
+            return cursor.prior(id) !== fingerprint;
+        },
+        priorFingerprint(id) {
+            return cursor.prior(id);
+        },
+        pruneStale() {
+            cursor.pruneStale();
+        },
+        toState() {
+            return cursor.toState();
+        },
+        size() {
+            return cursor.size();
+        },
+    };
+}
+function decodePriorFingerprints(priorState) {
+    const out = new Map();
+    if (!priorState || typeof priorState !== "object" || Array.isArray(priorState)) {
+        return out;
+    }
+    const raw = priorState.fingerprints;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return out;
+    }
+    for (const [id, value] of Object.entries(raw)) {
+        if (typeof value === "string" && value.length > 0) {
+            out.set(id, value);
+        }
+    }
+    return out;
+}
+function compareKeys(a, b) {
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}
+function stableStringify(value, exclude) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value) ?? "null";
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((v) => stableStringify(v, exclude)).join(",")}]`;
+    }
+    const entries = Object.entries(value)
+        .filter(([k]) => !exclude.has(k))
+        .sort(([a], [b]) => compareKeys(a, b));
+    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v, exclude)}`).join(",")}}`;
+}

package/dist/polyfill-connectors/src/local-device-client.d.ts

@@ -12,7 +12,9 @@ export interface LocalDeviceClientOptions {
     deviceId?: string;
     deviceToken?: string;
     fetchImpl?: typeof fetch;
+    requestTimeoutMs?: number;
 }
+export declare const DEFAULT_LOCAL_DEVICE_REQUEST_TIMEOUT_MS = 120000;
 export interface EnrollmentExchangeRequest {
     device_label?: string;
     enrollment_code: string;
@@ -35,8 +37,17 @@ export interface HeartbeatOutboxDiagnostics {
     succeeded: number;
     total: number;
 }
+export interface HeartbeatLastError {
+    kind: "state_read_failed" | "dead_letter_backlog";
+    top_dead_letter_classes?: {
+        count: number;
+        error_class: string;
+    }[];
+}
 export interface HeartbeatRequest {
+    agent_version?: string;
     connector_id: string;
+    last_error?: HeartbeatLastError | null;
     outbox?: HeartbeatOutboxDiagnostics;
     records_pending?: number;
     source_instance_id: string;
@@ -105,10 +116,16 @@ export interface RecoverLocalCollectorGapRequest {
 }
 export declare class LocalDeviceHttpError extends Error {
     readonly body: string;
+    readonly envelopeMessage: string | null;
+    readonly param: string | null;
     readonly status: number;
     readonly code: string | null;
     constructor(status: number, body: string);
 }
+export declare class LocalDeviceRequestTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
 export declare class LocalDeviceClient {
     #private;
     constructor(options: LocalDeviceClientOptions);

package/dist/polyfill-connectors/src/local-device-client.js

@@ -7,18 +7,23 @@ export const LOCAL_DEVICE_ENDPOINTS = {
     localCollectorGapRecovered: (deviceId, sourceInstanceId) => `/_ref/device-exporters/${encodeURIComponent(deviceId)}/source-instances/${encodeURIComponent(sourceInstanceId)}/local-collector-gaps/recovered`,
     sourceInstanceState: (deviceId, sourceInstanceId) => `/_ref/device-exporters/${encodeURIComponent(deviceId)}/source-instances/${encodeURIComponent(sourceInstanceId)}/state`,
 };
+export const DEFAULT_LOCAL_DEVICE_REQUEST_TIMEOUT_MS = 120_000;
 export class LocalDeviceHttpError extends Error {
     body;
+    envelopeMessage;
+    param;
     status;
     code;
     constructor(status, body) {
         const parsed = parseLocalDeviceErrorEnvelope(body);
-        const detail = parsed?.code ? ` ${parsed.code}` : "";
+        const detail = formatLocalDeviceErrorDetail(parsed);
         super(`local device request failed: ${status}${detail}`);
         this.name = "LocalDeviceHttpError";
         this.status = status;
         this.body = body;
         this.code = parsed?.code ?? null;
+        this.param = parsed?.param ?? null;
+        this.envelopeMessage = parsed?.message ?? null;
     }
 }
 function parseLocalDeviceErrorEnvelope(body) {
@@ -28,23 +33,55 @@ function parseLocalDeviceErrorEnvelope(body) {
     try {
         const parsed = JSON.parse(body);
         if (parsed && typeof parsed === "object" && parsed.error && typeof parsed.error.code === "string") {
-            return { code: parsed.error.code };
+            return {
+                code: parsed.error.code,
+                message: typeof parsed.error.message === "string" ? sanitizeErrorDetail(parsed.error.message) : null,
+                param: typeof parsed.error.param === "string" ? sanitizeErrorDetail(parsed.error.param) : null,
+            };
         }
     }
     catch {
     }
     return null;
 }
+function formatLocalDeviceErrorDetail(parsed) {
+    if (!parsed) {
+        return "";
+    }
+    const parts = [parsed.code];
+    if (parsed.param) {
+        parts.push(`param=${parsed.param}`);
+    }
+    if (parsed.message) {
+        parts.push(`message=${parsed.message}`);
+    }
+    return ` ${parts.join(" ")}`;
+}
+const ERROR_DETAIL_SECRET_RE = /\b(authorization|bearer|token|password|passwd|cookie|secret|otp|api[_-]?key)\b\s*[:=]\s*["']?[^"',\s}]+/gi;
+function sanitizeErrorDetail(value) {
+    const compact = value.replace(ERROR_DETAIL_SECRET_RE, "$1=[REDACTED]").replace(/\s+/g, " ").trim();
+    return compact.length > 160 ? `${compact.slice(0, 159)}…` : compact;
+}
+export class LocalDeviceRequestTimeoutError extends Error {
+    timeoutMs;
+    constructor(timeoutMs) {
+        super(`local device request timed out after ${timeoutMs}ms`);
+        this.name = "LocalDeviceRequestTimeoutError";
+        this.timeoutMs = timeoutMs;
+    }
+}
 export class LocalDeviceClient {
     #baseUrl;
     #deviceId;
     #deviceToken;
     #fetch;
+    #requestTimeoutMs;
     constructor(options) {
         this.#baseUrl = new URL(options.baseUrl);
         this.#deviceId = options.deviceId;
         this.#deviceToken = options.deviceToken;
         this.#fetch = options.fetchImpl ?? fetch;
+        this.#requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_LOCAL_DEVICE_REQUEST_TIMEOUT_MS;
     }
     exchangeEnrollment(request) {
         return this.#request(LOCAL_DEVICE_ENDPOINTS.exchangeEnrollment, {
@@ -119,14 +156,37 @@ export class LocalDeviceClient {
         if (options.body !== undefined) {
             init.body = JSON.stringify(options.body);
         }
-        const response = await this.#fetch(new URL(path, this.#baseUrl), init);
-        const text = await response.text();
-        if (!response.ok) {
-            throw new LocalDeviceHttpError(response.status, text);
+        const controller = this.#requestTimeoutMs > 0 ? new AbortController() : null;
+        const timer = controller
+            ? setTimeout(() => controller.abort(new LocalDeviceRequestTimeoutError(this.#requestTimeoutMs)), this.#requestTimeoutMs)
+            : null;
+        if (controller) {
+            init.signal = controller.signal;
         }
-        if (!text) {
-            return { ok: true };
+        try {
+            const response = await this.#fetch(new URL(path, this.#baseUrl), init);
+            const text = await response.text();
+            if (!response.ok) {
+                throw new LocalDeviceHttpError(response.status, text);
+            }
+            if (!text) {
+                return { ok: true };
+            }
+            return JSON.parse(text);
+        }
+        catch (error) {
+            if (controller?.signal.aborted) {
+                const reason = controller.signal.reason;
+                throw reason instanceof LocalDeviceRequestTimeoutError
+                    ? reason
+                    : new LocalDeviceRequestTimeoutError(this.#requestTimeoutMs);
+            }
+            throw error;
+        }
+        finally {
+            if (timer) {
+                clearTimeout(timer);
+            }
         }
-        return JSON.parse(text);
     }
 }