@rynx-ai/daemon 0.1.11-beta.3 → 0.1.11-beta.31

package/dist/headless-browser-host.js

@@ -34,6 +34,14 @@ const DEVTOOLS_BROWSER_PATH = /^\/devtools\/browser\/[A-Za-z0-9._~-]+$/;
 const DEVTOOLS_TARGET_ID_PATTERN = /^[A-Za-z0-9._~-]+$/;
 const CONTROL_CHARACTER_PATTERN = /[\u0000-\u001f\u007f]/;
 const CONTROL_CHARACTER_GLOBAL_PATTERN = /[\u0000-\u001f\u007f]/g;
+const NETWORK_AUTO_ATTACH_FILTER = [
+    { type: "page" },
+    { type: "iframe" },
+    { type: "worker" },
+    { type: "service_worker" },
+    { type: "shared_worker" },
+    { exclude: true },
+];
 export function createHeadlessBrowserHost(options = {}) {
     return new HeadlessBrowserHost(options);
 }
@@ -95,7 +103,7 @@ class HeadlessBrowserHost {
             throw error;
         }
         const ownerToken = randomBytes(32).toString("hex");
-        const args = chromeArguments(profileDir, ownerToken, input.url ?? "about:blank");
+        const args = chromeArguments(profileDir, ownerToken);
         let child;
         try {
             child = spawn(build.executablePath, args, {
@@ -198,6 +206,7 @@ class HeadlessBrowserHandle {
     closingTargetIds = new Set();
     pageSessions = new Map();
     targetBySession = new Map();
+    networkTargetTypeBySession = new Map();
     surfaceSources = new Map();
     loadingTargets = new Set();
     activeTargetId = null;
@@ -205,8 +214,11 @@ class HeadlessBrowserHandle {
     closing = false;
     closePromise;
     operations = Promise.resolve();
+    networkOperations = Promise.resolve();
+    requestHeaders;
     constructor(host) {
         this.host = host;
+        this.requestHeaders = cloneRequestHeadersConfig(host.input.requestHeaders ?? { enabled: false, headers: [] });
         this.events = this.eventQueue;
         this.host.connection.setEventHandler((event) => this.onCdpEvent(event));
         this.host.connection.setDisconnectHandler((reason) => this.markUnavailable(reason));
@@ -223,21 +235,22 @@ class HeadlessBrowserHandle {
     }
     async initialize() {
         await this.host.connection.command("Target.setDiscoverTargets", { discover: true });
-        await this.replaceRestoredStartupPages(this.host.input.url ?? "about:blank");
+        await this.host.connection.command("Target.setAutoAttach", {
+            autoAttach: true,
+            waitForDebuggerOnStart: true,
+            flatten: true,
+            filter: NETWORK_AUTO_ATTACH_FILTER,
+        });
+        await this.createFreshStartupPage();
         await this.refreshTargets();
         const requestedUrl = this.host.input.url;
         if (requestedUrl) {
-            let requestedTarget;
-            for (const target of this.targets.values()) {
-                if (target.url === requestedUrl)
-                    requestedTarget = target;
-            }
-            if (requestedTarget) {
-                await this.host.connection.command("Target.activateTarget", {
-                    targetId: requestedTarget.targetId,
-                });
-                this.activeTargetId = requestedTarget.targetId;
-            }
+            const targetId = this.activeTargetId;
+            if (!targetId)
+                throw new Error("Headless Browser startup Page is unavailable");
+            const pageSessionId = await this.pageSession(targetId);
+            await this.host.connection.command("Page.navigate", { url: requestedUrl }, pageSessionId);
+            await this.resetPageNavigationHistory(targetId);
         }
     }
     async getCdpEndpoint() {
@@ -336,10 +349,17 @@ class HeadlessBrowserHandle {
                 if (this.targets.size >= RUNTIME_BROWSER_MAX_PAGES) {
                     throw new SessionBrowserHostError("capacity", "Headless Browser Page capacity was reached");
                 }
-                const result = await this.host.connection.command("Target.createTarget", { url });
+                const result = await this.host.connection.command("Target.createTarget", {
+                    url: "about:blank",
+                });
                 const targetId = requiredCdpId(result.targetId, "Target.createTarget targetId");
                 this.activeTargetId = targetId;
                 await this.refreshTargets();
+                if (url !== "about:blank") {
+                    const pageSessionId = await this.pageSession(targetId);
+                    await this.host.connection.command("Page.navigate", { url }, pageSessionId);
+                    await this.resetPageNavigationHistory(targetId);
+                }
                 this.eventQueue.changed(this.browserGeneration);
             }
             catch (error) {
@@ -395,6 +415,18 @@ class HeadlessBrowserHandle {
     reload(hostPageId) {
         return this.pageCommand(hostPageId, "Page.reload", {});
     }
+    setRequestHeaders(config) {
+        return this.exclusive(async () => {
+            this.ensureAvailable();
+            await this.networkExclusive(async () => {
+                // Every target is permanently Fetch-intercepted before it is resumed.
+                // Swapping this immutable snapshot is therefore the single commit
+                // point for all current and future targets; already-paused/in-flight
+                // requests keep the snapshot they started with.
+                this.requestHeaders = cloneRequestHeadersConfig(config);
+            });
+        });
+    }
     close() {
         if (this.closePromise)
             return this.closePromise;
@@ -434,6 +466,24 @@ class HeadlessBrowserHandle {
             }
         });
     }
+    async resetPageNavigationHistory(targetId) {
+        let lastError;
+        for (let attempt = 0; attempt < PAGE_SNAPSHOT_TRANSITION_ATTEMPTS; attempt += 1) {
+            const sessionId = await this.pageSession(targetId);
+            try {
+                await this.host.connection.command("Page.resetNavigationHistory", {}, sessionId);
+                return;
+            }
+            catch (error) {
+                if (!isMissingTargetError(error) && !isTransientPageTransitionError(error))
+                    throw error;
+                lastError = error;
+                this.dropAttachedSession(sessionId);
+                await delay(PAGE_SNAPSHOT_TRANSITION_POLL_MS);
+            }
+        }
+        throw lastError ?? new Error("Headless Browser could not reset Page navigation history");
+    }
     pageCommand(hostPageId, method, params) {
         return this.exclusive(async () => {
             this.ensureAvailable();
@@ -491,13 +541,23 @@ class HeadlessBrowserHandle {
             throw this.mapOperationError(error);
         }
     }
-    async replaceRestoredStartupPages(url) {
+    async createFreshStartupPage() {
         const initialPages = await this.readPageTargets();
-        if (initialPages.length <= 1)
-            return;
-        const created = await this.host.connection.command("Target.createTarget", { url });
+        for (const page of initialPages) {
+            try {
+                await this.host.connection.command("Target.closeTarget", { targetId: page.targetId });
+            }
+            catch (error) {
+                if (!isMissingPageError(error))
+                    throw error;
+            }
+        }
+        const created = await this.host.connection.command("Target.createTarget", {
+            url: "about:blank",
+        });
         const freshTargetId = requiredCdpId(created.targetId, "Target.createTarget targetId");
         this.activeTargetId = freshTargetId;
+        await this.host.connection.command("Target.activateTarget", { targetId: freshTargetId });
         for (let attempt = 0; attempt < STARTUP_PAGE_CLEANUP_ATTEMPTS; attempt += 1) {
             const pages = await this.readPageTargets();
             if (!pages.some((page) => page.targetId === freshTargetId)) {
@@ -581,11 +641,21 @@ class HeadlessBrowserHandle {
             canGoForward: false,
         };
     }
-    async pageSession(targetId) {
+    async pageSession(targetId, retryMissing = true) {
         this.requireTarget(targetId);
         const existing = this.pageSessions.get(targetId);
-        if (existing)
-            return existing;
+        if (existing) {
+            try {
+                return await existing;
+            }
+            catch (error) {
+                if (!retryMissing || !isMissingPageError(error))
+                    throw error;
+                if (this.pageSessions.get(targetId) === existing)
+                    this.pageSessions.delete(targetId);
+                return this.pageSession(targetId, false);
+            }
+        }
         const pending = (async () => {
             const result = await this.host.connection.command("Target.attachToTarget", {
                 targetId,
@@ -593,7 +663,8 @@ class HeadlessBrowserHandle {
             });
             const sessionId = requiredCdpId(result.sessionId, "Target.attachToTarget sessionId");
             this.targetBySession.set(sessionId, targetId);
-            await this.host.connection.command("Page.enable", {}, sessionId);
+            this.networkTargetTypeBySession.set(sessionId, "page");
+            await this.networkExclusive(() => this.initializeAttachedTarget(sessionId, this.requireTarget(targetId), false));
             return sessionId;
         })();
         this.pageSessions.set(targetId, pending);
@@ -608,6 +679,67 @@ class HeadlessBrowserHandle {
     onCdpEvent(event) {
         if (this.closing || this.unavailableReason)
             return;
+        if (event.method === "Fetch.requestPaused" && event.sessionId) {
+            void this.continuePausedRequest(event.sessionId, event.params).catch((error) => {
+                if (isMissingFetchRequestError(error))
+                    return;
+                if (isMissingTargetError(error) || isTransientPageTransitionError(error)) {
+                    this.dropAttachedSession(event.sessionId);
+                    return;
+                }
+                this.markUnavailable("Headless Browser could not continue an intercepted request");
+            });
+            return;
+        }
+        if (event.method === "Target.attachedToTarget") {
+            const sessionId = optionalCdpId(event.params.sessionId);
+            const target = parseTargetInfo(event.params.targetInfo);
+            if (!sessionId)
+                return;
+            const waitingForDebugger = event.params.waitingForDebugger === true;
+            this.targetBySession.set(sessionId, target.targetId);
+            this.networkTargetTypeBySession.set(sessionId, target.type);
+            if (target.type === "page") {
+                this.targets.set(target.targetId, target);
+                let pending;
+                pending = this.networkExclusive(() => this.initializeAttachedTarget(sessionId, target, waitingForDebugger))
+                    .then(async () => {
+                    const selected = this.pageSessions.get(target.targetId);
+                    if (selected && selected !== pending) {
+                        let selectedSessionId;
+                        try {
+                            selectedSessionId = await selected;
+                        }
+                        catch {
+                            // The next Page operation will establish a replacement.
+                        }
+                        if (selectedSessionId !== sessionId &&
+                            this.targetBySession.get(sessionId) === target.targetId) {
+                            await this.networkExclusive(() => this.detachAuxiliaryPageSession(sessionId));
+                        }
+                    }
+                    return sessionId;
+                })
+                    .catch((error) => {
+                    if (this.pageSessions.get(target.targetId) === pending) {
+                        this.pageSessions.delete(target.targetId);
+                    }
+                    throw error;
+                });
+                void pending.catch(() => undefined);
+                // Chrome may deliver a waitForDebugger auto-attach session while a
+                // manual Target.attachToTarget for the same Page is still pending.
+                // Every physical session must be initialized and resumed even when a
+                // different session already owns semantic Page commands.
+                if (!this.pageSessions.has(target.targetId)) {
+                    this.pageSessions.set(target.targetId, pending);
+                }
+            }
+            else {
+                void this.networkExclusive(() => this.initializeAttachedTarget(sessionId, target, waitingForDebugger)).catch(() => undefined);
+            }
+            return;
+        }
         if (event.method === "Target.targetCreated" || event.method === "Target.targetInfoChanged") {
             const target = parseTargetInfo(event.params.targetInfo);
             if (target.type !== "page")
@@ -640,7 +772,7 @@ class HeadlessBrowserHandle {
         if (event.method === "Target.detachedFromTarget") {
             const sessionId = optionalCdpId(event.params.sessionId);
             if (sessionId)
-                this.dropPageSession(sessionId);
+                this.dropAttachedSession(sessionId);
             return;
         }
         const targetId = event.sessionId ? this.targetBySession.get(event.sessionId) : undefined;
@@ -683,22 +815,106 @@ class HeadlessBrowserHandle {
         this.loadingTargets.delete(targetId);
         const session = this.pageSessions.get(targetId);
         this.pageSessions.delete(targetId);
+        for (const [sessionId, attachedTargetId] of this.targetBySession) {
+            if (attachedTargetId === targetId)
+                this.dropAttachedSession(sessionId);
+        }
+        // A manual attach can resolve after targetDestroyed. Clean the late
+        // session as well instead of retaining it in the Network update set.
         if (session)
-            void session.then((id) => this.targetBySession.delete(id), () => undefined);
+            void session.then((id) => this.dropAttachedSession(id), () => undefined);
     }
     dropPageSession(sessionId) {
         const targetId = this.targetBySession.get(sessionId);
+        this.targetBySession.delete(sessionId);
+        this.networkTargetTypeBySession.delete(sessionId);
         if (!targetId)
             return;
-        this.targetBySession.delete(sessionId);
-        this.pageSessions.delete(targetId);
-        const surface = this.surfaceSources.get(targetId);
-        if (surface) {
-            this.surfaceSources.delete(targetId);
-            surface.closeAfterSourceLoss();
+        const selected = this.pageSessions.get(targetId);
+        if (selected) {
+            void selected.then((selectedSessionId) => {
+                if (selectedSessionId === sessionId &&
+                    this.pageSessions.get(targetId) === selected) {
+                    this.pageSessions.delete(targetId);
+                    const surface = this.surfaceSources.get(targetId);
+                    if (surface) {
+                        this.surfaceSources.delete(targetId);
+                        surface.closeAfterSourceLoss();
+                    }
+                }
+            }, () => undefined);
         }
         this.eventQueue.changed(this.browserGeneration);
     }
+    dropAttachedSession(sessionId) {
+        if (this.networkTargetTypeBySession.get(sessionId) === "page") {
+            this.dropPageSession(sessionId);
+            return;
+        }
+        this.networkTargetTypeBySession.delete(sessionId);
+        this.targetBySession.delete(sessionId);
+    }
+    async initializeAttachedTarget(sessionId, target, waitingForDebugger) {
+        try {
+            await this.host.connection.command("Network.enable", {}, sessionId);
+            await this.host.connection.command("Fetch.enable", {
+                patterns: [{ urlPattern: "*", requestStage: "Request" }],
+            }, sessionId);
+            if (target.type === "page" || target.type === "iframe") {
+                await this.host.connection.command("Target.setAutoAttach", {
+                    autoAttach: true,
+                    waitForDebuggerOnStart: true,
+                    flatten: true,
+                    filter: NETWORK_AUTO_ATTACH_FILTER,
+                }, sessionId);
+            }
+            if (target.type === "page") {
+                await this.host.connection.command("Page.enable", {}, sessionId);
+            }
+            if (waitingForDebugger) {
+                await this.host.connection.command("Runtime.runIfWaitingForDebugger", {}, sessionId);
+            }
+        }
+        catch (error) {
+            if (isMissingTargetError(error) || isTransientPageTransitionError(error)) {
+                this.dropAttachedSession(sessionId);
+                throw missingPage(error);
+            }
+            this.markUnavailable("Headless Browser could not initialize a network target");
+            throw this.mapOperationError(error);
+        }
+    }
+    async detachAuxiliaryPageSession(sessionId) {
+        try {
+            await this.host.connection.command("Target.detachFromTarget", { sessionId });
+        }
+        catch (error) {
+            if (!isMissingTargetError(error) && !isTransientPageTransitionError(error)) {
+                this.markUnavailable("Headless Browser could not fence a duplicate Page session");
+                throw this.mapOperationError(error);
+            }
+        }
+        finally {
+            this.dropAttachedSession(sessionId);
+        }
+    }
+    async continuePausedRequest(sessionId, params) {
+        const requestId = requiredCdpId(params.requestId, "Fetch.requestPaused requestId");
+        const config = this.requestHeaders;
+        const effective = config.enabled && config.headers.length > 0;
+        const request = effective && isRecord(params.request) ? params.request : {};
+        // This is a product-level baseline, not a security boundary: a caller
+        // holding the privileged native CDP endpoint can alter interception.
+        await this.host.connection.command("Fetch.continueRequest", {
+            requestId,
+            // Fetch treats `headers` as a full override. Omitting it is the only
+            // true pass-through path for disabled/empty policy and preserves
+            // Browser-managed Cookie, auth, redirect, and duplicate headers.
+            ...(effective
+                ? { headers: mergePausedRequestHeaders(pausedRequestHeaders(request.headers), config) }
+                : {}),
+        }, sessionId);
+    }
     ensureAvailable() {
         if (this.unavailableReason || this.closing || !this.host.connection.connected) {
             throw new SessionBrowserHostError("unavailable", "Headless Browser is unavailable");
@@ -729,6 +945,11 @@ class HeadlessBrowserHandle {
         this.operations = result.then(() => undefined, () => undefined);
         return result;
     }
+    networkExclusive(operation) {
+        const result = this.networkOperations.then(operation, operation);
+        this.networkOperations = result.then(() => undefined, () => undefined);
+        return result;
+    }
 }
 class HeadlessBrowserSurfaceSource {
     source;
@@ -1476,7 +1697,7 @@ class CdpConnection {
                 this.pending.delete(id);
                 rejectCommand(new CdpCommandTimeoutError(`Native CDP command ${method} timed out`));
             }, this.commandTimeoutMs);
-            this.pending.set(id, { resolve: resolveCommand, reject: rejectCommand, timer });
+            this.pending.set(id, { method, resolve: resolveCommand, reject: rejectCommand, timer });
             try {
                 this.socket.send(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }));
             }
@@ -1518,7 +1739,9 @@ class CdpConnection {
             this.pending.delete(value.id);
             clearTimeout(pending.timer);
             if (isRecord(value.error)) {
-                pending.reject(new CdpProtocolError(typeof value.error.code === "number" ? value.error.code : -1, typeof value.error.message === "string" ? value.error.message : "Native CDP command failed"));
+                pending.reject(new CdpProtocolError(typeof value.error.code === "number" ? value.error.code : -1, `Native CDP command ${pending.method} failed: ${typeof value.error.message === "string"
+                    ? value.error.message
+                    : "Native CDP command failed"}`));
             }
             else {
                 pending.resolve(value.result ?? {});
@@ -1887,7 +2110,7 @@ function readSmallRegularJson(path, maxBytes, label) {
         closeSync(descriptor);
     }
 }
-function chromeArguments(profileDir, ownerToken, url) {
+function chromeArguments(profileDir, ownerToken) {
     return [
         "--headless=new",
         "--use-mock-keychain",
@@ -1905,7 +2128,29 @@ function chromeArguments(profileDir, ownerToken, url) {
         "--metrics-recording-only",
         "--no-report-upload",
         "--window-size=1280,800",
-        url,
+        "--no-startup-window",
+    ];
+}
+function cloneRequestHeadersConfig(config) {
+    return {
+        enabled: config.enabled,
+        headers: config.headers.map((header) => ({ ...header })),
+    };
+}
+function pausedRequestHeaders(value) {
+    if (!isRecord(value))
+        return [];
+    return Object.entries(value).flatMap(([name, headerValue]) => typeof headerValue === "string" ? [{ name, value: headerValue }] : []);
+}
+function mergePausedRequestHeaders(original, config) {
+    if (!config.enabled)
+        return original.map((header) => ({ ...header }));
+    const overriddenNames = new Set(config.headers.map((header) => header.name.toLowerCase()));
+    return [
+        ...original
+            .filter((header) => !overriddenNames.has(header.name.toLowerCase()))
+            .map((header) => ({ ...header })),
+        ...config.headers.map((header) => ({ ...header })),
     ];
 }
 function validateActiveExecutable(build) {
@@ -2118,6 +2363,10 @@ function isTransientPageTransitionError(error) {
         /cannot find (?:an )?execution context/i.test(error.message) ||
         /cannot find context with specified id/i.test(error.message));
 }
+function isMissingFetchRequestError(error) {
+    return error instanceof CdpProtocolError && (/invalid (?:interception|request)id/i.test(error.message) ||
+        /no resource with given identifier/i.test(error.message));
+}
 function isMissingPageError(error) {
     return (error instanceof SessionBrowserHostError && error.code === "page_not_found") || isMissingTargetError(error);
 }

package/dist/lifecycle.d.ts

@@ -4,6 +4,7 @@ export interface StandaloneDaemonLaunchContext {
     builtinSkillsDir: string;
     cliVersion: string;
     productVersion: string;
+    tmuxBin?: string;
 }
 export declare function startDaemon(options: {
     force: boolean;

package/dist/lifecycle.js

@@ -11,6 +11,9 @@ export function startDaemon(options) {
             RYNX_DISTRIBUTION: "standalone",
             RYNX_PRODUCT_VERSION: options.context.productVersion,
             RYNX_DAEMON_LIFECYCLE: "standalone",
+            // An empty value explicitly disables PATH fallback when the optional
+            // platform package is missing, while keeping the control plane runnable.
+            RYNX_TMUX_BIN: options.context.tmuxBin ?? "",
         },
     });
 }

package/dist/migrations/cleanup-legacy-sessions.js

@@ -20,6 +20,7 @@ import { mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import { rynxHome } from "@rynx-ai/core";
 import { db } from "../db.js";
+import { transaction } from "../sqlite.js";
 /** Mirrors the daemon runtime store's default resolution. */
 function defaultProxyDir() {
     return path.join(rynxHome(), ".codex-proxy");
@@ -46,9 +47,9 @@ export function cleanupLegacySessions(opts = {}) {
     let deletedLogRows = 0;
     let deletedSessions = 0;
     let prunedStoreEntries = 0;
-    conn.transaction(() => {
-        deletedLogRows = conn.prepare(`DELETE FROM session_items WHERE ${LEGACY_LOG}`).run().changes;
-        deletedSessions = conn.prepare(`DELETE FROM sessions WHERE ${LEGACY_META}`).run().changes;
+    transaction(conn, () => {
+        deletedLogRows = Number(conn.prepare(`DELETE FROM session_items WHERE ${LEGACY_LOG}`).run().changes);
+        deletedSessions = Number(conn.prepare(`DELETE FROM sessions WHERE ${LEGACY_META}`).run().changes);
     })();
     // The runtime store is daemon-owned. Plugin routing stores remain private to
     // their plugins and are never inspected by this migration.

package/dist/plugin-cli.d.ts

@@ -20,6 +20,16 @@ export interface PluginCliCommandResult {
         stderrTruncated: boolean;
     };
 }
+export interface InstalledPluginListItem {
+    id: string;
+    version: string;
+    source: "local" | "git";
+    state: "enabled" | "disabled";
+}
+/** Read the durable installed-plugin inventory without contacting the daemon. */
+export declare function listInstalledPlugins(): InstalledPluginListItem[];
+/** Render manifest-declared command help without executing plugin code. */
+export declare function installedPluginCommandUsage(pluginId: string): string;
 /** Execute one statically declared, language-neutral plugin command. */
 export declare function runPluginCliCommand(pluginId: string, args: readonly string[], options?: RunPluginCliOptions): Promise<PluginCliCommandResult>;
 export declare function pluginCommandUsage(record: RunnablePluginRecord): string;

package/dist/plugin-cli.js

@@ -3,12 +3,29 @@ import { mkdirSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
 import { createPluginCliInvocationLeaseId, removePluginRuntimeLease, writePluginRuntimeLease, } from "@rynx-ai/plugin-sdk";
 import { db } from "./db.js";
+import { transaction } from "./sqlite.js";
 import { pluginDataDir, pluginRuntimeCacheDir } from "./plugin-installer.js";
 import { validatePluginPackageSnapshot } from "./plugin-package.js";
-import { getPlugin } from "./plugin-store.js";
+import { getPlugin, listPlugins, } from "./plugin-store.js";
 import { loadOrCreateDaemonInstallationIdentitySync } from "./installation-id.js";
 const DEFAULT_TERMINATION_GRACE_MS = 2_000;
 const MAX_TERMINATION_GRACE_MS = 30_000;
+/** Read the durable installed-plugin inventory without contacting the daemon. */
+export function listInstalledPlugins() {
+    return listPlugins().map((record) => ({
+        id: record.canonicalId,
+        version: record.version,
+        source: record.source,
+        state: record.enabled ? "enabled" : "disabled",
+    }));
+}
+/** Render manifest-declared command help without executing plugin code. */
+export function installedPluginCommandUsage(pluginId) {
+    const record = getPlugin(pluginId);
+    if (!record)
+        throw new Error(`plugin "${pluginId}" is not installed`);
+    return pluginCommandUsage(record);
+}
 /** Execute one statically declared, language-neutral plugin command. */
 export async function runPluginCliCommand(pluginId, args, options = {}) {
     const hostEnv = options.env ?? process.env;
@@ -74,7 +91,7 @@ export async function runPluginCliCommand(pluginId, args, options = {}) {
             removePluginRuntimeLease(dataDir, leaseId);
     };
     try {
-        db().transaction(() => {
+        transaction(db(), () => {
             const record = getPlugin(pluginId);
             if (!record)
                 throw new Error(`plugin "${pluginId}" is not installed`);