@openforge-app/plugin-sdk 0.1.0 → 0.2.4

package/dist/pluginIcons.js

@@ -0,0 +1,99 @@
+import DOMPurify from 'dompurify';
+import { isPluginSvgIcon } from './pluginIconContract';
+export const MAX_PLUGIN_SVG_ICON_CHARACTERS = 10_000;
+const ALLOWED_SVG_TAGS = ['svg', 'g', 'path', 'rect', 'circle', 'ellipse', 'line', 'polyline', 'polygon'];
+const ALLOWED_SVG_ATTRIBUTES = [
+    'viewBox',
+    'd',
+    'fill',
+    'fill-rule',
+    'fill-opacity',
+    'stroke',
+    'stroke-width',
+    'stroke-linecap',
+    'stroke-linejoin',
+    'stroke-miterlimit',
+    'stroke-dasharray',
+    'stroke-dashoffset',
+    'stroke-opacity',
+    'opacity',
+    'transform',
+    'x',
+    'y',
+    'x1',
+    'y1',
+    'x2',
+    'y2',
+    'cx',
+    'cy',
+    'r',
+    'rx',
+    'ry',
+    'width',
+    'height',
+    'points',
+];
+const SAFE_PAINT_VALUE = /^(?:none|currentColor|transparent|#[0-9a-f]{3,8}|[a-z]+|(?:rgb|rgba|hsl|hsla)\([\d\s.,%+\-/]+\))$/iu;
+function parseSvgRoot(markup) {
+    const template = document.createElement('template');
+    template.innerHTML = markup.trim();
+    const children = template.content.children;
+    const root = children.item(0);
+    if (children.length !== 1 || !(root instanceof SVGSVGElement)) {
+        throw new TypeError('Custom plugin icons require exactly one <svg> root');
+    }
+    return root;
+}
+function hasValidViewBox(root) {
+    const values = root.getAttribute('viewBox')?.trim().split(/[\s,]+/u).map(Number) ?? [];
+    return values.length === 4
+        && values.every(Number.isFinite)
+        && (values[2] ?? 0) > 0
+        && (values[3] ?? 0) > 0;
+}
+function removeUnsafePaint(root) {
+    for (const element of [root, ...root.querySelectorAll('*')]) {
+        for (const attribute of ['fill', 'stroke']) {
+            const value = element.getAttribute(attribute);
+            if (value !== null && !SAFE_PAINT_VALUE.test(value.trim())) {
+                element.removeAttribute(attribute);
+            }
+        }
+    }
+}
+/**
+ * Validates and sanitizes a plugin icon before it crosses a host contribution boundary.
+ * Named icons are preserved so unsupported names can retain the host's existing fallback.
+ */
+export function sanitizePluginIcon(icon) {
+    if (typeof icon === 'string') {
+        if (icon.trim().length === 0) {
+            throw new TypeError('Plugin icon names must be non-empty');
+        }
+        return icon;
+    }
+    if (!isPluginSvgIcon(icon) || icon.svg.trim().length === 0) {
+        throw new TypeError('Plugin icons must be a non-empty name or { type: "svg", svg }');
+    }
+    if (icon.svg.length > MAX_PLUGIN_SVG_ICON_CHARACTERS) {
+        throw new TypeError(`Custom plugin icon SVG must not exceed ${MAX_PLUGIN_SVG_ICON_CHARACTERS.toLocaleString('en-US')} characters`);
+    }
+    const sanitizedMarkup = DOMPurify.sanitize(icon.svg, {
+        ALLOWED_TAGS: ALLOWED_SVG_TAGS,
+        ALLOWED_ATTR: ALLOWED_SVG_ATTRIBUTES,
+        ALLOW_ARIA_ATTR: false,
+        ALLOW_DATA_ATTR: false,
+        KEEP_CONTENT: false,
+    });
+    const root = parseSvgRoot(sanitizedMarkup);
+    if (!hasValidViewBox(root)) {
+        throw new TypeError('Custom plugin icons require a viewBox with positive width and height');
+    }
+    if (!root.querySelector('path, rect, circle, ellipse, line, polyline, polygon')) {
+        throw new TypeError('Custom plugin icons require visible geometry');
+    }
+    root.removeAttribute('width');
+    root.removeAttribute('height');
+    removeUnsafePaint(root);
+    return { type: 'svg', svg: root.outerHTML };
+}

package/dist/publicUiExports.d.mts

@@ -0,0 +1,16 @@
+export type OpenForgePluginSdkPublicUiExport = Readonly<{
+  componentName: string
+  packageSubpath: `./ui/${string}.svelte`
+  importSpecifier: `@openforge-app/plugin-sdk/ui/${string}.svelte`
+  sourcePath: `src/ui/${string}.svelte`
+  workspaceSourcePath: `packages/plugin-sdk/src/ui/${string}.svelte`
+  distPath: `./dist/ui/${string}.svelte`
+}>
+
+export const OPENFORGE_PLUGIN_SDK_PUBLIC_UI_EXPORTS: readonly OpenForgePluginSdkPublicUiExport[]
+
+export function createOpenForgePluginSdkPublicUiPackageExports(): Record<string, string>
+
+export function assertOpenForgePluginSdkPublicUiPackageExports(
+  packageExports: unknown,
+): asserts packageExports is Record<string, unknown>

package/dist/publicUiExports.mjs

@@ -0,0 +1,60 @@
+const PLUGIN_SDK_PACKAGE_NAME = '@openforge-app/plugin-sdk'
+
+const PUBLIC_UI_COMPONENT_NAMES = Object.freeze([
+  'Button',
+  'Checkbox',
+  'MarkdownContent',
+  'ResizablePanel',
+  'Modal',
+  'PluginPageHeader',
+  'PluginViewState',
+  'PluginSidebarLink',
+  'FileTypeIcon',
+])
+
+/**
+ * Canonical registrations for public Svelte components shipped by the plugin SDK.
+ * Package exports are validated against this list; asset copying, source aliases,
+ * root Vite aliases, and import-boundary fallbacks are derived from it.
+ */
+export const OPENFORGE_PLUGIN_SDK_PUBLIC_UI_EXPORTS = Object.freeze(
+  PUBLIC_UI_COMPONENT_NAMES.map((componentName) => Object.freeze({
+    componentName,
+    packageSubpath: `./ui/${componentName}.svelte`,
+    importSpecifier: `${PLUGIN_SDK_PACKAGE_NAME}/ui/${componentName}.svelte`,
+    sourcePath: `src/ui/${componentName}.svelte`,
+    workspaceSourcePath: `packages/plugin-sdk/src/ui/${componentName}.svelte`,
+    distPath: `./dist/ui/${componentName}.svelte`,
+  })),
+)
+
+export function createOpenForgePluginSdkPublicUiPackageExports() {
+  return Object.fromEntries(
+    OPENFORGE_PLUGIN_SDK_PUBLIC_UI_EXPORTS.map(({ packageSubpath, distPath }) => [packageSubpath, distPath]),
+  )
+}
+
+export function assertOpenForgePluginSdkPublicUiPackageExports(packageExports) {
+  if (!packageExports || typeof packageExports !== 'object' || Array.isArray(packageExports)) {
+    throw new Error('Plugin SDK package.json must define an exports object')
+  }
+
+  const expected = createOpenForgePluginSdkPublicUiPackageExports()
+  const actual = Object.fromEntries(
+    Object.entries(packageExports).filter(([subpath]) => subpath.startsWith('./ui/')),
+  )
+  const expectedEntries = Object.entries(expected)
+  const missingOrMismatched = expectedEntries
+    .filter(([subpath, distPath]) => actual[subpath] !== distPath)
+    .map(([subpath, distPath]) => `${subpath} -> ${distPath}`)
+  const unexpected = Object.keys(actual).filter((subpath) => !(subpath in expected))
+
+  if (missingOrMismatched.length === 0 && unexpected.length === 0) return
+
+  const details = [
+    missingOrMismatched.length > 0 ? `missing or mismatched: ${missingOrMismatched.join(', ')}` : null,
+    unexpected.length > 0 ? `not in the canonical manifest: ${unexpected.join(', ')}` : null,
+  ].filter(Boolean)
+
+  throw new Error(`Plugin SDK public UI exports drifted from the canonical manifest (${details.join('; ')})`)
+}

package/dist/svelteHostRuntimeContract.d.mts

@@ -6,6 +6,7 @@ export type SvelteHostRuntimeModule = Readonly<{
 
 export const SVELTE_HOST_RUNTIME_MODULES: readonly SvelteHostRuntimeModule[]
 export const OPENFORGE_HOST_RUNTIME_SVELTE_SPECIFIERS: readonly string[]
+export function isOpenForgeHostRuntimeSvelteExternal(id: string): boolean
 export const SVELTE_HOST_RUNTIME_IMPORTS: Readonly<Record<string, string>>
 export function svelteHostRuntimeImportUrl(specifier: string): string | null
 export function svelteHostRuntimeBuildEntries(): Record<string, string>

package/dist/svelteHostRuntimeContract.mjs

@@ -26,6 +26,22 @@ export const OPENFORGE_HOST_RUNTIME_SVELTE_SPECIFIERS = Object.freeze(
   SVELTE_HOST_RUNTIME_MODULES.map(module => module.specifier),
 )
 
+const OPENFORGE_HOST_RUNTIME_SVELTE_MODULE_SET = new Set(OPENFORGE_HOST_RUNTIME_SVELTE_SPECIFIERS)
+
+/**
+ * True for the Svelte host-runtime specifiers the HOST renderer build must externalize.
+ *
+ * Externalizing these makes the host emit bare `svelte` / `svelte/internal/client` imports
+ * that resolve through the injected renderer import map to `plugin://host-runtime/svelte`
+ * — the same Svelte instance external plugins load. Host + plugins then share ONE Svelte
+ * instance, so mounting an external plugin component from the host tree no longer throws
+ * `effect_orphan`. Deliberately Svelte-only: once Svelte is external, host-bundled
+ * terminal-runtime resolves Svelte to the shared instance too, so nothing wider is needed.
+ */
+export function isOpenForgeHostRuntimeSvelteExternal(id) {
+  return OPENFORGE_HOST_RUNTIME_SVELTE_MODULE_SET.has(id)
+}
+
 export const SVELTE_HOST_RUNTIME_IMPORTS = Object.freeze(Object.fromEntries(
   SVELTE_HOST_RUNTIME_MODULES.map(module => [module.specifier, `${HOST_RUNTIME_SVELTE_BASE_URL}${module.assetPath}`]),
 ))

package/dist/testing/backendServicesFake.d.ts

@@ -0,0 +1,19 @@
+import type { BackendOpenForgeAPI } from '../types';
+import { type TestingRegistryServices } from './support';
+import type { TestingBackendMethodContribution, TestingBackgroundServiceContribution } from './contracts';
+export declare class TestingBackendServicesFake {
+    private readonly services;
+    private readonly backendMethods;
+    private readonly backgroundServices;
+    constructor(services: TestingRegistryServices);
+    createApi(): Pick<BackendOpenForgeAPI, 'backend' | 'background'>;
+    getSnapshot(): {
+        backendMethods: TestingBackendMethodContribution[];
+        backgroundServices: TestingBackgroundServiceContribution[];
+    };
+    captureBackgroundServiceIds(): Set<string>;
+    startNewBackgroundServices(existingServices: Set<string>): Promise<void>;
+    invokeMethod<TOutput>(method: string, payload?: unknown): Promise<TOutput>;
+    private registerBackendMethod;
+    private registerBackgroundService;
+}

package/dist/testing/backendServicesFake.js

@@ -0,0 +1,87 @@
+import { assertFunction, createDisposable } from './support';
+export class TestingBackendServicesFake {
+    services;
+    backendMethods = new Map();
+    backgroundServices = new Map();
+    constructor(services) {
+        this.services = services;
+    }
+    createApi() {
+        return {
+            backend: {
+                registerMethod: (method, registration) => this.registerBackendMethod(method, registration),
+            },
+            background: {
+                register: (registration) => this.registerBackgroundService(registration),
+            },
+        };
+    }
+    getSnapshot() {
+        return {
+            backendMethods: Array.from(this.backendMethods.values()),
+            backgroundServices: Array.from(this.backgroundServices.values()),
+        };
+    }
+    captureBackgroundServiceIds() {
+        return new Set(this.backgroundServices.keys());
+    }
+    async startNewBackgroundServices(existingServices) {
+        for (const [key, service] of this.backgroundServices.entries()) {
+            if (existingServices.has(key) || service.started)
+                continue;
+            await service.start();
+            service.started = true;
+        }
+    }
+    async invokeMethod(method, payload) {
+        const qualifiedId = this.services.localQualifiedId('backend', method);
+        this.services.calls.backendInvocations.push({ method, qualifiedId, payload });
+        const contribution = this.backendMethods.get(qualifiedId);
+        if (!contribution) {
+            throw new Error(`Backend method is not registered: ${qualifiedId}`);
+        }
+        return await contribution.registration.handler(payload);
+    }
+    registerBackendMethod(method, registration) {
+        const qualifiedId = this.services.localQualifiedId('backend', method);
+        assertFunction('backend', 'handler', registration.handler);
+        this.services.claims.claim('backend', qualifiedId);
+        const contribution = {
+            id: method.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+            registration,
+        };
+        this.backendMethods.set(qualifiedId, contribution);
+        return createDisposable(() => {
+            this.backendMethods.delete(qualifiedId);
+            this.services.claims.release('backend', qualifiedId);
+        });
+    }
+    registerBackgroundService(registration) {
+        const qualifiedId = this.services.localQualifiedId('background', registration.id);
+        if (registration.scope !== 'global' && registration.scope !== 'project' && registration.scope !== 'task') {
+            throw new Error('background registration requires scope to be global, project, or task');
+        }
+        assertFunction('background', 'start', registration.start);
+        this.services.claims.claim('background', qualifiedId);
+        const contribution = {
+            ...registration,
+            id: registration.id.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+            started: false,
+        };
+        this.backgroundServices.set(qualifiedId, contribution);
+        return createDisposable(async () => {
+            this.backgroundServices.delete(qualifiedId);
+            this.services.claims.release('background', qualifiedId);
+            if (contribution.started) {
+                await contribution.stop?.();
+                contribution.started = false;
+            }
+        });
+    }
+}

package/dist/testing/commonApiFake.d.ts

@@ -0,0 +1,23 @@
+import type { BackendOpenForgeAPI, FrontendOpenForgeAPI, OpenForgeCommonAPI } from '../types';
+import { type TestingRegistryServices } from './support';
+import type { TestingCommandContribution, TestingEventListenerContribution } from './contracts';
+export type TestingCommonApi = OpenForgeCommonAPI & Pick<FrontendOpenForgeAPI, 'navigation'>;
+export declare class TestingCommonApiFake {
+    private readonly services;
+    private readonly commands;
+    private readonly eventListeners;
+    private readonly eventHandlers;
+    private eventListenerSequence;
+    constructor(services: TestingRegistryServices);
+    createApi(): TestingCommonApi;
+    createBackendApi(): TestingCommonApi & Pick<BackendOpenForgeAPI, 'fs'>;
+    getSnapshot(): {
+        commands: TestingCommandContribution[];
+        eventListeners: TestingEventListenerContribution[];
+    };
+    private registerCommand;
+    private registerEventListener;
+    private invokeCommand;
+    private invokeGlobalCommand;
+    private emitEvent;
+}

package/dist/testing/commonApiFake.js

@@ -0,0 +1,306 @@
+import { assertFunction, assertTitle, commandDescriptor, createDisposable, isJsonValue, normalizeAgentCommandMetadata, } from './support';
+export class TestingCommonApiFake {
+    services;
+    commands = new Map();
+    eventListeners = new Map();
+    eventHandlers = new Map();
+    eventListenerSequence = 0;
+    constructor(services) {
+        this.services = services;
+    }
+    createApi() {
+        const api = {
+            commands: {
+                register: (registration) => this.registerCommand(registration),
+                invoke: async (id, payload) => this.invokeCommand(id, payload),
+                invokeGlobal: async (qualifiedId, payload) => this.invokeGlobalCommand(qualifiedId, payload),
+                list: async () => Array.from(this.commands.values()).map(commandDescriptor),
+                listCatalog: async () => [],
+            },
+            events: {
+                on: (event, handler) => this.registerEventListener(event, handler, false),
+                onGlobal: (qualifiedEvent, handler) => this.registerEventListener(qualifiedEvent, handler, true),
+                emit: async (event, payload) => this.emitEvent(event, payload, false),
+                emitGlobal: async (qualifiedEvent, payload) => this.emitEvent(qualifiedEvent, payload, true),
+            },
+            storage: this.services.storage,
+            context: {
+                getSnapshot: () => this.services.getContextSnapshot(),
+            },
+            tasks: {
+                list: async (request) => {
+                    const projectId = request?.projectId ?? null;
+                    const includeDone = request?.includeDone ?? false;
+                    this.services.calls.taskListRequests.push({ projectId, includeDone });
+                    return this.services.seededTasks.filter((task) => {
+                        if (projectId !== null && task.project_id !== projectId)
+                            return false;
+                        if (!includeDone && task.status === 'done')
+                            return false;
+                        return true;
+                    });
+                },
+                get: async () => null,
+                create: async (request) => {
+                    this.services.calls.taskCreations.push(request);
+                    return {
+                        id: `mock-task-${this.services.calls.taskCreations.length}`,
+                        initial_prompt: request.initialPrompt,
+                        status: 'backlog',
+                        prompt: null,
+                        title: null,
+                        title_source: null,
+                        title_generated_at: null,
+                        agent: null,
+                        permission_mode: null,
+                        worktree_source: null,
+                        worktree_branch: null,
+                        source_ticket_url: null,
+                        depends_on: request.dependsOn ?? [],
+                        project_id: request.projectId,
+                        created_at: 0,
+                        updated_at: 0,
+                    };
+                },
+                // The fake stands in for the host dialog: it records the request and
+                // reports a created-but-not-started task, so consumers can assert what
+                // they asked for without a UI. Override per test for the other outcomes.
+                compose: async (request) => {
+                    this.services.calls.taskComposes.push(request);
+                    const task = await api.tasks.create({
+                        projectId: request.projectId,
+                        initialPrompt: request.initialPrompt,
+                    });
+                    return { task, started: false };
+                },
+                updateStatus: async (taskId, status) => {
+                    this.services.calls.taskStatusUpdates.push({ taskId, status });
+                },
+                listStartPromptContributions: async (projectId) => this.services.startPromptContributions(projectId),
+                configureStartPromptContribution: async (request) => {
+                    this.services.calls.startPromptContributionConfigurations.push(request);
+                    const contribution = { ...request, ownerPluginId: this.services.pluginId };
+                    const existing = this.services.startPromptContributions(request.projectId)
+                        .filter((entry) => entry.id !== request.id
+                        || (entry.ownerPluginId !== undefined && entry.ownerPluginId !== contribution.ownerPluginId));
+                    const next = [...existing, contribution].sort((a, b) => (a.order ?? 0) - (b.order ?? 0)
+                        || a.id.localeCompare(b.id)
+                        || (a.ownerPluginId ?? '').localeCompare(b.ownerPluginId ?? ''));
+                    this.services.config.set(`project:${request.projectId}:start_prompt_contributions`, next);
+                    return next;
+                },
+                startImplementation: async (request) => {
+                    this.services.calls.taskImplementationStarts.push(request);
+                    return {
+                        taskId: request.taskId,
+                        workspacePath: '/mock-workspace',
+                        sessionId: 'mock-session',
+                    };
+                },
+                sendFollowUp: async (request) => {
+                    this.services.calls.taskFollowUps.push(request);
+                    return {
+                        taskId: request.taskId,
+                        sessionId: 'mock-session',
+                        disposition: 'delivered',
+                    };
+                },
+                getWorkspace: async () => null,
+                getLatestSession: async () => null,
+            },
+            projects: {
+                list: async () => [],
+                get: async () => null,
+            },
+            fs: {
+                readDir: async () => [],
+                readFile: async () => ({ type: 'text', content: '', mimeType: null, size: 0 }),
+                writeFile: async (request) => {
+                    this.services.calls.fsWrites.push(request);
+                },
+                searchFiles: async () => [],
+            },
+            shell: {
+                spawn: async (request) => {
+                    this.services.calls.shellSpawns.push(request);
+                    return 0;
+                },
+                write: async (request) => {
+                    this.services.calls.shellWrites.push(request);
+                },
+                resize: async (request) => {
+                    this.services.calls.shellResizes.push(request);
+                },
+                kill: async (request) => {
+                    this.services.calls.shellKills.push(request);
+                },
+                getBuffer: async (request) => {
+                    this.services.calls.shellBuffers.push(request);
+                    return { buffer: null, isLive: false };
+                },
+            },
+            notifications: {
+                notify: async (request) => {
+                    this.services.calls.notify.push(request);
+                },
+            },
+            attention: {
+                listProjects: async () => [],
+            },
+            system: {
+                openUrl: async (url) => {
+                    this.services.calls.openUrl.push(url);
+                },
+                writeClipboardText: async (text) => {
+                    this.services.calls.clipboardWrites.push(text);
+                },
+            },
+            navigation: {
+                get: () => this.services.getNavigationSnapshot(),
+                navigate: async (request) => {
+                    this.services.calls.navigationRequests.push(request);
+                    return this.services.getNavigationSnapshot(request);
+                },
+            },
+            config: {
+                get: async (key) => this.services.config.has(`global:${key}`)
+                    ? this.services.config.get(`global:${key}`)
+                    : null,
+                set: async (key, value) => {
+                    this.services.config.set(`global:${key}`, value);
+                    this.services.calls.configWrites.push({ key, value, projectId: null });
+                },
+            },
+            projectConfig: {
+                get: async (key, projectId = this.services.projectId ?? '') => this.services.config.has(`project:${projectId}:${key}`)
+                    ? this.services.config.get(`project:${projectId}:${key}`)
+                    : null,
+                set: async (key, value, projectId = this.services.projectId ?? '') => {
+                    this.services.config.set(`project:${projectId}:${key}`, value);
+                    this.services.calls.configWrites.push({ key, value, projectId });
+                },
+            },
+        };
+        return api;
+    }
+    createBackendApi() {
+        const api = this.createApi();
+        return {
+            ...api,
+            fs: {
+                ...api.fs,
+                userData: {
+                    readDir: async (request = {}) => {
+                        this.services.calls.fsUserDataReadDirs.push(request);
+                        return [];
+                    },
+                    readTextFile: async (request) => {
+                        this.services.calls.fsUserDataReads.push(request);
+                        return '';
+                    },
+                    writeTextFile: async (request) => {
+                        this.services.calls.fsUserDataWrites.push(request);
+                    },
+                },
+                external: {
+                    readDir: async (request) => {
+                        this.services.calls.fsExternalReadDirs.push(request);
+                        return [];
+                    },
+                    readTextFile: async (request) => {
+                        this.services.calls.fsExternalReads.push(request);
+                        return '';
+                    },
+                },
+            },
+        };
+    }
+    getSnapshot() {
+        return {
+            commands: Array.from(this.commands.values()),
+            eventListeners: Array.from(this.eventListeners.values()),
+        };
+    }
+    registerCommand(registration) {
+        const qualifiedId = this.services.localQualifiedId('commands', registration.id);
+        assertTitle('commands', registration.title);
+        assertFunction('commands', 'handler', registration.handler);
+        const agent = normalizeAgentCommandMetadata(registration.agent);
+        if (agent && registration.input !== undefined && !isJsonValue(registration.input)) {
+            throw new Error('commands registration agent-facing input schema must be a JSON value');
+        }
+        if (agent && registration.output !== undefined && !isJsonValue(registration.output)) {
+            throw new Error('commands registration agent-facing output schema must be a JSON value');
+        }
+        this.services.claims.claim('commands', qualifiedId);
+        const contribution = {
+            ...registration,
+            agent,
+            id: registration.id.trim(),
+            title: registration.title.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+            handler: registration.handler,
+        };
+        this.commands.set(qualifiedId, contribution);
+        return createDisposable(() => {
+            this.commands.delete(qualifiedId);
+            this.services.claims.release('commands', qualifiedId);
+        });
+    }
+    registerEventListener(event, handler, global) {
+        const qualifiedId = global ? event : this.services.localQualifiedId('events', event);
+        if (qualifiedId.trim().length === 0) {
+            throw new Error('events registration requires a non-empty id');
+        }
+        assertFunction('events', 'handler', handler);
+        const handlers = this.eventHandlers.get(qualifiedId) ?? new Set();
+        handlers.add(handler);
+        this.eventHandlers.set(qualifiedId, handlers);
+        const listenerKey = `${qualifiedId}#${++this.eventListenerSequence}`;
+        const contribution = {
+            id: event,
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+            handler,
+            global,
+        };
+        this.eventListeners.set(listenerKey, contribution);
+        return createDisposable(() => {
+            handlers.delete(handler);
+            if (handlers.size === 0)
+                this.eventHandlers.delete(qualifiedId);
+            this.eventListeners.delete(listenerKey);
+        });
+    }
+    async invokeCommand(id, payload) {
+        const qualifiedId = this.services.localQualifiedId('commands', id);
+        this.services.calls.commandInvocations.push({ id, qualifiedId, payload });
+        return this.invokeGlobalCommand(qualifiedId, payload);
+    }
+    async invokeGlobalCommand(qualifiedId, payload) {
+        this.services.calls.globalCommandInvocations.push({ qualifiedId, payload });
+        const command = this.commands.get(qualifiedId);
+        if (!command)
+            throw new Error(`Unknown command: ${qualifiedId}`);
+        return await command.handler(payload, {
+            taskId: null,
+            projectId: command.projectId,
+            source: 'plugin',
+        });
+    }
+    async emitEvent(event, payload, global) {
+        const qualifiedEvent = global ? event : this.services.localQualifiedId('events', event);
+        if (global) {
+            this.services.calls.emittedGlobalEvents.push({ qualifiedEvent, payload });
+        }
+        else {
+            this.services.calls.emittedEvents.push({ event, qualifiedEvent, payload });
+        }
+        for (const handler of Array.from(this.eventHandlers.get(qualifiedEvent) ?? [])) {
+            handler(payload);
+        }
+    }
+}