@lapis-notes/api 0.1.0

package/dist/plugin-distribution/installer.d.ts

@@ -0,0 +1,89 @@
+import type { DataAdapter } from "../storage/fs";
+import { InstalledPluginStateStore } from "./installed-plugin-state";
+import { type PluginBundleVerificationMode } from "./plugin-bundle-worker";
+import type { InstalledPluginRecord, PluginCatalogDetail, PluginCatalogEntry, PluginCompatibilityInput, PluginProvenance, TrustedSigningKey } from "./types";
+export type PluginBinaryFetch = (url: string, init?: RequestInit) => Promise<PluginBinaryResponse>;
+export type PluginBinaryResponse = Pick<Response, "ok" | "status" | "statusText" | "arrayBuffer" | "text"> & {
+    body?: ReadableStream<Uint8Array> | null;
+};
+export type PluginInstallerProgressPhase = "downloading-bundle" | "verifying-bundle" | "extracting-files" | "verifying-files" | "staging" | "installing" | "loading" | "enabling";
+export interface PluginInstallerProgressEvent {
+    phase: PluginInstallerProgressPhase;
+    message?: string;
+    downloadedBytes?: number;
+    processedBytes?: number;
+    totalBytes?: number;
+    filePath?: string;
+    fileIndex?: number;
+    fileCount?: number;
+}
+export interface PluginInstallerManager {
+    loadPlugin?(pluginPath: string, options?: {
+        provenance?: PluginProvenance;
+    }): Promise<unknown>;
+    enablePlugin?(pluginId: string): Promise<boolean>;
+    disablePlugin?(pluginId: string): Promise<boolean>;
+    isPluginEnabled?(pluginId: string): boolean;
+    getCommunityPluginDiagnostics?(pluginId: string): {
+        state?: string;
+        lastFailureMessage?: string | null;
+    } | null;
+}
+export interface InstallVerifiedPluginOptions {
+    entry: PluginCatalogEntry;
+    detail: PluginCatalogDetail;
+    version?: string;
+    enable?: boolean;
+    registryId?: string;
+    registryUrl?: string;
+    provenance?: PluginProvenance;
+    compatibility?: PluginCompatibilityInput;
+    signal?: AbortSignal;
+    onProgress?: (event: PluginInstallerProgressEvent) => void;
+}
+export interface InstallVerifiedPluginBundleOptions {
+    bundle: ArrayBuffer | Uint8Array;
+    enable?: boolean;
+    registryId?: string;
+    registryUrl?: string;
+    provenance?: PluginProvenance;
+    compatibility?: PluginCompatibilityInput;
+    signal?: AbortSignal;
+    onProgress?: (event: PluginInstallerProgressEvent) => void;
+}
+export interface UninstallVerifiedPluginOptions {
+    removeData?: boolean;
+}
+export declare class VerifiedPluginInstaller {
+    private readonly options;
+    private readonly fetchImpl;
+    private readonly stateStore;
+    constructor(options: {
+        adapter: DataAdapter;
+        trustedKeys: TrustedSigningKey[];
+        pluginsPath?: string;
+        stateStore?: InstalledPluginStateStore;
+        fetch?: PluginBinaryFetch;
+        pluginManager?: PluginInstallerManager;
+        now?: () => Date;
+        bundleVerification?: PluginBundleVerificationMode;
+    });
+    install(options: InstallVerifiedPluginOptions): Promise<InstalledPluginRecord>;
+    installBundle(options: InstallVerifiedPluginBundleOptions): Promise<InstalledPluginRecord>;
+    uninstall(pluginId: string, options?: UninstallVerifiedPluginOptions): Promise<void>;
+    private resolveRelease;
+    private assertReleaseMatchesCatalog;
+    private fetchBundle;
+    private verifyPluginBundle;
+    private installVerifiedBundlePayload;
+    private readBundleResponseBytes;
+    private emitBundleDownloadProgress;
+    private parsePluginManifest;
+    private writeStagingFiles;
+    private swapIntoPlace;
+    private removePluginCodeButKeepData;
+    private removeCommunityPluginEnabledState;
+    private removeIfExists;
+    private get pluginsPath();
+    private now;
+}

package/dist/plugin-distribution/installer.js

@@ -0,0 +1,395 @@
+import { basename, dirname, joinPath } from "../storage/path";
+import { checkReleaseManifestCompatibility } from "./compatibility";
+import { PluginDistributionError } from "./errors";
+import { InstalledPluginStateStore, ensureFolder, } from "./installed-plugin-state";
+import { canUsePluginBundleWorker, verifyPluginBundlePayloadInWorker, } from "./plugin-bundle-worker";
+import { exactArrayBuffer, throwIfAborted, verifyPluginBundlePayload, } from "./plugin-bundle-verifier";
+import { assertPluginIdAllowedForProvenance } from "./reserved-ids";
+import { validatePluginReleaseRuntime } from "./runtime-validation";
+export class VerifiedPluginInstaller {
+    options;
+    fetchImpl;
+    stateStore;
+    constructor(options) {
+        this.options = options;
+        this.fetchImpl =
+            options.fetch ??
+                ((url, init) => globalThis.fetch(url, init));
+        this.stateStore =
+            options.stateStore ??
+                new InstalledPluginStateStore(options.adapter, { now: options.now });
+    }
+    async install(options) {
+        throwIfAborted(options.signal);
+        const release = this.resolveRelease(options.detail, options.version);
+        const bundleUrl = new URL(release.bundle.url, options.entry.detail).toString();
+        const bundle = await this.fetchBundle(bundleUrl, release.bundle, options);
+        const payload = await this.verifyPluginBundle(bundle, {
+            ...options,
+            expectedBundle: release.bundle,
+        });
+        this.assertReleaseMatchesCatalog(options.entry, options.detail, release, payload.releaseManifest);
+        return this.installVerifiedBundlePayload(payload, {
+            enable: options.enable,
+            registryId: options.registryId,
+            registryUrl: options.registryUrl,
+            provenance: options.provenance ?? options.entry.channel,
+            compatibility: options.compatibility,
+            signal: options.signal,
+            onProgress: options.onProgress,
+        });
+    }
+    async installBundle(options) {
+        throwIfAborted(options.signal);
+        const payload = await this.verifyPluginBundle(options.bundle, options);
+        return this.installVerifiedBundlePayload(payload, {
+            ...options,
+            provenance: options.provenance ?? "official",
+        });
+    }
+    async uninstall(pluginId, options = {}) {
+        await this.options.pluginManager?.disablePlugin?.(pluginId);
+        const pluginPath = joinPath(this.pluginsPath, pluginId);
+        if (options.removeData) {
+            await this.removeIfExists(pluginPath);
+        }
+        else {
+            await this.removePluginCodeButKeepData(pluginPath);
+        }
+        await this.removeCommunityPluginEnabledState(pluginId);
+        await this.stateStore.remove(pluginId);
+    }
+    resolveRelease(detail, version) {
+        const release = detail.versions[version ?? detail.latestVersion];
+        if (!release) {
+            throw new PluginDistributionError("metadata-invalid", `No release metadata found for ${detail.id}@${version ?? detail.latestVersion}.`);
+        }
+        return release;
+    }
+    assertReleaseMatchesCatalog(entry, detail, release, manifest) {
+        if (entry.id !== detail.id ||
+            entry.id !== manifest.pluginId ||
+            release.version !== manifest.version ||
+            entry.channel !== manifest.channel) {
+            throw new PluginDistributionError("metadata-invalid", "Release manifest does not match catalog metadata.", {
+                details: {
+                    entryId: entry.id,
+                    detailId: detail.id,
+                    releaseVersion: release.version,
+                    manifestPluginId: manifest.pluginId,
+                    manifestVersion: manifest.version,
+                },
+            });
+        }
+    }
+    async fetchBundle(url, expectedBundle, options) {
+        throwIfAborted(options.signal);
+        const response = await this.fetchImpl(url, { signal: options.signal });
+        if (!response.ok) {
+            throw new PluginDistributionError("metadata-invalid", `Plugin bundle fetch failed for ${url}: ${response.status} ${response.statusText}`, { details: { url, status: response.status } });
+        }
+        const bytes = await this.readBundleResponseBytes(response, {
+            signal: options.signal,
+            onProgress: options.onProgress,
+            totalBytes: expectedBundle.size,
+        });
+        return bytes;
+    }
+    async verifyPluginBundle(bundle, options) {
+        throwIfAborted(options.signal);
+        const verifierOptions = {
+            bundle,
+            trustedKeys: this.options.trustedKeys,
+            expectedBundle: options.expectedBundle,
+            signal: options.signal,
+            onProgress: options.onProgress,
+        };
+        const mode = this.options.bundleVerification ?? "auto";
+        if (mode !== "main-thread" &&
+            (mode === "worker" || canUsePluginBundleWorker())) {
+            try {
+                return await verifyPluginBundlePayloadInWorker(verifierOptions);
+            }
+            catch (error) {
+                if (mode === "worker" || isAbortError(error)) {
+                    throw error;
+                }
+            }
+        }
+        return verifyPluginBundlePayload(verifierOptions);
+    }
+    async installVerifiedBundlePayload(payload, options) {
+        const { releaseEnvelope, releaseManifest, releaseManifestSha256, files } = payload;
+        if (options.compatibility) {
+            const compatibility = checkReleaseManifestCompatibility(releaseManifest, options.compatibility);
+            if (!compatibility.compatible) {
+                throw new PluginDistributionError("compatibility-failed", `Plugin ${releaseManifest.pluginId} is not compatible: ${compatibility.reasons.join(", ")}`, { details: { reasons: compatibility.reasons } });
+            }
+        }
+        const provenance = options.provenance ?? "official";
+        assertPluginIdAllowedForProvenance(releaseManifest.pluginId, provenance);
+        if (provenance === "official" && releaseManifest.channel !== "official") {
+            throw new PluginDistributionError("metadata-invalid", "Official plugin bundle channel does not match installer provenance.");
+        }
+        throwIfAborted(options.signal);
+        options.onProgress?.({
+            phase: "verifying-files",
+            message: "Validating plugin runtime metadata",
+        });
+        const pluginManifest = this.parsePluginManifest(files.get("manifest.json"), releaseManifest);
+        const runtimeValidation = validatePluginReleaseRuntime({
+            releaseManifest,
+            pluginManifest,
+            files,
+            provenance,
+        });
+        if (runtimeValidation.errors.length) {
+            throw new PluginDistributionError("metadata-invalid", `Plugin ${releaseManifest.pluginId} release runtime metadata is invalid: ${runtimeValidation.errors
+                .map((item) => item.message)
+                .join("; ")}`, { details: { diagnostics: runtimeValidation.errors } });
+        }
+        const stagingPath = joinPath(this.pluginsPath, ".installing", `${releaseManifest.pluginId}-${Date.now()}`);
+        const finalPath = joinPath(this.pluginsPath, releaseManifest.pluginId);
+        try {
+            throwIfAborted(options.signal);
+            options.onProgress?.({
+                phase: "staging",
+                message: "Staging plugin files",
+                processedBytes: 0,
+                totalBytes: totalFileBytes(files),
+            });
+            await this.writeStagingFiles(stagingPath, files, {
+                signal: options.signal,
+                onProgress: options.onProgress,
+            });
+            options.onProgress?.({
+                phase: "installing",
+                message: "Installing plugin files",
+            });
+            await this.swapIntoPlace(stagingPath, finalPath);
+        }
+        catch (error) {
+            await this.removeIfExists(stagingPath);
+            if (!(await this.options.adapter.exists(finalPath))) {
+                await this.removeIfExists(finalPath);
+            }
+            throw error;
+        }
+        const now = this.now();
+        const record = {
+            pluginId: releaseManifest.pluginId,
+            installedVersion: releaseManifest.version,
+            installedAt: now,
+            updatedAt: now,
+            provenance,
+            registryId: options.registryId,
+            registryUrl: options.registryUrl,
+            releaseManifestSha256,
+            files: releaseManifest.files.map((file) => ({
+                path: file.path,
+                sha256: file.sha256,
+                size: file.size,
+            })),
+            ...(runtimeValidation.warnings.length
+                ? { runtimeWarnings: runtimeValidation.warnings }
+                : {}),
+            signature: releaseEnvelope.signatures[0],
+            restartRequired: Boolean(this.options.pluginManager),
+        };
+        await this.stateStore.upsert(record);
+        if (this.options.pluginManager?.loadPlugin) {
+            options.onProgress?.({
+                phase: "loading",
+                message: "Loading installed plugin",
+            });
+        }
+        const loaded = await this.options.pluginManager?.loadPlugin?.(finalPath, {
+            provenance,
+        });
+        const shouldEnable = options.enable ?? true;
+        const diagnostics = this.options.pluginManager?.getCommunityPluginDiagnostics?.(releaseManifest.pluginId) ?? null;
+        const cleanDormantExtension = diagnostics?.state === "dormant" &&
+            (diagnostics.lastFailureMessage ?? null) === null;
+        let enabled = false;
+        if (shouldEnable &&
+            (loaded || cleanDormantExtension) &&
+            this.options.pluginManager?.enablePlugin) {
+            options.onProgress?.({
+                phase: "enabling",
+                message: "Enabling installed plugin",
+            });
+            enabled = await this.options.pluginManager.enablePlugin(releaseManifest.pluginId);
+        }
+        record.restartRequired = Boolean(this.options.pluginManager && !loaded && !enabled);
+        await this.stateStore.upsert(record);
+        return record;
+    }
+    async readBundleResponseBytes(response, options) {
+        const progress = {
+            downloadedBytes: 0,
+            totalBytes: options.totalBytes,
+        };
+        if (response.body) {
+            const reader = response.body.getReader();
+            const chunks = [];
+            let byteLength = 0;
+            try {
+                while (true) {
+                    throwIfAborted(options.signal);
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    if (!value)
+                        continue;
+                    chunks.push(value);
+                    byteLength += value.byteLength;
+                    progress.downloadedBytes += value.byteLength;
+                    this.emitBundleDownloadProgress(progress, options);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            return concatChunks(chunks, byteLength);
+        }
+        throwIfAborted(options.signal);
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        throwIfAborted(options.signal);
+        progress.downloadedBytes += bytes.byteLength;
+        this.emitBundleDownloadProgress(progress, options);
+        return bytes;
+    }
+    emitBundleDownloadProgress(progress, options) {
+        options.onProgress?.({
+            phase: "downloading-bundle",
+            message: "Downloading plugin bundle",
+            downloadedBytes: progress.downloadedBytes,
+            totalBytes: progress.totalBytes,
+        });
+    }
+    parsePluginManifest(data, releaseManifest) {
+        if (!data) {
+            throw new PluginDistributionError("metadata-invalid", "Plugin release did not include manifest.json.");
+        }
+        const manifest = JSON.parse(new TextDecoder().decode(data));
+        if (manifest.id !== releaseManifest.pluginId ||
+            manifest.version !== releaseManifest.version) {
+            throw new PluginDistributionError("metadata-invalid", "Plugin manifest id/version does not match the signed release manifest.", {
+                details: {
+                    manifestId: manifest.id,
+                    manifestVersion: manifest.version,
+                    releasePluginId: releaseManifest.pluginId,
+                    releaseVersion: releaseManifest.version,
+                },
+            });
+        }
+        return manifest;
+    }
+    async writeStagingFiles(stagingPath, files, options) {
+        await ensureFolder(this.options.adapter, stagingPath);
+        const entries = [...files.entries()];
+        const fileCount = entries.length;
+        const totalBytes = entries.reduce((sum, [, bytes]) => sum + bytes.byteLength, 0);
+        let processedBytes = 0;
+        for (const [index, [path, bytes]] of entries.entries()) {
+            throwIfAborted(options.signal);
+            const target = joinPath(stagingPath, path);
+            await ensureFolder(this.options.adapter, dirname(target));
+            throwIfAborted(options.signal);
+            await this.options.adapter.writeBinary(target, exactArrayBuffer(bytes));
+            processedBytes += bytes.byteLength;
+            options.onProgress?.({
+                phase: "staging",
+                message: `Staging ${path}`,
+                filePath: path,
+                fileIndex: index + 1,
+                fileCount,
+                processedBytes,
+                totalBytes,
+            });
+        }
+    }
+    async swapIntoPlace(stagingPath, finalPath) {
+        await ensureFolder(this.options.adapter, this.pluginsPath);
+        const backupPath = joinPath(this.pluginsPath, ".installing", `${basename(finalPath)}-backup-${Date.now()}`);
+        const hadExisting = await this.options.adapter.exists(finalPath);
+        if (hadExisting) {
+            await this.options.adapter.rename(finalPath, backupPath);
+        }
+        try {
+            await this.options.adapter.rename(stagingPath, finalPath);
+            if (hadExisting)
+                await this.removeIfExists(backupPath);
+        }
+        catch (error) {
+            if (hadExisting && !(await this.options.adapter.exists(finalPath))) {
+                await this.options.adapter.rename(backupPath, finalPath);
+            }
+            throw error;
+        }
+    }
+    async removePluginCodeButKeepData(pluginPath) {
+        if (!(await this.options.adapter.exists(pluginPath)))
+            return;
+        const listing = await this.options.adapter.list(pluginPath);
+        for (const file of listing.files) {
+            if (file !== "data.json") {
+                await this.options.adapter.remove(joinPath(pluginPath, file));
+            }
+        }
+        for (const folder of listing.folders) {
+            await this.options.adapter.rmdir(joinPath(pluginPath, folder), true);
+        }
+    }
+    async removeCommunityPluginEnabledState(pluginId) {
+        const enabledPath = ".obsidian/community-plugins.json";
+        try {
+            const enabled = JSON.parse(await this.options.adapter.read(enabledPath));
+            if (!Array.isArray(enabled))
+                return;
+            await this.options.adapter.write(enabledPath, JSON.stringify(enabled.filter((id) => id !== pluginId), null, 2));
+        }
+        catch {
+            // Missing or malformed enabled-state files should not block uninstall.
+        }
+    }
+    async removeIfExists(path) {
+        const stat = await this.options.adapter.stat(path);
+        if (!stat)
+            return;
+        if (stat.type === "folder") {
+            await this.options.adapter.rmdir(path, true);
+        }
+        else {
+            await this.options.adapter.remove(path);
+        }
+    }
+    get pluginsPath() {
+        return this.options.pluginsPath ?? ".obsidian/plugins";
+    }
+    now() {
+        return (this.options.now?.() ?? new Date()).toISOString();
+    }
+}
+function concatChunks(chunks, byteLength) {
+    const bytes = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
+function totalFileBytes(files) {
+    let total = 0;
+    for (const bytes of files.values()) {
+        total += bytes.byteLength;
+    }
+    return total;
+}
+function isAbortError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "name" in error &&
+        error.name === "AbortError");
+}

package/dist/plugin-distribution/manager.d.ts

@@ -0,0 +1,128 @@
+import { EventDispatcher } from "../events";
+import type { DataAdapter } from "../storage/fs";
+import { type PluginBinaryFetch, type PluginInstallerManager } from "./installer";
+import type { PluginBundleVerificationMode } from "./plugin-bundle-worker";
+import type { InstalledPluginRecord, PluginCatalogDetail, PluginCatalogEntry, PluginCatalogIndex, PluginCompatibilityResult, PluginPlatform, PluginProvenance, PluginRegistryChannel, PluginRevocationRecord, PluginRegistrySource, TrustedSigningKey } from "./types";
+export type PluginInstallPhase = "resolving" | "fetching-catalog" | "fetching-release" | "verifying-signature" | "downloading-bundle" | "verifying-bundle" | "extracting-files" | "verifying-files" | "staging" | "installing" | "loading" | "enabling" | "complete" | "failed";
+export interface PluginInstallProgressEvent {
+    pluginId: string;
+    phase: PluginInstallPhase;
+    message?: string;
+    downloadedBytes?: number;
+    processedBytes?: number;
+    totalBytes?: number;
+    filePath?: string;
+    fileIndex?: number;
+    fileCount?: number;
+}
+export type PluginInstallProgressListener = (event: PluginInstallProgressEvent) => void;
+export interface PluginSearchQuery {
+    text?: string;
+    category?: string;
+    channel?: PluginRegistryChannel | "all";
+    installed?: boolean;
+    compatibleOnly?: boolean;
+}
+export interface InstallPluginOptions {
+    version?: string;
+    /**
+     * Defaults to true for direct installs. Updates pass the previous enabled
+     * state explicitly so disabled plugins stay disabled.
+     */
+    enable?: boolean;
+    registryId?: string;
+    requireOfficial?: boolean;
+    signal?: AbortSignal;
+}
+export interface InstallPluginBundleOptions {
+    /** Defaults to true for manually selected official bundles. */
+    enable?: boolean;
+    signal?: AbortSignal;
+}
+export interface UpdatePluginOptions {
+    signal?: AbortSignal;
+}
+export interface UninstallPluginOptions {
+    removeData?: boolean;
+}
+export interface PluginUpdateInfo {
+    id: string;
+    name: string;
+    currentVersion: string;
+    latestVersion: string;
+    targetVersion: string;
+    provenance: PluginProvenance;
+    registryId?: string;
+    compatible: boolean;
+    canUpdate: boolean;
+    bundleSize?: number;
+    status: "update-available" | "incompatible" | "revoked";
+    reasons: PluginCompatibilityResult["reasons"];
+    revoked?: PluginRevocationRecord;
+}
+export interface PluginDistributionManager {
+    refreshCatalog(options?: {
+        force?: boolean;
+    }): Promise<PluginCatalogIndex>;
+    search(query?: PluginSearchQuery): PluginCatalogEntry[];
+    getCatalogEntry(pluginId: string): PluginCatalogEntry | undefined;
+    getPluginDetail(pluginId: string): Promise<PluginCatalogDetail | null>;
+    install(pluginId: string, options?: InstallPluginOptions): Promise<InstalledPluginRecord>;
+    installBundle(bundle: ArrayBuffer | Uint8Array, options?: InstallPluginBundleOptions): Promise<InstalledPluginRecord>;
+    update(pluginId: string, version?: string, options?: UpdatePluginOptions): Promise<InstalledPluginRecord | null>;
+    uninstall(pluginId: string, options?: UninstallPluginOptions): Promise<void>;
+    listInstalled(): Promise<InstalledPluginRecord[]>;
+    getInstalled(pluginId: string): Promise<InstalledPluginRecord | null>;
+    listUpdates(): Promise<PluginUpdateInfo[]>;
+    addProgressListener(listener: PluginInstallProgressListener): () => void;
+}
+export interface DefaultPluginDistributionManagerOptions {
+    adapter: DataAdapter;
+    appVersion: string;
+    platform?: PluginPlatform;
+    workspaceTrusted?: () => Promise<boolean> | boolean;
+    registries?: PluginRegistrySource[];
+    trustedKeys?: TrustedSigningKey[];
+    fetch?: PluginBinaryFetch;
+    pluginManager?: PluginInstallerManager;
+    bundleVerification?: PluginBundleVerificationMode;
+}
+export declare const DEFAULT_OFFICIAL_PLUGIN_REGISTRY_SOURCE: PluginRegistrySource;
+export declare const DEFAULT_PLUGIN_REGISTRY_SOURCES: PluginRegistrySource[];
+export declare const EMBEDDED_PLUGIN_REGISTRY_KEYS: TrustedSigningKey[];
+export declare class DefaultPluginDistributionManager extends EventDispatcher<{
+    progress: [PluginInstallProgressEvent];
+}> implements PluginDistributionManager {
+    private readonly options;
+    private catalog;
+    private readonly registryClient;
+    private readonly stateStore;
+    private readonly installer;
+    private readonly registries;
+    private readonly trustedKeys;
+    private installedIds;
+    private revocations;
+    constructor(options: DefaultPluginDistributionManagerOptions);
+    refreshCatalog(_options?: {
+        force?: boolean;
+    }): Promise<PluginCatalogIndex>;
+    search(query?: PluginSearchQuery): PluginCatalogEntry[];
+    getCatalogEntry(pluginId: string): PluginCatalogEntry | undefined;
+    getPluginDetail(pluginId: string): Promise<PluginCatalogDetail | null>;
+    install(pluginId: string, options?: InstallPluginOptions): Promise<InstalledPluginRecord>;
+    installBundle(bundle: ArrayBuffer | Uint8Array, options?: InstallPluginBundleOptions): Promise<InstalledPluginRecord>;
+    update(pluginId: string, version?: string, options?: UpdatePluginOptions): Promise<InstalledPluginRecord | null>;
+    uninstall(pluginId: string, options?: UninstallPluginOptions): Promise<void>;
+    listInstalled(): Promise<InstalledPluginRecord[]>;
+    getInstalled(pluginId: string): Promise<InstalledPluginRecord | null>;
+    listUpdates(): Promise<PluginUpdateInfo[]>;
+    addProgressListener(listener: PluginInstallProgressListener): () => void;
+    private requireEntry;
+    private sourceForEntry;
+    private compatibilityInput;
+    private get platform();
+    private isWorkspaceTrusted;
+    private applyRevocationsToInstalled;
+    private revocationFor;
+    private emitProgress;
+}