@openforge-app/plugin-sdk 0.1.0 → 0.2.4

package/dist/testing/contracts.d.ts

@@ -0,0 +1,236 @@
+import type { BrowserSurfaceVisualFeedback } from '../browserSurfaces';
+import type { TestingOpenForgeRegistryFake } from './registryFake';
+import type { BackendMethodRegistration, BackendOpenForgeAPI, BackgroundServiceRegistration, CommandRegistration, CommandShortcutMetadata, ComposeTaskRequest, ConfigureStartPromptContributionRequest, CreateTaskRequest, FrontendOpenForgeAPI, InjectionPointLocation, JsonValue, NotificationRequest, OpenForgeNavigationRequest, OpenForgePackageMetadata, PluginSettingsSectionRegistration, PluginStorage, PluginTaskPaneTabRegistration, PluginTaskUISectionRegistration, PluginViewRegistration, ShellSpawnRequest, SendTaskFollowUpRequest, StartTaskImplementationRequest, TaskLinkOpenRequest, TaskStartPrefixContext, ExternalReadDirectoryRequest, ExternalReadFileRequest, UserDataDirectoryRequest, UserDataFileRequest, UserDataFileWriteRequest } from '../types';
+import type { Task } from '../domain';
+export type TestingRuntimeScope = 'global' | 'project' | 'task';
+export type TestingRuntimeKind = 'commands' | 'events' | 'views' | 'taskPane' | 'taskUI' | 'settings' | 'backend' | 'background';
+export type TestingMaybePromise<T> = T | Promise<T>;
+export type TestingCommandHandler = (payload?: unknown) => TestingMaybePromise<unknown>;
+export type TestingEventHandler = (payload: unknown) => void;
+export interface TestingOpenForgeApiOptions {
+    pluginId?: string;
+    projectId?: string | null;
+    taskId?: string | null;
+    /** The active view key reported by `navigation.get().currentView`. Defaults to `'board'`. */
+    viewId?: string;
+    packageMetadata?: OpenForgePackageMetadata;
+    storage?: PluginStorage;
+    /**
+     * Tasks returned by `tasks.list`. The mock filters them by the requested
+     * `projectId` (when given) and drops `done` tasks unless `includeDone: true`,
+     * mirroring the host capability. Defaults to an empty list.
+     */
+    tasks?: Task[];
+}
+export interface TestingOpenForgeApiCalls {
+    commandInvocations: Array<{
+        id: string;
+        qualifiedId: string;
+        payload: unknown;
+    }>;
+    globalCommandInvocations: Array<{
+        qualifiedId: string;
+        payload: unknown;
+    }>;
+    backendInvocations: Array<{
+        method: string;
+        qualifiedId: string;
+        payload: unknown;
+    }>;
+    emittedEvents: Array<{
+        event: string;
+        qualifiedEvent: string;
+        payload: unknown;
+    }>;
+    emittedGlobalEvents: Array<{
+        qualifiedEvent: string;
+        payload: unknown;
+    }>;
+    openUrl: string[];
+    clipboardWrites: string[];
+    taskLinkOpenRequests: TaskLinkOpenRequest[];
+    navigationRequests: OpenForgeNavigationRequest[];
+    notify: NotificationRequest[];
+    taskCreations: CreateTaskRequest[];
+    taskComposes: ComposeTaskRequest[];
+    startPromptContributionConfigurations: ConfigureStartPromptContributionRequest[];
+    taskImplementationStarts: StartTaskImplementationRequest[];
+    taskFollowUps: SendTaskFollowUpRequest[];
+    taskListRequests: Array<{
+        projectId: string | null;
+        includeDone: boolean;
+    }>;
+    taskStatusUpdates: Array<{
+        taskId: string;
+        status: string;
+    }>;
+    configWrites: Array<{
+        key: string;
+        value: JsonValue;
+        projectId: string | null;
+    }>;
+    fsWrites: Array<{
+        projectId: string;
+        path: string;
+        content: string;
+    }>;
+    fsUserDataReadDirs: UserDataDirectoryRequest[];
+    fsUserDataReads: UserDataFileRequest[];
+    fsUserDataWrites: UserDataFileWriteRequest[];
+    fsExternalReadDirs: ExternalReadDirectoryRequest[];
+    fsExternalReads: ExternalReadFileRequest[];
+    shellSpawns: ShellSpawnRequest[];
+    shellWrites: Array<{
+        taskId: string;
+        terminalIndex: number;
+        data: string;
+    }>;
+    shellResizes: Array<{
+        taskId: string;
+        terminalIndex: number;
+        cols: number;
+        rows: number;
+    }>;
+    shellKills: Array<{
+        taskId: string;
+        terminalIndex: number;
+    }>;
+    shellBuffers: Array<{
+        taskId: string;
+        terminalIndex: number;
+    }>;
+    browserSurfaceGetOrCreate: Array<{
+        taskId: string;
+        id: string;
+        initialUrl?: string;
+    }>;
+    browserSurfaceAttachments: Array<{
+        taskId: string;
+        id: string;
+        element: HTMLElement;
+    }>;
+    browserSurfaceDetaches: Array<{
+        taskId: string;
+        id: string;
+    }>;
+    browserSurfaceDestroys: Array<{
+        taskId: string;
+        id: string;
+    }>;
+    browserSurfaceNavigations: Array<{
+        taskId: string;
+        id: string;
+        url: string;
+    }>;
+    browserSurfaceControls: Array<{
+        taskId: string;
+        id: string;
+        action: 'goBack' | 'goForward' | 'reload' | 'stop';
+    }>;
+    browserSurfaceSelections: Array<{
+        taskId: string;
+        id: string;
+    }>;
+    browserSurfaceFeedbackClears: Array<{
+        taskId: string;
+        id: string;
+    }>;
+    browserSurfaceFeedbackReplacements: Array<{
+        taskId: string;
+        id: string;
+        feedback: BrowserSurfaceVisualFeedback[];
+    }>;
+    browserSurfaceCaptureChecks: Array<{
+        taskId: string;
+        id: string;
+        artifactId: string;
+    }>;
+    browserSurfaceCaptures: Array<{
+        taskId: string;
+        id: string;
+    }>;
+    browserSurfaceCaptureDiscards: Array<{
+        taskId: string;
+        id: string;
+        artifactId: string;
+    }>;
+    browserSurfaceSessionResets: Array<Record<string, never>>;
+    storageGets: Array<{
+        scope: TestingRuntimeScope;
+        scopeId: string | null;
+        key: string;
+    }>;
+    storageSets: Array<{
+        scope: TestingRuntimeScope;
+        scopeId: string | null;
+        key: string;
+        value: JsonValue;
+    }>;
+    storageDeletes: Array<{
+        scope: TestingRuntimeScope;
+        scopeId: string | null;
+        key: string;
+    }>;
+}
+export interface TestingContributionBase {
+    id: string;
+    qualifiedId: string;
+    pluginId: string;
+    projectId: string | null;
+}
+export type TestingCommandContribution = TestingContributionBase & CommandRegistration & {
+    title: string;
+    icon?: string;
+    shortcut?: CommandShortcutMetadata;
+    handler: TestingCommandHandler;
+};
+export type TestingEventListenerContribution = TestingContributionBase & {
+    handler: TestingEventHandler;
+    global: boolean;
+};
+export type TestingViewContribution = TestingContributionBase & PluginViewRegistration;
+export type TestingTaskPaneTabContribution = TestingContributionBase & PluginTaskPaneTabRegistration;
+export type TestingTaskUISectionContribution = TestingContributionBase & PluginTaskUISectionRegistration;
+export type TestingSettingsSectionContribution = TestingContributionBase & PluginSettingsSectionRegistration;
+export type TestingBackendMethodContribution = TestingContributionBase & {
+    registration: BackendMethodRegistration;
+};
+export type TestingBackgroundServiceContribution = TestingContributionBase & BackgroundServiceRegistration & {
+    started: boolean;
+};
+export interface TestingInjectionPointContribution {
+    id: string;
+    location: InjectionPointLocation;
+}
+export interface TestingTaskStartPrefixProviderContribution {
+    id: string;
+    title: string;
+    order: number;
+    provide(context: TaskStartPrefixContext): TestingMaybePromise<string | null>;
+}
+export interface TestingOpenForgeRegistrySnapshot {
+    pluginId: string;
+    projectId: string | null;
+    views: TestingViewContribution[];
+    taskPaneTabs: TestingTaskPaneTabContribution[];
+    taskUISections: TestingTaskUISectionContribution[];
+    settingsSections: TestingSettingsSectionContribution[];
+    commands: TestingCommandContribution[];
+    eventListeners: TestingEventListenerContribution[];
+    backendMethods: TestingBackendMethodContribution[];
+    backgroundServices: TestingBackgroundServiceContribution[];
+    injectionPoints: TestingInjectionPointContribution[];
+    taskStartPrefixProviders: TestingTaskStartPrefixProviderContribution[];
+}
+export type MockFrontendOpenForgeAPI = FrontendOpenForgeAPI & {
+    readonly __testing: {
+        readonly calls: TestingOpenForgeApiCalls;
+        readonly registry: TestingOpenForgeRegistryFake;
+    };
+};
+export type MockBackendOpenForgeAPI = BackendOpenForgeAPI & {
+    readonly __testing: {
+        readonly calls: TestingOpenForgeApiCalls;
+        readonly registry: TestingOpenForgeRegistryFake;
+    };
+};

package/dist/testing/contracts.js

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

package/dist/testing/frontendContributionFake.d.ts

@@ -0,0 +1,36 @@
+import { type TaskBrowserSurfaceState } from '../browserSurfaces';
+import type { FrontendOpenForgeAPI } from '../types';
+import { type TestingRegistryServices } from './support';
+import type { TestingInjectionPointContribution, TestingTaskStartPrefixProviderContribution, TestingSettingsSectionContribution, TestingTaskPaneTabContribution, TestingTaskUISectionContribution, TestingViewContribution } from './contracts';
+type TestingFrontendContributionApi = Pick<FrontendOpenForgeAPI, 'browserSurfaces' | 'taskLinks' | 'views' | 'taskUI' | 'taskPane' | 'settings' | 'backend' | 'injectionPoints' | 'taskStart'>;
+export declare class TestingFrontendContributionFake {
+    private readonly services;
+    private readonly invokeBackendMethod;
+    private readonly views;
+    private readonly taskPaneTabs;
+    private readonly taskUISections;
+    private readonly settingsSections;
+    private readonly injectionPoints;
+    private readonly taskStartPrefixProviders;
+    private readonly browserSurfaces;
+    private taskLinkHandler;
+    private api;
+    constructor(services: TestingRegistryServices, invokeBackendMethod: (method: string, payload?: unknown) => Promise<unknown>);
+    createApi(): TestingFrontendContributionApi;
+    setBrowserSurfaceState(taskId: string, id: string, patch: Partial<TaskBrowserSurfaceState>): void;
+    getSnapshot(): {
+        views: TestingViewContribution[];
+        taskPaneTabs: TestingTaskPaneTabContribution[];
+        taskUISections: TestingTaskUISectionContribution[];
+        settingsSections: TestingSettingsSectionContribution[];
+        injectionPoints: TestingInjectionPointContribution[];
+        taskStartPrefixProviders: TestingTaskStartPrefixProviderContribution[];
+    };
+    private registerView;
+    private registerTaskPaneTab;
+    private registerTaskUISection;
+    private registerSettingsSection;
+    private registerTaskStartPrefixProvider;
+    private registerInjectionPoint;
+}
+export {};

package/dist/testing/frontendContributionFake.js

@@ -0,0 +1,204 @@
+import { createTestingBrowserSurfaces } from '../browserSurfacesTesting';
+import { isAllowedBrowserSurfaceUrl } from '../browserSurfaces';
+import { assertFunction, assertTitle, createDisposable, } from './support';
+export class TestingFrontendContributionFake {
+    services;
+    invokeBackendMethod;
+    views = new Map();
+    taskPaneTabs = new Map();
+    taskUISections = new Map();
+    settingsSections = new Map();
+    injectionPoints = new Map();
+    taskStartPrefixProviders = new Map();
+    browserSurfaces;
+    taskLinkHandler = null;
+    api = null;
+    constructor(services, invokeBackendMethod) {
+        this.services = services;
+        this.invokeBackendMethod = invokeBackendMethod;
+        this.browserSurfaces = createTestingBrowserSurfaces(services.calls);
+    }
+    createApi() {
+        if (this.api)
+            return this.api;
+        const api = {
+            browserSurfaces: this.browserSurfaces.api,
+            taskLinks: {
+                open: async (request) => {
+                    this.services.calls.taskLinkOpenRequests.push(request);
+                    if (!isAllowedBrowserSurfaceUrl(request.url)) {
+                        throw new Error('Task links must use a valid HTTP(S) URL');
+                    }
+                    if (this.taskLinkHandler === null) {
+                        this.services.calls.openUrl.push(request.url);
+                        return;
+                    }
+                    const result = await this.taskLinkHandler(request);
+                    if (result === 'declined') {
+                        this.services.calls.openUrl.push(request.url);
+                        return;
+                    }
+                    if (result !== 'handled') {
+                        throw new Error(`Task link handler returned an invalid result: ${String(result)}`);
+                    }
+                },
+                registerHandler: (handler) => {
+                    if (this.taskLinkHandler !== null) {
+                        throw new Error('A Task link handler is already registered');
+                    }
+                    this.taskLinkHandler = handler;
+                    return createDisposable(() => {
+                        if (this.taskLinkHandler === handler)
+                            this.taskLinkHandler = null;
+                    });
+                },
+            },
+            views: {
+                register: (registration) => this.registerView(registration),
+            },
+            taskUI: {
+                registerTab: (registration) => this.registerTaskPaneTab(registration),
+                registerSection: (registration) => this.registerTaskUISection(registration),
+            },
+            taskPane: {
+                registerTab: (registration) => this.registerTaskPaneTab(registration),
+            },
+            settings: {
+                registerSection: (registration) => this.registerSettingsSection(registration),
+            },
+            backend: {
+                state: 'ready',
+                whenReady: async () => undefined,
+                onReady: (handler) => {
+                    handler();
+                    return createDisposable(() => undefined);
+                },
+                invoke: async (method, payload) => this.invokeBackendMethod(method, payload),
+            },
+            injectionPoints: {
+                register: (registration) => this.registerInjectionPoint(registration),
+            },
+            taskStart: {
+                registerPrefixProvider: (registration) => this.registerTaskStartPrefixProvider(registration),
+            },
+        };
+        this.api = api;
+        return api;
+    }
+    setBrowserSurfaceState(taskId, id, patch) {
+        this.browserSurfaces.setState(taskId, id, patch);
+    }
+    getSnapshot() {
+        return {
+            views: Array.from(this.views.values()),
+            taskPaneTabs: Array.from(this.taskPaneTabs.values()),
+            taskUISections: Array.from(this.taskUISections.values()),
+            settingsSections: Array.from(this.settingsSections.values()),
+            injectionPoints: Array.from(this.injectionPoints.values()),
+            taskStartPrefixProviders: Array.from(this.taskStartPrefixProviders.values()).sort((left, right) => left.order - right.order || left.id.localeCompare(right.id)),
+        };
+    }
+    registerView(registration) {
+        const qualifiedId = this.services.localQualifiedId('views', registration.id);
+        assertTitle('views', registration.title);
+        assertFunction('views', 'component', registration.component);
+        if (registration.navigationComponent !== undefined) {
+            assertFunction('views', 'navigationComponent', registration.navigationComponent);
+            if (registration.placement !== 'sidebar') {
+                throw new Error('views registration custom navigation requires sidebar placement');
+            }
+            if (!this.services.packageMetadata.requires?.includes('customSidebarNavigation')) {
+                throw new Error('views registration custom navigation requires the customSidebarNavigation capability');
+            }
+        }
+        this.services.claims.claim('views', qualifiedId);
+        const contribution = {
+            ...registration,
+            id: registration.id.trim(),
+            title: registration.title.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+        };
+        this.views.set(qualifiedId, contribution);
+        return createDisposable(() => {
+            this.views.delete(qualifiedId);
+            this.services.claims.release('views', qualifiedId);
+        });
+    }
+    registerTaskPaneTab(registration) {
+        const qualifiedId = this.services.localQualifiedId('taskPane', registration.id);
+        assertTitle('taskPane', registration.title);
+        assertFunction('taskPane', 'component', registration.component);
+        this.services.claims.claim('taskPane', qualifiedId);
+        const contribution = {
+            ...registration,
+            id: registration.id.trim(),
+            title: registration.title.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+        };
+        this.taskPaneTabs.set(qualifiedId, contribution);
+        return createDisposable(() => {
+            this.taskPaneTabs.delete(qualifiedId);
+            this.services.claims.release('taskPane', qualifiedId);
+        });
+    }
+    registerTaskUISection(registration) {
+        const qualifiedId = this.services.localQualifiedId('taskUI', registration.id);
+        assertFunction('taskUI', 'component', registration.component);
+        this.services.claims.claim('taskUI', qualifiedId);
+        const contribution = {
+            ...registration,
+            id: registration.id.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+        };
+        this.taskUISections.set(qualifiedId, contribution);
+        return createDisposable(() => {
+            this.taskUISections.delete(qualifiedId);
+            this.services.claims.release('taskUI', qualifiedId);
+        });
+    }
+    registerSettingsSection(registration) {
+        const qualifiedId = this.services.localQualifiedId('settings', registration.id);
+        assertTitle('settings', registration.title);
+        assertFunction('settings', 'component', registration.component);
+        this.services.claims.claim('settings', qualifiedId);
+        const contribution = {
+            ...registration,
+            id: registration.id.trim(),
+            title: registration.title.trim(),
+            qualifiedId,
+            pluginId: this.services.pluginId,
+            projectId: this.services.projectId,
+        };
+        this.settingsSections.set(qualifiedId, contribution);
+        return createDisposable(() => {
+            this.settingsSections.delete(qualifiedId);
+            this.services.claims.release('settings', qualifiedId);
+        });
+    }
+    registerTaskStartPrefixProvider(registration) {
+        this.taskStartPrefixProviders.set(registration.id, {
+            id: registration.id,
+            title: registration.title,
+            order: registration.order ?? 0,
+            provide: (context) => registration.provide(context),
+        });
+        return createDisposable(() => {
+            this.taskStartPrefixProviders.delete(registration.id);
+        });
+    }
+    registerInjectionPoint(registration) {
+        this.injectionPoints.set(registration.id, {
+            id: registration.id,
+            location: registration.location,
+        });
+        return createDisposable(() => {
+            this.injectionPoints.delete(registration.id);
+        });
+    }
+}

package/dist/testing/registryFake.d.ts

@@ -0,0 +1,40 @@
+import type { TaskBrowserSurfaceState } from '../browserSurfaces';
+import type { BackendPlugin, BackendPluginContext, FrontendPlugin, FrontendPluginContext, OpenForgePackageMetadata, PluginStorage } from '../types';
+import type { MockBackendOpenForgeAPI, MockFrontendOpenForgeAPI, TestingOpenForgeApiCalls, TestingOpenForgeApiOptions, TestingOpenForgeRegistrySnapshot } from './contracts';
+import { TestingSubscriptionSink } from './support';
+export declare class TestingOpenForgeRegistryFake {
+    readonly pluginId: string;
+    readonly projectId: string | null;
+    readonly taskId: string | null;
+    readonly viewId: string;
+    readonly packageMetadata: OpenForgePackageMetadata;
+    readonly calls: TestingOpenForgeApiCalls;
+    readonly storage: PluginStorage;
+    readonly frontendSubscriptions: TestingSubscriptionSink;
+    readonly backendSubscriptions: TestingSubscriptionSink;
+    private readonly services;
+    private readonly commonApi;
+    private readonly frontendContributions;
+    private readonly backendServices;
+    private cachedFrontendApi;
+    private cachedBackendApi;
+    constructor(options?: TestingOpenForgeApiOptions);
+    get frontendApi(): MockFrontendOpenForgeAPI;
+    get backendApi(): MockBackendOpenForgeAPI;
+    get snapshot(): TestingOpenForgeRegistrySnapshot;
+    createFrontendApi(): MockFrontendOpenForgeAPI;
+    createBackendApi(): MockBackendOpenForgeAPI;
+    createFrontendContext(): FrontendPluginContext;
+    createBackendContext(): BackendPluginContext;
+    activateFrontend(plugin: FrontendPlugin): Promise<void>;
+    activateBackend(plugin: BackendPlugin): Promise<void>;
+    setBrowserSurfaceState(taskId: string, id: string, patch: Partial<TaskBrowserSurfaceState>): void;
+    disposeAll(): Promise<void>;
+    getSnapshot(): TestingOpenForgeRegistrySnapshot;
+    private createContext;
+}
+export declare function createOpenForgeRegistryFake(options?: TestingOpenForgeApiOptions): TestingOpenForgeRegistryFake;
+export declare function createMockOpenForgeApi(options?: TestingOpenForgeApiOptions): MockFrontendOpenForgeAPI;
+export declare function createMockFrontendOpenForgeApi(options?: TestingOpenForgeApiOptions): MockFrontendOpenForgeAPI;
+export declare function createMockBackendOpenForgeApi(options?: TestingOpenForgeApiOptions): MockBackendOpenForgeAPI;
+export declare function createMockPluginContext(options?: TestingOpenForgeApiOptions): FrontendPluginContext;

package/dist/testing/registryFake.js

@@ -0,0 +1,124 @@
+import { TestingBackendServicesFake } from './backendServicesFake';
+import { TestingCommonApiFake } from './commonApiFake';
+import { TestingFrontendContributionFake } from './frontendContributionFake';
+import { TestingRegistryServices, TestingSubscriptionSink, } from './support';
+export class TestingOpenForgeRegistryFake {
+    pluginId;
+    projectId;
+    taskId;
+    viewId;
+    packageMetadata;
+    calls;
+    storage;
+    frontendSubscriptions = new TestingSubscriptionSink();
+    backendSubscriptions = new TestingSubscriptionSink();
+    services;
+    commonApi;
+    frontendContributions;
+    backendServices;
+    cachedFrontendApi = null;
+    cachedBackendApi = null;
+    constructor(options = {}) {
+        this.services = new TestingRegistryServices(options);
+        this.pluginId = this.services.pluginId;
+        this.projectId = this.services.projectId;
+        this.taskId = this.services.taskId;
+        this.viewId = this.services.viewId;
+        this.packageMetadata = this.services.packageMetadata;
+        this.calls = this.services.calls;
+        this.storage = this.services.storage;
+        this.commonApi = new TestingCommonApiFake(this.services);
+        this.backendServices = new TestingBackendServicesFake(this.services);
+        this.frontendContributions = new TestingFrontendContributionFake(this.services, (method, payload) => this.backendServices.invokeMethod(method, payload));
+    }
+    get frontendApi() {
+        return this.createFrontendApi();
+    }
+    get backendApi() {
+        return this.createBackendApi();
+    }
+    get snapshot() {
+        return this.getSnapshot();
+    }
+    createFrontendApi() {
+        if (this.cachedFrontendApi)
+            return this.cachedFrontendApi;
+        const api = {
+            ...this.commonApi.createApi(),
+            ...this.frontendContributions.createApi(),
+            __testing: {
+                calls: this.calls,
+                registry: this,
+            },
+        };
+        this.cachedFrontendApi = api;
+        return api;
+    }
+    createBackendApi() {
+        if (this.cachedBackendApi)
+            return this.cachedBackendApi;
+        const api = {
+            ...this.commonApi.createBackendApi(),
+            ...this.backendServices.createApi(),
+            __testing: {
+                calls: this.calls,
+                registry: this,
+            },
+        };
+        this.cachedBackendApi = api;
+        return api;
+    }
+    createFrontendContext() {
+        return this.createContext(this.frontendSubscriptions);
+    }
+    createBackendContext() {
+        return this.createContext(this.backendSubscriptions);
+    }
+    async activateFrontend(plugin) {
+        await plugin.activate(this.frontendApi, this.createFrontendContext());
+    }
+    async activateBackend(plugin) {
+        const existingServices = this.backendServices.captureBackgroundServiceIds();
+        await plugin.activate(this.backendApi, this.createBackendContext());
+        await this.backendServices.startNewBackgroundServices(existingServices);
+    }
+    setBrowserSurfaceState(taskId, id, patch) {
+        this.frontendContributions.setBrowserSurfaceState(taskId, id, patch);
+    }
+    async disposeAll() {
+        await this.backendSubscriptions.disposeAll();
+        await this.frontendSubscriptions.disposeAll();
+    }
+    getSnapshot() {
+        return {
+            pluginId: this.pluginId,
+            projectId: this.projectId,
+            ...this.frontendContributions.getSnapshot(),
+            ...this.commonApi.getSnapshot(),
+            ...this.backendServices.getSnapshot(),
+        };
+    }
+    createContext(subscriptions) {
+        return {
+            pluginId: this.pluginId,
+            apiVersion: 1,
+            packageMetadata: this.packageMetadata,
+            subscriptions,
+        };
+    }
+}
+export function createOpenForgeRegistryFake(options = {}) {
+    return new TestingOpenForgeRegistryFake(options);
+}
+export function createMockOpenForgeApi(options = {}) {
+    return createMockFrontendOpenForgeApi(options);
+}
+export function createMockFrontendOpenForgeApi(options = {}) {
+    return createOpenForgeRegistryFake(options).frontendApi;
+}
+export function createMockBackendOpenForgeApi(options = {}) {
+    return createOpenForgeRegistryFake(options).backendApi;
+}
+export function createMockPluginContext(options = {}) {
+    return createOpenForgeRegistryFake(options).createFrontendContext();
+}

package/dist/testing/support.d.ts

@@ -0,0 +1,40 @@
+import type { AgentCommandMetadata, CommandDescriptor, Disposable, JsonValue, OpenForgeContextSnapshot, OpenForgeNavigationRequest, OpenForgeNavigationSnapshot, OpenForgePackageMetadata, PluginStorage, StartPromptContribution, SubscriptionSink } from '../types';
+import type { Task } from '../domain';
+import type { TestingCommandContribution, TestingMaybePromise, TestingOpenForgeApiCalls, TestingOpenForgeApiOptions, TestingRuntimeKind } from './contracts';
+export declare function createDisposable(dispose: () => TestingMaybePromise<void>): Disposable;
+export declare class TestingSubscriptionSink implements SubscriptionSink {
+    readonly subscriptions: Disposable[];
+    add(subscription: Disposable | (() => void)): void;
+    disposeAll(): Promise<void>;
+}
+export declare function createTestingCalls(): TestingOpenForgeApiCalls;
+export declare function createMemoryPluginStorage(calls?: TestingOpenForgeApiCalls): PluginStorage;
+export declare function commandDescriptor(command: TestingCommandContribution): CommandDescriptor;
+export declare function normalizeAgentCommandMetadata(metadata: unknown): AgentCommandMetadata | undefined;
+export declare function isJsonValue(value: unknown, seen?: Set<object>): value is JsonValue;
+export declare function assertLocalId(kind: TestingRuntimeKind, id: string): void;
+export declare function assertTitle(kind: TestingRuntimeKind, title: string): void;
+export declare function assertFunction(kind: TestingRuntimeKind, field: string, value: unknown): void;
+export declare class TestingContributionClaims {
+    private readonly ids;
+    claim(kind: TestingRuntimeKind, qualifiedId: string): void;
+    release(kind: TestingRuntimeKind, qualifiedId: string): void;
+    private key;
+}
+export declare class TestingRegistryServices {
+    readonly pluginId: string;
+    readonly projectId: string | null;
+    readonly taskId: string | null;
+    readonly viewId: string;
+    readonly packageMetadata: OpenForgePackageMetadata;
+    readonly calls: TestingOpenForgeApiCalls;
+    readonly storage: PluginStorage;
+    readonly config: Map<string, JsonValue>;
+    readonly seededTasks: Task[];
+    readonly claims: TestingContributionClaims;
+    constructor(options?: TestingOpenForgeApiOptions);
+    localQualifiedId(kind: TestingRuntimeKind, id: string): string;
+    getContextSnapshot(): OpenForgeContextSnapshot;
+    getNavigationSnapshot(overrides?: OpenForgeNavigationRequest): OpenForgeNavigationSnapshot;
+    startPromptContributions(projectId: string): StartPromptContribution[];
+}