| import fs from "node:fs"; |
| import path from "node:path"; |
| import type { DatabaseSync } from "node:sqlite"; |
| import { afterAll, afterEach, describe, expect, it } from "vitest"; |
| import type { OpenClawConfig } from "../config/types.js"; |
| import { acquirePluginRegistryForInspection, loadPluginRegistryHandle } from "../plugins/loader.js"; |
| import { |
| cleanupPluginLoaderFixturesForTest, |
| makePluginLoaderTempDir, |
| resetPluginLoaderTestStateForTest, |
| useNoBundledPlugins, |
| writePlugin, |
| } from "../plugins/loader.test-fixtures.js"; |
| import { clearPluginMetadataLifecycleCaches } from "../plugins/plugin-metadata-lifecycle.js"; |
| import { withPluginRuntimeRegistryScope } from "../plugins/runtime/gateway-request-scope.js"; |
| import { captureAsyncWorkTracker, trackAsyncWork } from "../shared/async-work-scope.js"; |
| import { createDeferredCore } from "../shared/deferred.js"; |
| import { withEnvAsync } from "../test-utils/env.js"; |
| import { generateMusic } from "./runtime.js"; |
|
|
| function createNativeMusicFixture( |
| rejectGeneration = false, |
| id = "native-music-owner", |
| disposalContext: "operation" | "registration" | "node-bound" = "operation", |
| ) { |
| const dir = makePluginLoaderTempDir(); |
| const alias = id === "native-music-owner" ? "native-music-alias" : `${id}-alias`; |
| const key = `__openclaw_music_resources_${path.basename(dir)}`; |
| const started = createDeferredCore(); |
| const resume = createDeferredCore(); |
| const connections: Array<{ |
| database: DatabaseSync; |
| disposals: number; |
| reads: number[]; |
| }> = []; |
| Object.defineProperty(globalThis, key, { |
| configurable: true, |
| value: { connections, started, resume, captureAsyncWorkTracker }, |
| }); |
| const plugin = writePlugin({ |
| dir, |
| id, |
| body: `const { DatabaseSync } = require("node:sqlite"); |
| module.exports = { |
| id: ${JSON.stringify(id)}, |
| register(api) { |
| const state = globalThis[${JSON.stringify(key)}]; |
| const database = new DatabaseSync(":memory:"); |
| const connection = { database, disposals: 0, reads: [] }; |
| state.connections.push(connection); |
| let trackCleanup = state.captureAsyncWorkTracker(); |
| const disposeNative = async () => { |
| await Promise.resolve(); |
| connection.reads.push(database.prepare("SELECT 42 AS value").get().value); |
| connection.disposals++; |
| database.close(); |
| }; |
| let runDispose = () => trackCleanup(disposeNative); |
| api.registerRuntimeLifecycle({ |
| id: "native-music-resource", |
| dispose: () => runDispose(), |
| }); |
| api.registerMusicGenerationProvider({ |
| id: ${JSON.stringify(id)}, |
| aliases: [${JSON.stringify(alias)}], |
| label: "Native music fixture", |
| defaultModel: "fixture-model", |
| capabilities: {}, |
| async generateMusic() { |
| if (${JSON.stringify(disposalContext)} === "operation") { |
| trackCleanup = state.captureAsyncWorkTracker(); |
| } else if (${JSON.stringify(disposalContext)} === "node-bound") { |
| runDispose = require("node:async_hooks").AsyncLocalStorage.bind(disposeNative); |
| } |
| connection.reads.push(database.prepare("SELECT 42 AS value").get().value); |
| state.started.resolve(); |
| await state.resume.promise; |
| connection.reads.push(database.prepare("SELECT 42 AS value").get().value); |
| if (${rejectGeneration}) throw new Error("native music generation failed"); |
| return { tracks: [{ buffer: Buffer.from("native music 42"), mimeType: "audio/mpeg" }] }; |
| }, |
| }); |
| }, |
| };`, |
| }); |
| fs.writeFileSync( |
| path.join(dir, "openclaw.plugin.json"), |
| JSON.stringify({ |
| id, |
| contracts: { musicGenerationProviders: [id] }, |
| configSchema: { type: "object", additionalProperties: false, properties: {} }, |
| }), |
| ); |
| const config: OpenClawConfig = { |
| plugins: { allow: [id], load: { paths: [plugin.file] }, slots: { memory: "none" } }, |
| }; |
| const run = () => |
| generateMusic({ |
| cfg: config, |
| prompt: "synthetic native resource proof", |
| modelOverride: `${alias}/fixture-model`, |
| autoProviderFallback: false, |
| }); |
| return { |
| config, |
| plugin, |
| connections, |
| started, |
| resume, |
| run, |
| withEnvironment: (operation: () => Promise<void>) => |
| withEnvAsync( |
| { |
| OPENCLAW_HOME: dir, |
| OPENCLAW_STATE_DIR: dir, |
| OPENCLAW_CONFIG_PATH: path.join(dir, "config.json"), |
| }, |
| operation, |
| ), |
| cleanup() { |
| resume.resolve(); |
| for (const { database } of connections) { |
| if (database.isOpen) { |
| database.close(); |
| } |
| } |
| Reflect.deleteProperty(globalThis, key); |
| }, |
| }; |
| } |
|
|
| async function waitForProviderStart( |
| started: Promise<void>, |
| operation: Promise<unknown>, |
| ): Promise<void> { |
| await Promise.race([ |
| started, |
| operation.then((outcome) => { |
| throw new Error("Music operation settled before invoking the native provider", { |
| cause: outcome, |
| }); |
| }), |
| ]); |
| } |
|
|
| afterEach(() => { |
| clearPluginMetadataLifecycleCaches(); |
| resetPluginLoaderTestStateForTest(); |
| }); |
| afterAll(cleanupPluginLoaderFixturesForTest); |
|
|
| describe("music generation registration resources", () => { |
| it.each([false, true])( |
| "releases a cold native registration after generation settles (reject=%s)", |
| async (rejectGeneration) => { |
| const fixture = createNativeMusicFixture(rejectGeneration); |
| try { |
| await fixture.withEnvironment(async () => { |
| useNoBundledPlugins(); |
| const result = fixture.run(); |
| const settled = result.then( |
| (value) => ({ value, error: undefined }), |
| (error: unknown) => ({ value: undefined, error }), |
| ); |
| try { |
| await waitForProviderStart(fixture.started.promise, settled); |
| expect(fixture.connections).toHaveLength(1); |
| expect(fixture.connections[0]!.database.isOpen).toBe(true); |
| expect(fixture.connections[0]!.disposals).toBe(0); |
| fixture.resume.resolve(); |
| const outcome = await settled; |
| if (rejectGeneration) { |
| expect(outcome.error).toBeInstanceOf(Error); |
| expect(String(outcome.error)).toContain("native music generation failed"); |
| } else { |
| expect(outcome.error).toBeUndefined(); |
| expect(outcome.value?.tracks[0]?.buffer.toString()).toBe("native music 42"); |
| expect(outcome.value?.provider).toBe("native-music-alias"); |
| } |
| expect(fixture.connections[0]!.database.isOpen).toBe(false); |
| expect(fixture.connections[0]!.disposals).toBe(1); |
| expect(fixture.connections[0]!.reads).toEqual([42, 42, 42]); |
| } finally { |
| fixture.resume.resolve(); |
| await settled; |
| } |
| }); |
| } finally { |
| fixture.cleanup(); |
| } |
| }, |
| ); |
|
|
| it("selects an override alias from a different eligible plugin than the configured model", async () => { |
| const configured = createNativeMusicFixture(false, "configured-music-owner"); |
| const override = createNativeMusicFixture(); |
| configured.resume.resolve(); |
| try { |
| await override.withEnvironment(async () => { |
| useNoBundledPlugins(); |
| const result = generateMusic({ |
| cfg: { |
| agents: { |
| defaults: { |
| mediaModels: { music: { primary: "configured-music-owner/fixture-model" } }, |
| }, |
| }, |
| plugins: { |
| allow: [configured.plugin.id, override.plugin.id], |
| load: { paths: [configured.plugin.file, override.plugin.file] }, |
| slots: { memory: "none" }, |
| }, |
| }, |
| prompt: "synthetic override selection proof", |
| modelOverride: "native-music-alias/fixture-model", |
| }); |
| const settled = result.then( |
| (value) => ({ value, error: undefined }), |
| (error: unknown) => ({ value: undefined, error }), |
| ); |
| try { |
| await waitForProviderStart(override.started.promise, settled); |
| expect(configured.connections).toHaveLength(1); |
| expect(override.connections).toHaveLength(1); |
| expect(configured.connections[0]!.reads).toEqual([]); |
| expect(override.connections[0]!.database.isOpen).toBe(true); |
| override.resume.resolve(); |
| const outcome = await settled; |
| expect(outcome.error).toBeUndefined(); |
| expect(outcome.value?.provider).toBe("native-music-alias"); |
| expect(outcome.value?.tracks[0]?.buffer.toString()).toBe("native music 42"); |
| for (const { database, disposals } of [ |
| ...configured.connections, |
| ...override.connections, |
| ]) { |
| expect(database.isOpen).toBe(false); |
| expect(disposals).toBe(1); |
| } |
| } finally { |
| override.resume.resolve(); |
| await settled; |
| } |
| }); |
| } finally { |
| configured.cleanup(); |
| override.cleanup(); |
| } |
| }); |
|
|
| it.each(["registration", "node-bound"] as const)( |
| "supports later managed-host disposal with %s cleanup context", |
| async (disposalContext) => { |
| const fixture = createNativeMusicFixture(false, "native-music-owner", disposalContext); |
| try { |
| await fixture.withEnvironment(async () => { |
| useNoBundledPlugins(); |
| const inspection = await acquirePluginRegistryForInspection({ config: fixture.config }); |
| try { |
| fixture.resume.resolve(); |
| const result = await withPluginRuntimeRegistryScope(inspection.registry, fixture.run); |
| expect(result.tracks[0]?.buffer.toString()).toBe("native music 42"); |
| expect(fixture.connections).toHaveLength(1); |
| expect(fixture.connections[0]!.database.isOpen).toBe(true); |
| expect(fixture.connections[0]!.disposals).toBe(0); |
| await inspection.release(); |
| expect(fixture.connections[0]!.database.isOpen).toBe(false); |
| expect(fixture.connections[0]!.reads).toEqual([42, 42, 42]); |
| expect(fixture.connections[0]!.disposals).toBe(1); |
| } finally { |
| fixture.resume.resolve(); |
| await inspection.release(); |
| } |
| }); |
| } finally { |
| fixture.cleanup(); |
| } |
| }, |
| ); |
|
|
| it("joins admitted getter work before releasing the last claim on projection failure", async () => { |
| const fixture = createNativeMusicFixture(); |
| const readGate = createDeferredCore(); |
| const entered = createDeferredCore(); |
| const projectionError = new Error("native music projection failed"); |
| let projectionWork: Promise<void> | undefined; |
| let parentRelease: Promise<void> | undefined; |
| let read: unknown; |
| try { |
| await fixture.withEnvironment(async () => { |
| useNoBundledPlugins(); |
| const inspection = await acquirePluginRegistryForInspection({ config: fixture.config }); |
| const connection = fixture.connections[0]!; |
| const provider = inspection.registry.musicGenerationProviders[0]!.provider; |
| Object.defineProperty(provider, "id", { |
| get() { |
| projectionWork ??= trackAsyncWork(async () => { |
| await readGate.promise; |
| read = connection.database.prepare("SELECT 42 AS value").get(); |
| }); |
| void projectionWork.catch(() => undefined); |
| parentRelease ??= inspection.release(); |
| entered.resolve(); |
| throw projectionError; |
| }, |
| }); |
| const settled = withPluginRuntimeRegistryScope(inspection.registry, fixture.run).then( |
| (value) => ({ value, error: undefined }), |
| (error: unknown) => ({ value: undefined, error }), |
| ); |
| try { |
| await waitForProviderStart(entered.promise, settled); |
| await new Promise<void>((resolve) => { |
| setImmediate(resolve); |
| }); |
| expect(connection.database.isOpen).toBe(true); |
| expect(connection.disposals).toBe(0); |
| readGate.resolve(); |
| const outcome = await settled; |
| expect(outcome.error).toBe(projectionError); |
| await projectionWork; |
| expect(read).toEqual({ value: 42 }); |
| expect(connection.database.isOpen).toBe(false); |
| expect(connection.disposals).toBe(1); |
| } finally { |
| readGate.resolve(); |
| fixture.resume.resolve(); |
| await Promise.allSettled([settled, projectionWork, parentRelease]); |
| await inspection.release(); |
| } |
| }); |
| } finally { |
| fixture.cleanup(); |
| } |
| }); |
|
|
| it.each(["managed", "managed-getter", "raw"] as const)( |
| "keeps %s registration resources until the operation settles", |
| async (ownership) => { |
| const fixture = createNativeMusicFixture(); |
| try { |
| await fixture.withEnvironment(async () => { |
| useNoBundledPlugins(); |
| const inspection = |
| ownership !== "raw" |
| ? await acquirePluginRegistryForInspection({ config: fixture.config }) |
| : undefined; |
| const registry = |
| inspection?.registry ?? loadPluginRegistryHandle({ config: fixture.config }); |
| let projectionRelease: Promise<void> | undefined; |
| if (ownership === "managed-getter") { |
| expect(inspection).toBeDefined(); |
| const managed = inspection!; |
| const provider = managed.registry.musicGenerationProviders[0]!.provider; |
| const id = provider.id; |
| Object.defineProperty(provider, "id", { |
| get() { |
| projectionRelease ??= managed.release(); |
| return id; |
| }, |
| }); |
| } |
| const result = withPluginRuntimeRegistryScope(registry, fixture.run); |
| const settled = result.then( |
| (value) => ({ value, error: undefined }), |
| (error: unknown) => ({ value: undefined, error }), |
| ); |
| try { |
| await waitForProviderStart(fixture.started.promise, settled); |
| expect(fixture.connections).toHaveLength(1); |
| if (ownership === "managed-getter") { |
| expect(projectionRelease).toBeDefined(); |
| await projectionRelease; |
| } |
| await inspection?.release(); |
| expect(fixture.connections[0]!.database.isOpen).toBe(true); |
| expect(fixture.connections[0]!.disposals).toBe(0); |
| expect(fixture.connections[0]!.reads).toEqual([42]); |
| fixture.resume.resolve(); |
| const outcome = await settled; |
| expect(outcome.error).toBeUndefined(); |
| expect(outcome.value?.tracks[0]?.buffer.toString()).toBe("native music 42"); |
| expect(outcome.value?.provider).toBe("native-music-alias"); |
| expect(fixture.connections[0]!.database.isOpen).toBe(ownership === "raw"); |
| expect(fixture.connections[0]!.disposals).toBe(ownership === "raw" ? 0 : 1); |
| expect(fixture.connections[0]!.reads).toEqual( |
| ownership === "raw" ? [42, 42] : [42, 42, 42], |
| ); |
| } finally { |
| fixture.resume.resolve(); |
| await settled; |
| await inspection?.release(); |
| } |
| }); |
| } finally { |
| fixture.cleanup(); |
| } |
| }, |
| ); |
| }); |
|
|
