@alisio/server 0.9.0 → 0.10.0

package/dist/plugins/catalog-service.js

@@ -0,0 +1,306 @@
+/**
+ * The plugin catalog client: one remote JSON document, cached on disk and revalidated only when it
+ * is stale (24 h by default) or the user asks. A revalidation is a conditional request, so an
+ * unchanged catalog costs a 304. Offline with a cache serves the cache; offline without one fails.
+ * Covers are proxied from the catalog origin through a disk cache so the browser never makes a
+ * third-party request (the web UI CSP would block it anyway).
+ */
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { stateHome } from "@alisio/core";
+import { safeUrl, sameOrigin, sanitizeCatalog, } from "./catalog-schema.js";
+export const DEFAULT_CATALOG_URL = "https://gustavogutierrez.github.io/alisio-plugins/catalog.json";
+export const CATALOG_TTL_MS = 24 * 60 * 60 * 1000;
+export const CATALOG_TIMEOUT_MS = 10_000;
+export const MAX_CATALOG_BYTES = 2 * 1024 * 1024;
+export const MAX_COVER_BYTES = 512 * 1024;
+/**
+ * The on-disk form of a sanitized catalog: the cover source goes back under its catalog key so the
+ * cache is validated by the same `sanitizeCatalog` it was produced by.
+ */
+function storable(catalog) {
+    return {
+        ...catalog,
+        plugins: catalog.plugins.map(({ coverSource, ...rest }) => ({
+            ...rest,
+            ...(coverSource ? { cover: coverSource } : {}),
+        })),
+    };
+}
+export class CatalogUnavailableError extends Error {
+}
+/** Image types a cover may have, recognised by their bytes (never by the origin's header). */
+const COVER_TYPES = [
+    { type: "image/svg+xml", ext: "svg" },
+    { type: "image/webp", ext: "webp" },
+    { type: "image/png", ext: "png" },
+    { type: "image/jpeg", ext: "jpg" },
+];
+export function sniffCover(body) {
+    if (body.subarray(0, 4).toString("latin1") === "RIFF" &&
+        body.subarray(8, 12).toString("latin1") === "WEBP")
+        return COVER_TYPES[1];
+    if (body.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])))
+        return COVER_TYPES[2];
+    if (body[0] === 0xff && body[1] === 0xd8 && body[2] === 0xff)
+        return COVER_TYPES[3];
+    if (/<svg[\s>]/i.test(body.toString("utf8", 0, Math.min(body.length, 4096))))
+        return COVER_TYPES[0];
+    return undefined;
+}
+/** Body of `res` as a Buffer, refusing more than `max` bytes. */
+async function readCapped(res, max) {
+    const declared = Number(res.headers.get("content-length") ?? Number.NaN);
+    if (Number.isFinite(declared) && declared > max)
+        throw new Error("The response is too large");
+    if (!res.body)
+        return Buffer.alloc(0);
+    const reader = res.body.getReader();
+    const chunks = [];
+    let size = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        size += value.byteLength;
+        if (size > max) {
+            await reader.cancel().catch(() => { });
+            throw new Error("The response is too large");
+        }
+        chunks.push(Buffer.from(value));
+    }
+    return Buffer.concat(chunks);
+}
+async function writeAtomic(file, data) {
+    await mkdir(join(file, ".."), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, data, { mode: 0o600 });
+        await rename(temporary, file);
+    }
+    catch (error) {
+        await rm(temporary, { force: true }).catch(() => { });
+        throw error;
+    }
+}
+const message = (error) => (error instanceof Error ? error.message : String(error));
+export class CatalogService {
+    options;
+    inflight = new Map();
+    coverInflight = new Map();
+    fetcher;
+    clock;
+    constructor(options = {}) {
+        this.options = options;
+        this.fetcher = options.fetch ?? fetch;
+        this.clock = options.now ?? Date.now;
+    }
+    get url() {
+        return this.options.url ?? process.env.ALISIO_PLUGIN_CATALOG_URL ?? DEFAULT_CATALOG_URL;
+    }
+    get ttl() {
+        return this.options.ttlMs ?? CATALOG_TTL_MS;
+    }
+    get cacheFile() {
+        return join(stateHome(), "cache", "plugin-catalog.json");
+    }
+    coverFile(slug, ext) {
+        return join(stateHome(), "cache", "plugin-covers", `${slug}.${ext}`);
+    }
+    coverMetaFile(slug) {
+        return join(stateHome(), "cache", "plugin-covers", `${slug}.json`);
+    }
+    async readCache() {
+        try {
+            const parsed = JSON.parse(await readFile(this.cacheFile, "utf8"));
+            if (parsed.url !== this.url || !parsed.meta || typeof parsed.meta.checkedAt !== "number")
+                return undefined;
+            // Re-sanitized on every read: the file is a cache on disk, not a trusted source.
+            const catalog = sanitizeCatalog({ schemaVersion: 1, ...parsed.catalog }, this.url);
+            return { url: parsed.url, meta: parsed.meta, catalog };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** The catalog: from cache when fresh, else revalidated (`refresh` forces the check). */
+    get(refresh = false) {
+        const running = this.inflight.get(refresh);
+        if (running)
+            return running;
+        const task = this.load(refresh).finally(() => this.inflight.delete(refresh));
+        this.inflight.set(refresh, task);
+        return task;
+    }
+    async load(refresh) {
+        const cache = await this.readCache();
+        const now = this.clock();
+        if (cache && !refresh && now - cache.meta.checkedAt < this.ttl)
+            return this.result(cache, { fromCache: true, offline: false });
+        try {
+            return await this.revalidate(cache);
+        }
+        catch (error) {
+            if (cache)
+                return this.result(cache, { fromCache: true, offline: true, error: message(error) });
+            throw new CatalogUnavailableError(message(error));
+        }
+    }
+    result(cache, state) {
+        return {
+            catalog: cache.catalog,
+            meta: {
+                checkedAt: cache.meta.checkedAt,
+                fetchedAt: cache.meta.fetchedAt,
+                fromCache: state.fromCache,
+                stale: this.clock() - cache.meta.checkedAt >= this.ttl,
+                offline: state.offline,
+                ...(state.error ? { error: state.error } : {}),
+            },
+        };
+    }
+    async revalidate(cache) {
+        const url = this.url;
+        const target = safeUrl(url, 2048, true);
+        if (!target)
+            throw new Error("The plugin catalog URL must be https");
+        const headers = { Accept: "application/json" };
+        if (cache?.meta.etag)
+            headers["If-None-Match"] = cache.meta.etag;
+        if (cache?.meta.lastModified)
+            headers["If-Modified-Since"] = cache.meta.lastModified;
+        const res = await this.fetcher(url, {
+            headers,
+            signal: AbortSignal.timeout(this.options.timeoutMs ?? CATALOG_TIMEOUT_MS),
+        });
+        this.assertSameOrigin(res, target);
+        const now = this.clock();
+        if (res.status === 304 && cache) {
+            await res.body?.cancel().catch(() => { });
+            const next = { ...cache, meta: { ...cache.meta, checkedAt: now } };
+            await writeAtomic(this.cacheFile, JSON.stringify({ ...next, catalog: storable(next.catalog) })).catch(() => { });
+            return this.result(next, { fromCache: true, offline: false });
+        }
+        if (!res.ok) {
+            await res.body?.cancel().catch(() => { });
+            throw new Error(`The plugin catalog server answered HTTP ${res.status}`);
+        }
+        const raw = await readCapped(res, MAX_CATALOG_BYTES);
+        let parsed;
+        try {
+            parsed = JSON.parse(raw.toString("utf8"));
+        }
+        catch {
+            throw new Error("The plugin catalog is not valid JSON");
+        }
+        const catalog = sanitizeCatalog(parsed, url);
+        const etag = res.headers.get("etag") ?? undefined;
+        const lastModified = res.headers.get("last-modified") ?? undefined;
+        const next = {
+            url,
+            meta: {
+                ...(etag ? { etag } : {}),
+                ...(lastModified ? { lastModified } : {}),
+                fetchedAt: now,
+                checkedAt: now,
+            },
+            catalog,
+        };
+        await writeAtomic(this.cacheFile, JSON.stringify({ ...next, catalog: storable(catalog) })).catch(() => { });
+        return this.result(next, { fromCache: false, offline: false });
+    }
+    assertSameOrigin(res, expected) {
+        if (!res.url)
+            return;
+        let final;
+        try {
+            final = new URL(res.url);
+        }
+        catch {
+            return;
+        }
+        if (!sameOrigin(final, expected))
+            throw new Error("The plugin catalog redirected to another origin");
+    }
+    /** A plugin of the current catalog by slug (cache, revalidated only when stale). */
+    async plugin(slug) {
+        const result = await this.get(false);
+        const plugin = result.catalog.plugins.find((entry) => entry.slug === slug);
+        return plugin ? { plugin, result } : undefined;
+    }
+    /**
+     * The cover SVG of a catalog plugin. It is fetched from the sanitized catalog URL only and kept
+     * on disk; it is revalidated (conditionally) only when the catalog content changed since it was
+     * last checked, and an unreachable origin falls back to the copy on disk.
+     */
+    cover(plugin, catalogFetchedAt) {
+        const key = plugin.slug;
+        const running = this.coverInflight.get(key);
+        if (running)
+            return running;
+        const task = this.loadCover(plugin, catalogFetchedAt).finally(() => this.coverInflight.delete(key));
+        this.coverInflight.set(key, task);
+        return task;
+    }
+    async loadCover(plugin, catalogFetchedAt) {
+        const metaFile = this.coverMetaFile(plugin.slug);
+        let meta = {};
+        let body;
+        try {
+            meta = JSON.parse(await readFile(metaFile, "utf8"));
+            if (meta.ext && COVER_TYPES.some((entry) => entry.ext === meta.ext))
+                body = await readFile(this.coverFile(plugin.slug, meta.ext));
+        }
+        catch {
+            /* no usable copy yet */
+        }
+        const source = plugin.coverSource;
+        if (!source)
+            return undefined;
+        const usable = body !== undefined && meta.source === source && !!meta.contentType;
+        const served = (data, contentType, upstream) => ({
+            body: data,
+            etag: upstream ?? this.etagOf(data),
+            contentType,
+        });
+        if (usable && body && meta.contentType && (meta.checkedAt ?? 0) >= catalogFetchedAt)
+            return served(body, meta.contentType, meta.upstream);
+        try {
+            const headers = {};
+            if (usable && meta.upstream)
+                headers["If-None-Match"] = meta.upstream;
+            const res = await this.fetcher(source, {
+                headers,
+                signal: AbortSignal.timeout(this.options.timeoutMs ?? CATALOG_TIMEOUT_MS),
+            });
+            this.assertSameOrigin(res, new URL(this.url));
+            const now = this.clock();
+            if (res.status === 304 && usable && body && meta.contentType) {
+                await res.body?.cancel().catch(() => { });
+                await writeAtomic(metaFile, JSON.stringify({ ...meta, checkedAt: now })).catch(() => { });
+                return served(body, meta.contentType, meta.upstream);
+            }
+            if (!res.ok) {
+                await res.body?.cancel().catch(() => { });
+                throw new Error(`HTTP ${res.status}`);
+            }
+            const fresh = await readCapped(res, MAX_COVER_BYTES);
+            const kind = sniffCover(fresh);
+            if (!kind)
+                throw new Error("The cover is not an SVG, WebP, PNG or JPEG image");
+            const upstream = res.headers.get("etag") ?? undefined;
+            await writeAtomic(this.coverFile(plugin.slug, kind.ext), fresh).catch(() => { });
+            await writeAtomic(metaFile, JSON.stringify({ source, upstream, checkedAt: now, contentType: kind.type, ext: kind.ext })).catch(() => { });
+            return served(fresh, kind.type, upstream);
+        }
+        catch {
+            return usable && body && meta.contentType
+                ? served(body, meta.contentType, meta.upstream)
+                : undefined;
+        }
+    }
+    etagOf(body) {
+        return `"sha1-${createHash("sha1").update(body).digest("hex")}"`;
+    }
+}

package/dist/plugins/jobs.d.ts

@@ -0,0 +1,41 @@
+export type PhaseId = "uploading" | "validating" | "copying" | "installing" | "registering" | "reloading" | "cleanup";
+export declare const INSTALL_PHASES: readonly PhaseId[];
+export type PhaseStatus = "pending" | "running" | "done" | "failed";
+/** `GET /api/plugins/jobs/:jobId`. */
+export interface JobView {
+    phase?: PhaseId;
+    phases: Array<{
+        id: PhaseId;
+        status: PhaseStatus;
+    }>;
+    done: boolean;
+    error?: string;
+    result?: unknown;
+    logTail?: string;
+}
+export declare const JOB_TTL_MS: number;
+export declare class InstallJob {
+    readonly id: string;
+    private status;
+    private current;
+    private finished;
+    private failure;
+    private outcome;
+    touched: number;
+    constructor(id: string, now: number);
+    /** Marks the running phase done and `phase` running. */
+    start(phase: PhaseId, now?: number): void;
+    succeed(result: unknown, now?: number): void;
+    fail(error: string, logTail?: string, now?: number): void;
+    get done(): boolean;
+    view(): JobView;
+}
+export declare class InstallJobs {
+    private ttlMs;
+    private now;
+    private jobs;
+    constructor(ttlMs?: number, now?: () => number);
+    create(): InstallJob;
+    get(id: string): InstallJob | undefined;
+    private sweep;
+}

package/dist/plugins/jobs.js

@@ -0,0 +1,94 @@
+/**
+ * In-memory install jobs: a local-file install runs in the background and the browser polls its
+ * phase list. Jobs expire 10 minutes after they finish (or start, if they never do).
+ */
+import { randomUUID } from "node:crypto";
+export const INSTALL_PHASES = [
+    "uploading",
+    "validating",
+    "copying",
+    "installing",
+    "registering",
+    "reloading",
+    "cleanup",
+];
+export const JOB_TTL_MS = 10 * 60 * 1000;
+export class InstallJob {
+    id;
+    status = new Map(INSTALL_PHASES.map((id) => [id, "pending"]));
+    current;
+    finished = false;
+    failure;
+    outcome;
+    touched;
+    constructor(id, now) {
+        this.id = id;
+        this.touched = now;
+    }
+    /** Marks the running phase done and `phase` running. */
+    start(phase, now = Date.now()) {
+        if (this.current && this.status.get(this.current) === "running")
+            this.status.set(this.current, "done");
+        // Phases skipped over (the core does not report "uploading") count as done.
+        for (const id of INSTALL_PHASES) {
+            if (id === phase)
+                break;
+            if (this.status.get(id) === "pending")
+                this.status.set(id, "done");
+        }
+        this.status.set(phase, "running");
+        this.current = phase;
+        this.touched = now;
+    }
+    succeed(result, now = Date.now()) {
+        for (const id of INSTALL_PHASES)
+            this.status.set(id, "done");
+        this.finished = true;
+        this.outcome = result;
+        this.touched = now;
+    }
+    fail(error, logTail, now = Date.now()) {
+        if (this.current)
+            this.status.set(this.current, "failed");
+        this.finished = true;
+        this.failure = { error, ...(logTail ? { logTail } : {}) };
+        this.touched = now;
+    }
+    get done() {
+        return this.finished;
+    }
+    view() {
+        return {
+            ...(this.current ? { phase: this.current } : {}),
+            phases: INSTALL_PHASES.map((id) => ({ id, status: this.status.get(id) ?? "pending" })),
+            done: this.finished,
+            ...(this.failure ? this.failure : {}),
+            ...(this.finished && !this.failure ? { result: this.outcome } : {}),
+        };
+    }
+}
+export class InstallJobs {
+    ttlMs;
+    now;
+    jobs = new Map();
+    constructor(ttlMs = JOB_TTL_MS, now = Date.now) {
+        this.ttlMs = ttlMs;
+        this.now = now;
+    }
+    create() {
+        this.sweep();
+        const job = new InstallJob(randomUUID(), this.now());
+        this.jobs.set(job.id, job);
+        return job;
+    }
+    get(id) {
+        this.sweep();
+        return this.jobs.get(id);
+    }
+    sweep() {
+        const cutoff = this.now() - this.ttlMs;
+        for (const [id, job] of this.jobs)
+            if (job.done && job.touched < cutoff)
+                this.jobs.delete(id);
+    }
+}

package/dist/plugins/sdk-version.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Version of the installed `@alisio/sdk`, read from the nearest `package.json` of the package the
+ * server itself resolves. `undefined` when it cannot be found (a standalone binary, say): the
+ * catalog then reports every plugin as compatible instead of guessing.
+ */
+export declare function installedSdkVersion(): string | undefined;

package/dist/plugins/sdk-version.js

@@ -0,0 +1,28 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Version of the installed `@alisio/sdk`, read from the nearest `package.json` of the package the
+ * server itself resolves. `undefined` when it cannot be found (a standalone binary, say): the
+ * catalog then reports every plugin as compatible instead of guessing.
+ */
+export function installedSdkVersion() {
+    try {
+        let dir = dirname(fileURLToPath(import.meta.resolve("@alisio/sdk")));
+        for (let depth = 0; depth < 6; depth++) {
+            try {
+                const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+                if (manifest.name === "@alisio/sdk")
+                    return manifest.version;
+            }
+            catch {
+                /* keep walking up */
+            }
+            dir = dirname(dir);
+        }
+    }
+    catch {
+        /* not resolvable here */
+    }
+    return undefined;
+}

package/dist/plugins/staging.d.ts

@@ -0,0 +1,13 @@
+export declare const STAGING_MAX_AGE_MS: number;
+export declare const stagingRoot: () => string;
+export declare const isStagingId: (value: string) => boolean;
+export declare const stagingDir: (id: string) => string;
+export declare const stagingFile: (id: string) => string;
+export declare function createStaging(): Promise<{
+    id: string;
+    dir: string;
+    file: string;
+}>;
+export declare function removeStaging(id: string): Promise<void>;
+/** Removes staging directories not touched for `maxAgeMs`; returns how many it removed. */
+export declare function sweepStaging(now?: number, maxAgeMs?: number): Promise<number>;

package/dist/plugins/staging.js

@@ -0,0 +1,48 @@
+/**
+ * Staging area of uploaded plugin tarballs: `<stateHome>/tmp/plugin-uploads/<id>/plugin.tgz`.
+ * Everything here is temporary: it is deleted after install, failure or cancel, and directories
+ * older than an hour are swept at server start and before each upload.
+ */
+import { randomUUID } from "node:crypto";
+import { mkdir, readdir, rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { stateHome } from "@alisio/core";
+export const STAGING_MAX_AGE_MS = 60 * 60 * 1000;
+const ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+export const stagingRoot = () => join(stateHome(), "tmp", "plugin-uploads");
+export const isStagingId = (value) => ID.test(value);
+export const stagingDir = (id) => join(stagingRoot(), id);
+export const stagingFile = (id) => join(stagingDir(id), "plugin.tgz");
+export async function createStaging() {
+    const id = randomUUID();
+    await mkdir(stagingDir(id), { recursive: true, mode: 0o700 });
+    return { id, dir: stagingDir(id), file: stagingFile(id) };
+}
+export async function removeStaging(id) {
+    if (isStagingId(id))
+        await rm(stagingDir(id), { recursive: true, force: true });
+}
+/** Removes staging directories not touched for `maxAgeMs`; returns how many it removed. */
+export async function sweepStaging(now = Date.now(), maxAgeMs = STAGING_MAX_AGE_MS) {
+    let removed = 0;
+    let names;
+    try {
+        names = await readdir(stagingRoot());
+    }
+    catch {
+        return 0;
+    }
+    for (const name of names) {
+        const dir = join(stagingRoot(), name);
+        try {
+            if (now - (await stat(dir)).mtimeMs >= maxAgeMs) {
+                await rm(dir, { recursive: true, force: true });
+                removed++;
+            }
+        }
+        catch {
+            /* gone already */
+        }
+    }
+    return removed;
+}

package/dist/routes/plugin-catalog.d.ts

@@ -0,0 +1,103 @@
+import { type InstallRunner } from "@alisio/core";
+import type { Router } from "../http/router.ts";
+import type { CatalogPlugin } from "../plugins/catalog-schema.ts";
+import { type CatalogResult, type CatalogService } from "../plugins/catalog-service.ts";
+import { type JobView } from "../plugins/jobs.ts";
+import type { ManagementContext, WorkspaceRecycler } from "./management.ts";
+export interface PluginCatalogRouteOptions {
+    service: CatalogService;
+    /** Version of the installed `@alisio/sdk` (compatibility checks); unknown = all compatible. */
+    sdkVersion?: string;
+    /** Injected npm for tests; defaults to the real (or bundled) npm. */
+    installRunner?: InstallRunner;
+    /** Upload cap of a local plugin tarball (default 50 MB); tests lower it. */
+    maxUploadBytes?: number;
+    /** How long a finished install job stays readable (default 10 minutes). */
+    jobTtlMs?: number;
+}
+/** `POST /api/plugins/local/inspect`: what the uploaded tarball is, before anything is installed. */
+export interface LocalInspectResponse {
+    /** Present only when the tarball can be installed; pass it to `local/install`. */
+    stagingId?: string;
+    package?: string;
+    version?: string;
+    description?: string;
+    author?: string;
+    license?: string;
+    sdkRange?: string;
+    /** A warning, not a block: private plugins may lag behind the installed SDK. */
+    compatible: boolean;
+    isAlisioPlugin: boolean;
+    reasons: string[];
+    lifecycleScripts: string[];
+    installed?: {
+        version: string;
+        relation: "update" | "same" | "downgrade";
+    };
+    size: number;
+}
+export type LocalInstallJobResponse = {
+    jobId: string;
+};
+export type { JobView };
+/** A catalog plugin as the browser sees it: no remote URLs for the cover, plus its install state. */
+export interface CatalogPluginWire extends Omit<CatalogPlugin, "coverSource"> {
+    /** Same-origin cover URL, absent when the catalog has none. */
+    cover?: string;
+    installedVersion?: string;
+    updateAvailable: boolean;
+    compatible: boolean;
+}
+export interface PluginCatalogResponse {
+    catalog: {
+        generatedAt?: string;
+        categories: Array<{
+            id: string;
+            count: number;
+        }>;
+        plugins: CatalogPluginWire[];
+    };
+    meta: CatalogResult["meta"];
+    installed: Array<{
+        package: string;
+        version: string;
+    }>;
+    sdkVersion?: string;
+}
+export interface PluginInstallResponse {
+    package: string;
+    installedVersion: string;
+    alreadyInstalled: boolean;
+    /** Replaced an installed version (update, reinstall or downgrade). */
+    updated: boolean;
+    previousVersion?: string;
+    /** The plugin loads when the workspace's current runs finish. */
+    restartPending: boolean;
+    /**
+     * The package's code was already imported in this process, and Node keeps it for the process's
+     * lifetime: the new version only runs after Alisio restarts.
+     */
+    restartRequired: boolean;
+}
+export interface PluginUninstallResponse {
+    package: string;
+    removed: boolean;
+    restartPending: boolean;
+}
+export interface InstalledPluginPackage {
+    package: string;
+    version: string;
+    /** Ids of the plugins this package provides in the workspace (empty when it did not load). */
+    pluginIds: string[];
+    removable: boolean;
+    /** Updated on disk, but this process still runs the old code. */
+    restartRequired: boolean;
+    /** Installed from a local `.tgz`: it has no remote source to check for updates. */
+    local: boolean;
+    /** The catalog's version, for a catalog plugin that is not a local package. */
+    latestVersion?: string;
+    updateAvailable: boolean;
+    /** False when the newer version needs a newer `@alisio/sdk` than this Alisio has. */
+    updateCompatible: boolean;
+}
+export declare function registerPluginCatalogRoutes(router: Router, ctx: ManagementContext, recycler: WorkspaceRecycler, options: PluginCatalogRouteOptions): void;