@openmixer/plugin-qualify 0.18.0 → 0.18.2

package/tools/isolated-step.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+// One isolated step (plugin-qualify#249): a plugin-hostd of its own on the JACK server the environment names, the plugin
+// added alone, worker_list read, a sine through it for a window, and worker_list read again. Prints one JSON line for
+// src/qualify-isolated.ts to judge. A host that never listened says started: false: nothing was learned about the plugin.
+import { spawn, spawnSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { createConnection } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const [uri, windowMsWord] = process.argv.slice(2);
+const windowMs = Number(windowMsWord);
+const signalTool = process.env.OMX_ISOLATED_SIGNAL;
+const hostd = process.env.PLUGIN_HOSTD ?? "plugin-hostd";
+const port = 40000 + (process.pid % 20000);
+const CONNECT_TRIES = 50;
+// the sync gives each command its budget: a plugin that hangs in add ends there
+const COMMAND_MS = Number(process.env.OMX_ADMIT_STEP_MS ?? 0) || 30000;
+const INSTANCE = 0;
+const CLOCK_TICKS = 100;
+const WORKER_SPAWN = -503;
+
+const state = mkdtempSync(join(tmpdir(), "plugin-qualify-isolated-"));
+const host = spawn(hostd, ["-n", "-p", String(port)], { stdio: "ignore", detached: true, env: { ...process.env, XDG_STATE_HOME: state } });
+let ended = false;
+host.on("exit", () => (ended = true));
+host.on("error", () => (ended = true));
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function connect() {
+  for (let i = 0; i < CONNECT_TRIES && !ended; i++) {
+    const s = await new Promise((resolve) => {
+      const c = createConnection({ port, host: "127.0.0.1" }, () => resolve(c));
+      c.on("error", () => resolve(undefined));
+    });
+    if (s !== undefined) return s;
+    await sleep(100);
+  }
+  return undefined;
+}
+
+function commander(sock) {
+  let buffer = "";
+  let closed = false;
+  sock.on("data", (d) => (buffer += d.toString()));
+  sock.on("close", () => (closed = true));
+  sock.on("error", () => (closed = true));
+  return async (line) => {
+    buffer = "";
+    sock.write(`${line}\0`);
+    const until = Date.now() + COMMAND_MS;
+    while (Date.now() < until && !closed) {
+      const m = /resp (-?\d+)([^\0]*)\0?/.exec(buffer);
+      if (m !== null && buffer.includes("\0")) return { code: Number(m[1]), rest: m[2].trim() };
+      await sleep(20);
+    }
+    return undefined;
+  };
+}
+
+/** `<worker>:<pid>:<format>:<state>:<core>:<pool>:<place>:<i>,<i>,...` per worker. */
+const workersOf = (answer) =>
+  (answer?.rest ?? "").split(/\s+/).filter(Boolean).map((w) => {
+    const f = w.split(":");
+    return { pid: Number(f[1]), instances: (f[7] ?? "").split(",").filter(Boolean) };
+  });
+
+function cpuTicks(pid) {
+  try {
+    const after = readFileSync(`/proc/${String(pid)}/stat`, "utf8").replace(/^.*\) /, "").split(" ");
+    return Number(after[11]) + Number(after[12]);
+  } catch {
+    return undefined;
+  }
+}
+
+async function main() {
+  const sock = await connect();
+  if (sock === undefined) return { started: false, problem: `${hostd} did not listen` };
+  const send = commander(sock);
+  const added = await send(`add ${uri} ${String(INSTANCE)}`);
+  // WORKER_SPAWN: no worker came up to hold the plugin, which says nothing of the plugin. The next pass tries it again.
+  if (added?.code === WORKER_SPAWN) return { started: false, problem: `no worker came up: add answered ${String(WORKER_SPAWN)}` };
+  if (added === undefined || added.code < 0) return { started: true, added: false, problem: added === undefined ? "the host gave no answer to add" : `add answered ${String(added.code)}` };
+  const before = workersOf(await send("worker_list"));
+  const worker = before[0];
+  const ticksBefore = worker === undefined ? undefined : cpuTicks(worker.pid);
+  const signal = spawnSync(signalTool, [`effect_${String(INSTANCE)}`, String(windowMs)], { encoding: "utf8", timeout: windowMs + 15000, killSignal: "SIGKILL" });
+  const ticksAfter = worker === undefined ? undefined : cpuTicks(worker.pid);
+  const after = workersOf(await send("worker_list"));
+  sock.destroy();
+  const alive = after.length > 0 && after[0].pid === worker?.pid && ticksAfter !== undefined;
+  if (signal.error !== undefined || signal.status !== 0) {
+    if (signal.status === 2 && alive) return { started: false, problem: `isolated_signal: ${signal.stderr.trim()}` };
+    return { started: true, added: true, alive, workers: before.length, instancesInWorker: worker?.instances.length ?? 0, problem: signal.stderr?.trim() };
+  }
+  const heard = JSON.parse(signal.stdout);
+  return {
+    started: true,
+    added: true,
+    alive,
+    workers: before.length,
+    instancesInWorker: worker?.instances.length ?? 0,
+    latencyFrames: heard.latencyFrames,
+    xruns: heard.xruns,
+    finite: heard.finite,
+    silent: heard.silent,
+    ...(ticksBefore === undefined || ticksAfter === undefined ? {} : { cpuPercent: ((ticksAfter - ticksBefore) * 100000) / CLOCK_TICKS / windowMs }),
+  };
+}
+
+const result = await main();
+try {
+  process.kill(-host.pid, "SIGKILL");
+} catch {
+  // the host went on its own
+}
+rmSync(state, { recursive: true, force: true });
+process.stdout.write(`${JSON.stringify(result)}\n`);
+process.exit(0);

package/tools/lv2_resolve.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: GPL-3.0-or-later
+# Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+"""Which bundle lilv takes for each LV2 plugin on the search path, and its binary (plugin-qualify#199).
+
+lilv loads one world over the whole LV2_PATH; where two bundles describe one plugin URI, its version rule decides
+(the higher lv2:minorVersion, then lv2:microVersion, replaces the other). An LV2 complement writes a replacing bundle
+with the microVersion one above, so lilv, and every host built on it, loads that one. The sync keys an LV2 plugin by
+the bundle lilv takes, never by the first one a directory listing finds.
+
+    LV2_PATH=<dir>:<dir>... lv2_resolve.py
+
+prints one JSON object: {"plugins": [{"uri", "bundle", "binary"}, ...]}, `bundle` a directory, `binary` the absolute
+path of the library lilv would load (it may lie outside the bundle).
+"""
+import json
+import sys
+from urllib.parse import unquote, urlparse
+
+
+def path_of(uri):
+    """A file: URI as a path, its trailing slash dropped."""
+    return unquote(urlparse(uri).path).rstrip("/")
+
+
+def main():
+    try:
+        import lilv
+    except ImportError as e:
+        print(f"lv2_resolve: lilv's Python bindings are not installed: {e}", file=sys.stderr)
+        return 2
+    world = lilv.World()
+    world.load_all()
+    out = []
+    for plugin in world.get_all_plugins():
+        library = plugin.get_library_uri()
+        out.append({
+            "uri": str(plugin.get_uri()),
+            "bundle": path_of(str(plugin.get_bundle_uri())),
+            "binary": path_of(str(library)) if library is not None else None,
+        })
+    out.sort(key=lambda p: p["uri"])
+    json.dump({"plugins": out}, sys.stdout)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/tools/mod-host-admit.mjs

@@ -4,23 +4,41 @@
 // One mod-host admission: a fresh `mod-host -n` on its own port, then `add` and `remove` of one plugin on its
 // socket. Prints one JSON line, {installed, steps:[{cmd, resp | died}]}, for src/host-admission.ts to classify. The host
 // is always killed at the end, so the next plugin gets a fresh one.
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
 import { createConnection } from "node:net";
+import { fileURLToPath } from "node:url";
 
 const uri = process.argv[2];
 // the host to admit under: mod-host, or omx-clap-host for plugin-hostd's LV2 adapter, which answers the same protocol
 const bin = process.argv[3] ?? "mod-host";
 const port = 20000 + (process.pid % 20000);
-const STEP_MS = 10000;
+// an adapter-only pass gives the host its budget for a command, an address space and a state directory of the plugin's own
+const STEP_MS = Number(process.env.OMX_ADMIT_STEP_MS ?? 0) || 10000;
+const ADDRESS_KB = process.env.OMX_ADMIT_ADDRESS_KB;
+const STATE_DIR = process.env.OMX_ADMIT_STATE_DIR;
 const INSTANCE = 0;
+// an instrument under the adapter is played: one note, held this long, its output read at its JACK ports
+const NOTE_WINDOW_MS = 1000;
+const NOTE_ON = `note_on ${INSTANCE} 0 60 100`;
+const ADAPTER = "omx-clap-host";
 const COMMANDS = [
   ["add", `add ${uri} ${INSTANCE}`],
   ["remove", `remove ${INSTANCE}`],
 ];
 
-const host = spawn(bin, ["-n", "-p", String(port)], { stdio: "ignore" });
+const args = ["-n", "-p", String(port), ...(STATE_DIR === undefined ? [] : ["-s", STATE_DIR])];
+// in a process group of its own, so that the end below takes whatever a plugin started as well
+const host =
+  ADDRESS_KB === undefined
+    ? spawn(bin, args, { stdio: "ignore", detached: true })
+    : spawn("/bin/sh", ["-c", `command -v "$1" >/dev/null || exit 127; ulimit -v ${ADDRESS_KB} && exec "$@"`, "sh", bin, ...args], { stdio: "ignore", detached: true });
 let hostEnd; // how the host went, once it has
-host.on("exit", (code, signal) => (hostEnd = signal ?? "exit"));
+let shellNotFound = false;
+host.on("exit", (code, signal) => {
+  hostEnd = signal ?? "exit";
+  if (code === 127) shellNotFound = true;
+});
 const spawnFailed = new Promise((resolve) => host.on("error", (e) => resolve(e.code)));
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -37,8 +55,54 @@ async function connect() {
   return undefined;
 }
 
+// the LV2 class says it is an instrument; the note port and the audio input say nothing, a synth can have both, an effect
+// can have both. omx-clap-scan comes with omx-clap-host: without an answer from it this is not known to be an instrument
+function isInstrument() {
+  const r = spawnSync("omx-clap-scan", ["--fields", `lv2:${uri}`], { encoding: "utf8", timeout: STEP_MS });
+  return r.status === 0 && /^plugin\trdf:type\tlv2:InstrumentPlugin$/m.test(r.stdout);
+}
+
+// the JACK output ports of the instance, from audio_ports's reply: resp 0 [dry] in:... out:main:1:2:stereo:"out":out_1,out_2
+function outputPorts(reply) {
+  return [...reply.matchAll(/ out:[^ "]*"[^"]*":([^ ]+)/g)].flatMap((m) => m[1].split(",")).map((p) => `effect_${INSTANCE}:${p}`);
+}
+
+const PEAK_TOOL_DIRS = [fileURLToPath(new URL("../native/build/", import.meta.url)), "/usr/libexec/plugin-qualify/", "/usr/lib/plugin-qualify/"];
+const peakTool = () => process.env.OMX_JACK_PEAK || PEAK_TOOL_DIRS.map((d) => `${d}jack_peak`).find((p) => existsSync(p));
+
+// the peak on `ports` while `during` runs: { peak } in linear magnitude, or { problem } with why
+async function peakDuring(ports, during) {
+  const tool = peakTool();
+  if (tool === undefined) return { problem: "no jack_peak" };
+  const meter = spawn(tool, ports, { stdio: ["pipe", "pipe", "pipe"] });
+  let out = "";
+  let err = "";
+  const ended = new Promise((resolve) => {
+    meter.on("error", (e) => resolve(e.code ?? "error"));
+    meter.on("exit", (code) => resolve(code));
+  });
+  meter.stdout.on("data", (d) => (out += d.toString()));
+  meter.stderr.on("data", (d) => (err += d.toString()));
+  const until = Date.now() + STEP_MS;
+  while (!out.includes("ready") && Date.now() < until && meter.exitCode === null) await sleep(10);
+  if (!out.includes("ready")) {
+    meter.kill("SIGKILL");
+    await ended;
+    return { problem: err.trim() || "jack_peak did not start" };
+  }
+  await during();
+  meter.stdin.end();
+  await Promise.race([ended, sleep(STEP_MS)]);
+  meter.kill("SIGKILL");
+  try {
+    return { peak: JSON.parse(out.slice(out.indexOf("ready") + 5)).peak };
+  } catch {
+    return { problem: err.trim() || "jack_peak gave no figure" };
+  }
+}
+
 async function main() {
-  if ((await Promise.race([spawnFailed, sleep(200).then(() => undefined)])) === "ENOENT") return { installed: false, steps: [] };
+  if ((await Promise.race([spawnFailed, sleep(200).then(() => undefined)])) === "ENOENT" || shellNotFound) return { installed: false, steps: [] };
   const sock = await connect();
   // the host never listened (omx-clap-host with no JACK server): the plugin was never loaded
   if (sock === undefined) return { installed: true, started: false, steps: [] };
@@ -48,7 +112,31 @@ async function main() {
   sock.on("close", () => (closed = true));
   sock.on("error", () => (closed = true));
   const steps = [];
+  let sound;
+  // one line on the socket and its whole answer: undefined when none came in time
+  const ask = async (line) => {
+    buffer = "";
+    sock.write(`${line}\0`);
+    const until = Date.now() + STEP_MS;
+    while (Date.now() < until && !closed && hostEnd === undefined) {
+      const m = /resp -?\d+[^\0]*/.exec(buffer);
+      if (m !== null && buffer.includes("\0")) return m[0];
+      await sleep(20);
+    }
+    return undefined;
+  };
   for (const [cmd, line] of COMMANDS) {
+    // an instrument the adapter took: does a held note sound? A plugin that dies on the note dies at the remove below
+    if (cmd === "remove" && bin === ADAPTER && isInstrument()) {
+      const ports = outputPorts((await ask(`audio_ports ${INSTANCE}`)) ?? "");
+      sound =
+        ports.length === 0
+          ? { problem: "no output port" }
+          : await peakDuring(ports, async () => {
+              await ask(NOTE_ON);
+              await sleep(NOTE_WINDOW_MS);
+            });
+    }
     buffer = "";
     sock.write(`${line}\0`);
     const until = Date.now() + STEP_MS;
@@ -68,10 +156,14 @@ async function main() {
     if (resp < 0) break;
   }
   sock.destroy();
-  return { installed: true, steps };
+  return { installed: true, steps, ...(sound === undefined ? {} : { sound }) };
 }
 
 const result = await main();
-host.kill("SIGKILL");
+try {
+  process.kill(-host.pid, "SIGKILL");
+} catch {
+  // the host went on its own
+}
 process.stdout.write(`${JSON.stringify(result)}\n`);
 process.exit(0);