Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

fix(plugins): retain replacement search providers

Yudhi Armyndharis6a6610a3b116
diff --git a/src/core/plugins/plugin-loader-sandbox-routing.spec.ts b/src/core/plugins/plugin-loader-sandbox-routing.spec.ts
index ccf5b5988..cbe7c7b29 100644
--- a/src/core/plugins/plugin-loader-sandbox-routing.spec.ts
+++ b/src/core/plugins/plugin-loader-sandbox-routing.spec.ts
@@ -6,6 +6,8 @@ import { HookContext, HookEvent, HookHandler, HookManager } from '../hooks';
import { IPlugin, PluginInstance, PluginManifest, PluginStatus, PluginType } from './plugin.interfaces';
import { PluginWorkerHost } from './sandbox/plugin-worker-host';
import { PluginLogLevel } from './sandbox/protocol';
+import { PLUGIN_SEARCH_REGISTRY_PORT } from './plugin-host-ports';
+import { SearchProviderRegistry } from '../../modules/search/search-provider.registry';
type FakeHost = {
load: jest.Mock;
@@ -13,6 +15,7 @@ type FakeHost = {
terminate: jest.Mock;
dispatchHook: jest.Mock;
healthCheck: jest.Mock;
+ dispatchSearch: jest.Mock;
};
/** Loader that returns fake worker hosts so routing is testable without spawning a real OS thread. */
@@ -22,13 +25,14 @@ class TestableLoader extends PluginLoaderService {
capturedOnLog?: (level: PluginLogLevel, message: string, meta?: Record<string, unknown>) => void;
capturedOnWorkerExit?: (code: number, intentional: boolean, reason?: string) => void;
capturedOnUnresponsive?: () => void;
+ capturedOnSearchProviderRegister?: () => void;
protected createSandboxHost(
_capDispatcher?: (verb: string, args: unknown[]) => Promise<unknown>,
onHookSubscribe?: (event: string, priority?: number) => void,
_onWebhookSubscribe?: (route: string) => void,
onLog?: (level: PluginLogLevel, message: string, meta?: Record<string, unknown>) => void,
_runWithHookGuard?: (inFlightEvents: string[], run: () => Promise<unknown>) => Promise<unknown>,
- _onSearchProviderRegister?: () => void,
+ onSearchProviderRegister?: () => void,
onWorkerExit?: (code: number, intentional: boolean, reason?: string) => void,
onUnresponsive?: () => void,
): PluginWorkerHost {
@@ -36,20 +40,27 @@ class TestableLoader extends PluginLoaderService {
this.capturedOnLog = onLog;
this.capturedOnWorkerExit = onWorkerExit;
this.capturedOnUnresponsive = onUnresponsive;
+ this.capturedOnSearchProviderRegister = onSearchProviderRegister;
const host: FakeHost = {
load: jest.fn().mockResolvedValue(undefined),
runLifecycle: jest.fn().mockResolvedValue(undefined),
terminate: jest.fn().mockResolvedValue(undefined),
dispatchHook: jest.fn().mockResolvedValue({ continue: true }),
healthCheck: jest.fn().mockResolvedValue({ healthy: true }),
+ dispatchSearch: jest.fn().mockResolvedValue({
+ ok: true,
+ results: { hits: [], total: 0, tookMs: 1, provider: 'plugin:p1' },
+ }),
};
this.hosts.push(host);
return host as unknown as PluginWorkerHost;
}
}
-function makeLoader(): TestableLoader {
- const configService = { get: jest.fn().mockReturnValue(undefined) } as unknown as ConfigService;
+function makeLoader(registry?: SearchProviderRegistry, searchMode = 'auto'): TestableLoader {
+ const configService = {
+ get: jest.fn((key: string) => (key === 'search.provider' ? searchMode : undefined)),
+ } as unknown as ConfigService;
const pluginStorage = {
createPluginStorage: jest.fn().mockReturnValue({}),
getPluginConfig: jest.fn().mockReturnValue(undefined),
@@ -57,7 +68,9 @@ function makeLoader(): TestableLoader {
setPluginEntry: jest.fn(),
setPluginStatus: jest.fn(),
} as unknown as PluginStorageService;
- const moduleRef = { get: jest.fn() } as unknown as ModuleRef;
+ const moduleRef = {
+ get: jest.fn((token: unknown) => (token === PLUGIN_SEARCH_REGISTRY_PORT ? registry : undefined)),
+ } as unknown as ModuleRef;
return new TestableLoader(configService, new HookManager(), pluginStorage, moduleRef);
}
@@ -477,6 +490,123 @@ describe('PluginLoaderService - blocked sandbox worker', () => {
});
});
+describe('PluginLoaderService - sandbox search provider ownership', () => {
+ const setup = async (mode = 'auto', searchEnabled = true) => {
+ const registry = new SearchProviderRegistry();
+ registry.register({ id: 'builtin-fts', label: 'Built-in', search: jest.fn(), health: jest.fn() });
+ const loader = makeLoader(searchEnabled ? registry : undefined, mode);
+ seed(loader, { builtIn: false, instance: null });
+ pluginOf(loader).manifest.permissions = ['search:provide'];
+ await loader.enablePlugin('p1');
+ loader.capturedOnSearchProviderRegister!();
+ return { loader, registry };
+ };
+
+ it.each([true, false])(
+ 'preserves the replacement provider when a retired worker exits (intentional=%s)',
+ async intentional => {
+ const { loader, registry } = await setup();
+ const oldExit = loader.capturedOnWorkerExit!;
+ let finishTermination!: () => void;
+ loader.hosts[0].terminate.mockReturnValueOnce(new Promise<void>(resolve => (finishTermination = resolve)));
+ loader.capturedOnUnresponsive!();
+ expect(pluginOf(loader).status).toBe(PluginStatus.ERROR);
+ await loader.enablePlugin('p1');
+ loader.capturedOnSearchProviderRegister!();
+ loader.capturedOnHookSubscribe!('message:received');
+ const currentProvider = registry.active();
+ const hooks = (loader as unknown as { hookManager: HookManager }).hookManager;
+ const unregister = jest.spyOn(hooks, 'unregisterPlugin');
+
+ oldExit(1, intentional);
+ finishTermination();
+
+ expect(registry.active()).toBe(currentProvider);
+ expect(registry.active()?.id).toBe('plugin:p1');
+ await expect(registry.active()!.search({ q: 'hello' })).resolves.toEqual({
+ hits: [],
+ total: 0,
+ tookMs: 1,
+ provider: 'plugin:p1',
+ });
+ expect(loader.hosts[1].dispatchSearch).toHaveBeenCalled();
+ expect(pluginOf(loader).status).toBe(PluginStatus.ENABLED);
+ expect((loader as unknown as { sandboxHosts: Map<string, unknown> }).sandboxHosts.get('p1')).toBe(
+ loader.hosts[1],
+ );
+ expect(unregister).not.toHaveBeenCalled();
+ expect(loader.hosts[1].terminate).not.toHaveBeenCalled();
+ },
+ );
+
+ it('removes an unresponsive worker provider when its host entry is already absent', async () => {
+ const { loader, registry } = await setup();
+ loader.capturedOnUnresponsive!();
+ expect((loader as unknown as { sandboxHosts: Map<string, unknown> }).sandboxHosts.has('p1')).toBe(false);
+
+ loader.capturedOnWorkerExit!(1, true);
+
+ expect(registry.list().map(provider => provider.id)).toEqual(['builtin-fts']);
+ expect(registry.active()?.id).toBe('builtin-fts');
+ expect(pluginOf(loader).status).toBe(PluginStatus.ERROR);
+ });
+
+ it('removes the current worker provider after an unexpected exit', async () => {
+ const { loader, registry } = await setup();
+
+ loader.capturedOnWorkerExit!(1, false);
+
+ expect(registry.list().map(provider => provider.id)).toEqual(['builtin-fts']);
+ expect(registry.active()?.id).toBe('builtin-fts');
+ expect(pluginOf(loader).status).toBe(PluginStatus.ERROR);
+ });
+
+ it.each(['builtin-fts', 'none', 'disabled'])('preserves search mode %s across worker replacement', async mode => {
+ const { loader, registry } = await setup(mode, mode !== 'disabled');
+ const oldExit = loader.capturedOnWorkerExit!;
+ loader.capturedOnUnresponsive!();
+ await loader.enablePlugin('p1');
+ loader.capturedOnSearchProviderRegister!();
+
+ oldExit(1, true);
+
+ expect(registry.active()?.id).toBe('builtin-fts');
+ expect(registry.list().map(provider => provider.id)).toEqual(
+ mode === 'builtin-fts' ? ['builtin-fts', 'plugin:p1'] : ['builtin-fts'],
+ );
+ expect(pluginOf(loader).status).toBe(PluginStatus.ENABLED);
+ });
+
+ it('registers a replacement normally when the retired worker exits first', async () => {
+ const { loader, registry } = await setup();
+ const oldExit = loader.capturedOnWorkerExit!;
+ loader.capturedOnUnresponsive!();
+ oldExit(1, true);
+ expect(registry.active()?.id).toBe('builtin-fts');
+
+ await loader.enablePlugin('p1');
+ loader.capturedOnSearchProviderRegister!();
+
+ expect(registry.active()?.id).toBe('plugin:p1');
+ });
+
+ it.each(['disable', 'unload'])('removes the provider during normal %s', async operation => {
+ const { loader, registry } = await setup();
+ const onExit = loader.capturedOnWorkerExit!;
+
+ if (operation === 'disable') await loader.disablePlugin('p1');
+ else await loader.unloadPlugin('p1');
+ onExit(0, true);
+
+ expect(loader.hosts[0].terminate).toHaveBeenCalledTimes(1);
+ expect(registry.list().map(provider => provider.id)).toEqual(['builtin-fts']);
+ expect(registry.active()?.id).toBe('builtin-fts');
+ expect((loader as unknown as { sandboxHosts: Map<string, unknown> }).sandboxHosts.has('p1')).toBe(false);
+ if (operation === 'disable') expect(pluginOf(loader).status).toBe(PluginStatus.DISABLED);
+ else expect(pluginOf(loader)).toBeUndefined();
+ });
+});
+
describe('PluginLoaderService — sandbox log relay bounds', () => {
const loggerOf = (loader: TestableLoader): { warn: jest.Mock; log: jest.Mock } =>
(loader as unknown as { logger: { warn: jest.Mock; log: jest.Mock } }).logger;
diff --git a/src/core/plugins/plugin-sandbox-bridge.ts b/src/core/plugins/plugin-sandbox-bridge.ts
index 9700e1b3a..61fabedce 100644
--- a/src/core/plugins/plugin-sandbox-bridge.ts
+++ b/src/core/plugins/plugin-sandbox-bridge.ts
@@ -337,7 +337,7 @@ export class PluginSandboxBridge {
const onSearchProviderRegister = this.buildSearchProviderRegistrar(pluginId, plugin);
- const onWorkerExit = this.buildWorkerExitHandler(pluginId, logRelayState);
+ const onWorkerExit = this.buildWorkerExitHandler(pluginId, logRelayState, () => host);
// A worker whose event loop stays blocked after a dispatch timeout (a synchronous loop in plugin
// code) would otherwise keep running and queue every later dispatch for the full budget each.
@@ -646,6 +646,7 @@ export class PluginSandboxBridge {
private buildWorkerExitHandler(
pluginId: string,
logRelayState: SandboxLogRelayState,
+ getSourceHost: () => PluginWorkerHost,
): (code: number, intentional: boolean, reason?: string) => void {
return (code: number, intentional: boolean, reason?: string): void => {
// Final log-relay flush: the per-window drop warn above only fires when a new line arrives in a
@@ -658,9 +659,10 @@ export class PluginSandboxBridge {
);
logRelayState.dropped = 0;
}
- // Always release the search-provider slot so the registry can fall back to builtin-fts. On a crash
- // this is the only cleanup; on a deliberate disable/enable-failure the explicit unregister already
- // ran, making this a harmless no-op.
+ // A replacement owns its provider, hooks and status. An absent host still needs cleanup after
+ // markWorkerFailed removed the retiring worker before its termination completed.
+ const currentHost = this.sandboxHosts.get(pluginId);
+ if (currentHost && currentHost !== getSourceHost()) return;
unregisterPluginSearchProvider(this.hostServices.getSearchRegistryPort(), pluginId);
if (intentional) return; // routine disable/enable-failure already logged and expected
// Unexpected crash after a successful enable: the worker is gone. Drop the dead host +