@lapis-notes/api 0.1.0

package/dist/plugin-distribution/schemas.js

@@ -0,0 +1,299 @@
+import { z } from "zod";
+import { PluginDistributionError } from "./errors";
+const isoDate = z.string().datetime({ offset: true });
+const sha256 = z.string().regex(/^[a-fA-F0-9]{64}$/);
+const nonEmpty = z.string().min(1);
+const urlOrRelative = z.string().min(1);
+const httpsUrl = z.string().url().startsWith("https://");
+export const registryTrustTierSchema = z.enum([
+    "official",
+    "community",
+    "local",
+]);
+export const pluginProvenanceSchema = z.enum([
+    "bundled",
+    "official",
+    "community",
+    "manual",
+    "development",
+]);
+export const pluginRegistryChannelSchema = z.enum(["official", "community"]);
+export const pluginPlatformSchema = z.enum(["web", "electron", "desktop"]);
+export const pluginBadgeSchema = z.enum([
+    "official",
+    "verified",
+    "community",
+    "desktop-only",
+    "requires-trust",
+    "update-available",
+    "revoked",
+]);
+export const signatureRecordSchema = z.object({
+    keyId: nonEmpty,
+    alg: z.literal("ed25519"),
+    sig: nonEmpty,
+});
+export const trustedSigningKeySchema = z.object({
+    keyId: nonEmpty,
+    alg: z.literal("ed25519"),
+    publicKey: nonEmpty,
+    trustTier: registryTrustTierSchema,
+    expiresAt: isoDate.optional(),
+});
+export const remoteFileReferenceSchema = z
+    .object({
+    url: urlOrRelative,
+    sha256,
+    size: z.number().int().nonnegative().optional(),
+})
+    .passthrough();
+export const pluginReleaseFileSchema = z
+    .object({
+    path: nonEmpty,
+    sha256,
+    size: z.number().int().nonnegative(),
+})
+    .passthrough();
+const pluginReleaseRuntimeHostFields = {
+    workspace: true,
+    electronRenderer: true,
+    electronSidecar: true,
+    desktop: true,
+    trustedDesktop: true,
+};
+export const pluginReleaseModuleFormatSchema = z.enum([
+    "esm",
+    "commonjs",
+    "node-esm",
+]);
+export const pluginReleaseRuntimeEntryDescriptorSchema = z
+    .object({
+    path: nonEmpty,
+    format: pluginReleaseModuleFormatSchema,
+    fallbackPath: nonEmpty.optional(),
+    sharedDependencies: z.array(nonEmpty).optional(),
+    requiresReloadOnUpdate: z.boolean().optional(),
+})
+    .passthrough();
+export const pluginReleaseRuntimeEntriesSchema = z
+    .object(Object.fromEntries(Object.keys(pluginReleaseRuntimeHostFields).map((field) => [
+    field,
+    pluginReleaseRuntimeEntryDescriptorSchema.optional(),
+])))
+    .passthrough();
+export const pluginReleaseRuntimeSharedDependenciesSchema = z
+    .object(Object.fromEntries(Object.keys(pluginReleaseRuntimeHostFields).map((field) => [
+    field,
+    z.array(nonEmpty).optional(),
+])))
+    .passthrough();
+export const pluginReleaseRuntimeCompatibilityOverridesSchema = z
+    .object({
+    deprecatedHostModules: pluginReleaseRuntimeSharedDependenciesSchema.optional(),
+})
+    .passthrough();
+export const pluginReleaseRuntimeMetadataSchema = z
+    .object({
+    entries: pluginReleaseRuntimeEntriesSchema.optional(),
+    sharedDependencies: pluginReleaseRuntimeSharedDependenciesSchema.optional(),
+    compatibilityOverrides: pluginReleaseRuntimeCompatibilityOverridesSchema.optional(),
+})
+    .passthrough();
+export const pluginReleaseRuntimeDiagnosticSchema = z
+    .object({
+    severity: z.enum(["error", "warning"]),
+    code: z.enum([
+        "lapis-manifest-invalid",
+        "runtime-metadata-missing",
+        "runtime-metadata-mismatch",
+        "runtime-entry-file-missing",
+        "runtime-entry-format-mismatch",
+        "runtime-fallback-file-missing",
+        "runtime-fallback-format-mismatch",
+        "runtime-main-missing",
+        "runtime-commonjs-not-allowed",
+        "runtime-dependency-unknown",
+        "runtime-dependency-private",
+        "runtime-dependency-platform-unsupported",
+        "runtime-dependency-undeclared",
+        "runtime-dependency-deprecated",
+        "runtime-legacy-commonjs",
+    ]),
+    message: nonEmpty,
+    details: z.record(z.unknown()).optional(),
+})
+    .passthrough();
+export const pluginContributionSummarySchema = z
+    .object({
+    commands: z
+        .array(z.object({ id: nonEmpty, name: nonEmpty }).passthrough())
+        .optional(),
+    editorViews: z
+        .array(z
+        .object({
+        id: nonEmpty,
+        filenamePatterns: z.array(nonEmpty).optional(),
+        extensions: z.array(nonEmpty).optional(),
+        mimeTypes: z.array(nonEmpty).optional(),
+    })
+        .passthrough())
+        .optional(),
+    markdownProcessors: z
+        .array(z.object({ id: nonEmpty, name: nonEmpty.optional() }).passthrough())
+        .optional(),
+    notebookRenderers: z
+        .array(z.object({ id: nonEmpty, name: nonEmpty.optional() }).passthrough())
+        .optional(),
+    configuration: z
+        .array(z.object({ id: nonEmpty, name: nonEmpty.optional() }).passthrough())
+        .optional(),
+})
+    .passthrough();
+export const pluginCatalogEntrySchema = z
+    .object({
+    id: nonEmpty,
+    name: nonEmpty,
+    description: z.string(),
+    readmeUrl: httpsUrl.optional(),
+    author: nonEmpty,
+    channel: pluginRegistryChannelSchema,
+    latestVersion: nonEmpty,
+    minAppVersion: nonEmpty,
+    platforms: z.array(pluginPlatformSchema).min(1),
+    categories: z.array(nonEmpty),
+    badges: z.array(pluginBadgeSchema).optional(),
+    detail: urlOrRelative,
+    contributes: pluginContributionSummarySchema.optional(),
+})
+    .passthrough();
+export const pluginCatalogIndexSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    generatedAt: isoDate,
+    registries: z
+        .record(z.object({
+        name: nonEmpty,
+        trustTier: registryTrustTierSchema,
+    }))
+        .optional(),
+    plugins: z.array(pluginCatalogEntrySchema),
+    signatures: z.array(signatureRecordSchema).optional(),
+})
+    .passthrough();
+export const pluginRevocationRecordSchema = z.object({
+    revokedAt: isoDate,
+    reason: nonEmpty,
+    message: z.string().optional(),
+    replacementVersion: nonEmpty.optional(),
+});
+export const pluginRevokedVersionRecordSchema = pluginRevocationRecordSchema.extend({
+    pluginId: nonEmpty,
+    versions: z.array(nonEmpty).min(1),
+});
+export const pluginRevocationIndexSchema = z.object({
+    schemaVersion: z.literal(1),
+    generatedAt: isoDate,
+    revoked: z.array(pluginRevokedVersionRecordSchema),
+    signatures: z.array(signatureRecordSchema).optional(),
+});
+export const pluginCatalogReleaseSchema = z
+    .object({
+    version: nonEmpty,
+    minAppVersion: nonEmpty,
+    releasedAt: isoDate,
+    platforms: z.array(pluginPlatformSchema).min(1),
+    bundle: remoteFileReferenceSchema,
+    revoked: pluginRevocationRecordSchema.optional(),
+})
+    .passthrough();
+export const pluginCatalogDetailSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    id: nonEmpty,
+    name: nonEmpty,
+    description: z.string(),
+    readmeUrl: httpsUrl.optional(),
+    channel: pluginRegistryChannelSchema,
+    owner: z.object({
+        name: nonEmpty,
+        verified: z.boolean().optional(),
+        url: z.string().url().optional(),
+    }),
+    latestVersion: nonEmpty,
+    readme: remoteFileReferenceSchema.optional(),
+    versions: z.record(pluginCatalogReleaseSchema),
+    signatures: z.array(signatureRecordSchema).optional(),
+})
+    .passthrough();
+export const pluginReleaseManifestSchema = z.object({
+    schemaVersion: z.literal(1),
+    type: z.literal("lapis.plugin.release"),
+    pluginId: nonEmpty,
+    version: nonEmpty,
+    channel: pluginRegistryChannelSchema,
+    source: z
+        .object({
+        repo: nonEmpty.optional(),
+        commit: nonEmpty.optional(),
+        package: nonEmpty.optional(),
+    })
+        .optional(),
+    compatibility: z.object({
+        minAppVersion: nonEmpty,
+        platforms: z.array(pluginPlatformSchema).min(1),
+        desktopOnly: z.boolean().optional(),
+        requiresWorkspaceTrust: z.boolean().optional(),
+    }),
+    runtime: pluginReleaseRuntimeMetadataSchema.optional(),
+    files: z.array(pluginReleaseFileSchema),
+    revoked: pluginRevocationRecordSchema.optional(),
+});
+export const signedEnvelopeSchema = (signed) => z.object({
+    signed,
+    signatures: z.array(signatureRecordSchema).min(1),
+});
+export const installedPluginRecordSchema = z
+    .object({
+    pluginId: nonEmpty,
+    installedVersion: nonEmpty,
+    installedAt: isoDate,
+    updatedAt: isoDate,
+    provenance: pluginProvenanceSchema,
+    registryId: nonEmpty.optional(),
+    registryUrl: nonEmpty.optional(),
+    releaseManifestSha256: sha256.optional(),
+    files: z.array(z.object({
+        path: nonEmpty,
+        sha256,
+        size: z.number().int().nonnegative(),
+    })),
+    runtimeWarnings: z.array(pluginReleaseRuntimeDiagnosticSchema).optional(),
+    signature: signatureRecordSchema.optional(),
+    revoked: pluginRevocationRecordSchema.optional(),
+    restartRequired: z.boolean().optional(),
+})
+    .passthrough();
+export const installedPluginsStateSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    updatedAt: isoDate,
+    plugins: z.record(installedPluginRecordSchema),
+    migrations: z
+        .record(z.object({
+        oldId: nonEmpty.optional(),
+        newId: nonEmpty.optional(),
+        dataMigratedAt: isoDate.optional(),
+        source: nonEmpty.optional(),
+    }))
+        .optional(),
+})
+    .passthrough();
+export const parsePluginDistributionMetadata = (schema, value) => {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        throw new PluginDistributionError("metadata-invalid", result.error.issues
+            .map((issue) => `${issue.path.join(".") || "$"}: ${issue.message}`)
+            .join("; "), { cause: result.error });
+    }
+    return result.data;
+};

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

@@ -0,0 +1,5 @@
+import type { SignatureRecord, SignedEnvelope, TrustedSigningKey } from "./types";
+export declare const verifySignedEnvelope: <T>(envelope: SignedEnvelope<T>, trustedKeys: TrustedSigningKey[]) => Promise<T>;
+export declare const verifySignature: (payload: Uint8Array, signature: SignatureRecord, trustedKey: TrustedSigningKey) => Promise<boolean>;
+export declare const bytesToBase64: (bytes: Uint8Array) => string;
+export declare const base64ToBytes: (base64: string) => Uint8Array;

package/dist/plugin-distribution/signing.js

@@ -0,0 +1,38 @@
+import { canonicalJson } from "./canonical-json";
+import { PluginDistributionError } from "./errors";
+export const verifySignedEnvelope = async (envelope, trustedKeys) => {
+    const payload = new TextEncoder().encode(canonicalJson(envelope.signed));
+    for (const signature of envelope.signatures) {
+        const key = trustedKeys.find((candidate) => candidate.keyId === signature.keyId && candidate.alg === signature.alg);
+        if (!key)
+            continue;
+        const ok = await verifySignature(payload, signature, key);
+        if (ok)
+            return envelope.signed;
+        throw new PluginDistributionError("signature-invalid", `Signature ${signature.keyId} did not verify.`, { details: { keyId: signature.keyId } });
+    }
+    throw new PluginDistributionError("signature-key-not-found", "No trusted signing key matched the envelope signatures.", {
+        details: {
+            signatureKeyIds: envelope.signatures.map((signature) => signature.keyId),
+            trustedKeyIds: trustedKeys.map((key) => key.keyId),
+        },
+    });
+};
+export const verifySignature = async (payload, signature, trustedKey) => {
+    const key = await globalThis.crypto.subtle.importKey("raw", base64ToBytes(trustedKey.publicKey), { name: "Ed25519" }, false, ["verify"]);
+    return globalThis.crypto.subtle.verify({ name: "Ed25519" }, key, base64ToBytes(signature.sig), payload);
+};
+export const bytesToBase64 = (bytes) => {
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+};
+export const base64ToBytes = (base64) => {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+};

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

@@ -0,0 +1,217 @@
+export type PluginProvenance = "bundled" | "official" | "community" | "manual" | "development";
+export type RegistryTrustTier = "official" | "community" | "local";
+export interface PluginRegistrySource {
+    id: string;
+    name: string;
+    url: string;
+    trustTier: RegistryTrustTier;
+    enabled: boolean;
+    builtin?: boolean;
+}
+export type PluginRegistryChannel = "official" | "community";
+export type PluginPlatform = "web" | "electron" | "desktop";
+export type PluginBadge = "official" | "verified" | "community" | "desktop-only" | "requires-trust" | "update-available" | "revoked";
+export interface PluginContributionSummary {
+    commands?: Array<{
+        id: string;
+        name: string;
+    }>;
+    editorViews?: Array<{
+        id: string;
+        filenamePatterns?: string[];
+        extensions?: string[];
+        mimeTypes?: string[];
+    }>;
+    markdownProcessors?: Array<{
+        id: string;
+        name?: string;
+    }>;
+    notebookRenderers?: Array<{
+        id: string;
+        name?: string;
+    }>;
+    configuration?: Array<{
+        id: string;
+        name?: string;
+    }>;
+}
+export interface PluginCatalogIndex {
+    schemaVersion: 1;
+    generatedAt: string;
+    registries?: Record<string, {
+        name: string;
+        trustTier: RegistryTrustTier;
+    }>;
+    plugins: PluginCatalogEntry[];
+    signatures?: SignatureRecord[];
+}
+export interface PluginCatalogEntry {
+    id: string;
+    name: string;
+    description: string;
+    readmeUrl?: string;
+    author: string;
+    channel: PluginRegistryChannel;
+    latestVersion: string;
+    minAppVersion: string;
+    platforms: PluginPlatform[];
+    categories: string[];
+    badges?: PluginBadge[];
+    detail: string;
+    contributes?: PluginContributionSummary;
+}
+export interface PluginCatalogDetail {
+    schemaVersion: 1;
+    id: string;
+    name: string;
+    description: string;
+    readmeUrl?: string;
+    channel: PluginRegistryChannel;
+    owner: {
+        name: string;
+        verified?: boolean;
+        url?: string;
+    };
+    latestVersion: string;
+    readme?: RemoteFileReference;
+    versions: Record<string, PluginCatalogRelease>;
+    signatures?: SignatureRecord[];
+}
+export interface PluginCatalogRelease {
+    version: string;
+    minAppVersion: string;
+    releasedAt: string;
+    platforms: PluginPlatform[];
+    bundle: RemoteFileReference;
+    revoked?: PluginRevocationRecord;
+}
+export interface RemoteFileReference {
+    url: string;
+    sha256: string;
+    size?: number;
+}
+export interface PluginReleaseFile {
+    path: string;
+    sha256: string;
+    size: number;
+}
+export type PluginReleaseRuntimeHost = "workspace" | "electronRenderer" | "electronSidecar" | "desktop" | "trustedDesktop";
+export type PluginReleaseModuleFormat = "esm" | "commonjs" | "node-esm";
+export interface PluginReleaseRuntimeEntryDescriptor {
+    path: string;
+    format: PluginReleaseModuleFormat;
+    fallbackPath?: string;
+    sharedDependencies?: string[];
+    requiresReloadOnUpdate?: boolean;
+}
+export interface PluginReleaseRuntimeMetadata {
+    entries?: Partial<Record<PluginReleaseRuntimeHost, PluginReleaseRuntimeEntryDescriptor>>;
+    sharedDependencies?: Partial<Record<PluginReleaseRuntimeHost, string[]>>;
+    compatibilityOverrides?: PluginReleaseRuntimeCompatibilityOverrides;
+}
+export interface PluginReleaseRuntimeCompatibilityOverrides {
+    deprecatedHostModules?: Partial<Record<PluginReleaseRuntimeHost, string[]>>;
+}
+export type PluginReleaseRuntimeDiagnosticSeverity = "error" | "warning";
+export type PluginReleaseRuntimeDiagnosticCode = "lapis-manifest-invalid" | "runtime-metadata-missing" | "runtime-metadata-mismatch" | "runtime-entry-file-missing" | "runtime-entry-format-mismatch" | "runtime-fallback-file-missing" | "runtime-fallback-format-mismatch" | "runtime-main-missing" | "runtime-commonjs-not-allowed" | "runtime-dependency-unknown" | "runtime-dependency-private" | "runtime-dependency-platform-unsupported" | "runtime-dependency-undeclared" | "runtime-dependency-deprecated" | "runtime-legacy-commonjs";
+export interface PluginReleaseRuntimeDiagnostic {
+    severity: PluginReleaseRuntimeDiagnosticSeverity;
+    code: PluginReleaseRuntimeDiagnosticCode;
+    message: string;
+    details?: Record<string, unknown>;
+}
+export interface SignedEnvelope<T> {
+    signed: T;
+    signatures: SignatureRecord[];
+}
+export interface SignatureRecord {
+    keyId: string;
+    alg: "ed25519";
+    sig: string;
+}
+export interface TrustedSigningKey {
+    keyId: string;
+    alg: "ed25519";
+    publicKey: string;
+    trustTier: RegistryTrustTier;
+    expiresAt?: string;
+}
+export interface PluginReleaseManifest {
+    schemaVersion: 1;
+    type: "lapis.plugin.release";
+    pluginId: string;
+    version: string;
+    channel: PluginRegistryChannel;
+    source?: {
+        repo?: string;
+        commit?: string;
+        package?: string;
+    };
+    compatibility: {
+        minAppVersion: string;
+        platforms: PluginPlatform[];
+        desktopOnly?: boolean;
+        requiresWorkspaceTrust?: boolean;
+    };
+    runtime?: PluginReleaseRuntimeMetadata;
+    files: PluginReleaseFile[];
+    revoked?: PluginRevocationRecord;
+}
+export interface PluginRevocationRecord {
+    revokedAt: string;
+    reason: string;
+    message?: string;
+    replacementVersion?: string;
+}
+export interface PluginRevokedVersionRecord extends PluginRevocationRecord {
+    pluginId: string;
+    versions: string[];
+}
+export interface PluginRevocationIndex {
+    schemaVersion: 1;
+    generatedAt: string;
+    revoked: PluginRevokedVersionRecord[];
+    signatures?: SignatureRecord[];
+}
+export interface InstalledPluginsState {
+    schemaVersion: 1;
+    updatedAt: string;
+    plugins: Record<string, InstalledPluginRecord>;
+    migrations?: Record<string, InstalledPluginMigrationRecord>;
+    [key: string]: unknown;
+}
+export interface InstalledPluginRecord {
+    pluginId: string;
+    installedVersion: string;
+    installedAt: string;
+    updatedAt: string;
+    provenance: PluginProvenance;
+    registryId?: string;
+    registryUrl?: string;
+    releaseManifestSha256?: string;
+    files: Array<{
+        path: string;
+        sha256: string;
+        size: number;
+    }>;
+    runtimeWarnings?: PluginReleaseRuntimeDiagnostic[];
+    signature?: SignatureRecord;
+    revoked?: PluginRevocationRecord;
+    restartRequired?: boolean;
+    [key: string]: unknown;
+}
+export interface InstalledPluginMigrationRecord {
+    oldId?: string;
+    newId?: string;
+    dataMigratedAt?: string;
+    source?: string;
+}
+export interface PluginCompatibilityInput {
+    appVersion: string;
+    platform: PluginPlatform;
+    workspaceTrusted?: boolean;
+}
+export interface PluginCompatibilityResult {
+    compatible: boolean;
+    reasons: Array<"app-version-too-old" | "platform-unsupported" | "desktop-only" | "workspace-trust-required" | "revoked">;
+}

package/dist/plugin-distribution/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugin-install-progress.d.ts

@@ -0,0 +1,15 @@
+import type { App } from "./context.svelte";
+import type { NotificationProgressHandle, NotificationProgressOptions } from "./notifications";
+import type { PluginInstallProgressEvent } from "./plugin-distribution/manager";
+export declare function humanizePluginInstallPhase(phase: string): string;
+export declare function pluginInstallProgressMessage(event: PluginInstallProgressEvent): string;
+export declare function reportPluginInstallProgress(progressHandle: NotificationProgressHandle, event: PluginInstallProgressEvent): void;
+export declare function isAbortError(error: unknown): boolean;
+export interface WithPluginInstallProgressOptions {
+    pluginId: string;
+    title: string;
+    source?: string;
+    location?: NotificationProgressOptions["location"];
+    persistOnError?: boolean;
+}
+export declare function withPluginInstallProgress<T>(app: App, options: WithPluginInstallProgressOptions, action: (signal: AbortSignal) => Promise<T>): Promise<T>;

package/dist/plugin-install-progress.js

@@ -0,0 +1,86 @@
+export function humanizePluginInstallPhase(phase) {
+    return phase
+        .split(/[\s-]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+export function pluginInstallProgressMessage(event) {
+    let message = event.message ?? humanizePluginInstallPhase(event.phase);
+    if (event.filePath &&
+        typeof event.fileIndex === "number" &&
+        typeof event.fileCount === "number") {
+        message = `${message} (${event.fileIndex} of ${event.fileCount})`;
+    }
+    if (typeof event.processedBytes === "number" &&
+        typeof event.totalBytes === "number" &&
+        event.totalBytes > 0) {
+        message = `${message} - ${formatByteSize(event.processedBytes)} of ${formatByteSize(event.totalBytes)}`;
+    }
+    return message;
+}
+export function reportPluginInstallProgress(progressHandle, event) {
+    const message = pluginInstallProgressMessage(event);
+    if (typeof event.totalBytes === "number" && event.totalBytes > 0) {
+        if (event.phase === "downloading-bundle" &&
+            typeof event.downloadedBytes === "number") {
+            progressHandle.report({
+                current: event.downloadedBytes,
+                total: event.totalBytes,
+                message,
+            });
+            return;
+        }
+        if (typeof event.processedBytes === "number") {
+            progressHandle.report({
+                current: event.processedBytes,
+                total: event.totalBytes,
+                message,
+            });
+            return;
+        }
+    }
+    progressHandle.report({ message, indeterminate: true });
+}
+export function isAbortError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "name" in error &&
+        error.name === "AbortError");
+}
+function formatByteSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ["KB", "MB", "GB"];
+    let value = bytes / 1024;
+    for (const unit of units) {
+        if (value < 1024 || unit === units.at(-1)) {
+            return `${value.toFixed(value >= 10 ? 0 : 1)} ${unit}`;
+        }
+        value /= 1024;
+    }
+    return `${bytes} B`;
+}
+export async function withPluginInstallProgress(app, options, action) {
+    return app.notifications.withProgress({
+        title: options.title,
+        source: options.source ?? "Plugin registry",
+        location: options.location ?? "status",
+        cancellable: true,
+        persistOnError: options.persistOnError ?? false,
+    }, async (progressHandle, token) => {
+        const removeProgressListener = app.pluginDistribution.addProgressListener((event) => {
+            if (event.pluginId !== options.pluginId) {
+                return;
+            }
+            reportPluginInstallProgress(progressHandle, event);
+        });
+        try {
+            progressHandle.report({ message: "Starting", indeterminate: true });
+            return await action(token.signal);
+        }
+        finally {
+            removeProgressListener();
+        }
+    });
+}