@openmixer/plugin-qualify 0.14.1 → 0.15.1

package/src/whole-file.ts

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * A file written whole or not at all: the bytes go to `<path>.new` beside it, are flushed to the disk, and the name is
+ * moved over the old file, then the directory is flushed so the rename itself survives a power cut. A reader of
+ * `path`, plugin-hostd at start among them, sees the old file or the whole new one, never a half.
+ */
+import { closeSync, fsyncSync, mkdirSync, openSync, renameSync, writeSync } from "node:fs";
+import { dirname } from "node:path";
+
+/** The bytes one write call takes; a large file goes out in pieces of this size. */
+const PIECE_BYTES = 1 << 16;
+
+/** The name the new bytes are written under before the rename. */
+export const pendingPath = (path: string): string => `${path}.new`;
+
+export function writeFileWhole(path: string, content: string | Uint8Array): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const bytes = typeof content === "string" ? Buffer.from(content, "utf8") : content;
+  const pending = pendingPath(path);
+  const fd = openSync(pending, "w", 0o644);
+  try {
+    for (let at = 0; at < bytes.length; at += PIECE_BYTES) writeSync(fd, bytes, at, Math.min(PIECE_BYTES, bytes.length - at));
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  renameSync(pending, path);
+  const dir = openSync(dirname(path), "r");
+  try {
+    fsyncSync(dir);
+  } finally {
+    closeSync(dir);
+  }
+}

package/tools/_declarations.py

@@ -25,7 +25,7 @@ DESCRIPTOR_DIR_SYSTEM = "/var/lib/omx/descriptors"
 DESCRIPTOR_HASH_PREFIX = 12
 DESCRIPTOR_SCHEMA_ENV = "OMX_CONTRACT_SCHEMA"
 DESCRIPTOR_SCHEMA_INSTALLED = "/usr/share/omx-contract/omx-contract.schema.json"
-DESCRIPTOR_SCHEMA_FLOOR = ">= 3.0.0"
+DESCRIPTOR_SCHEMA_FLOOR = ">= 3.4.0"
 DESCRIPTOR_CODE_SCHEMA = "contract.file.invalid"
 DESCRIPTOR_CODE_SCHEMA_MISSING = "qualify.descriptor.schema-missing"
 DESCRIPTOR_CODE_BINARY_UNHASHED = "qualify.descriptor.binary-unhashed"

package/tools/gen-hosting-codes.mjs

@@ -51,7 +51,7 @@ export async function hostingCodesFileFrom(dir) {
 function absent() {
   return (
     `omx-clap-core's TypeScript modules were not found in any of: ${clapCoreTsDirCandidates().join(', ')}. ` +
-    'Install omx-clap-core-devel (pkg-config omx-clap-core), set OMX_CLAP_CORE_TSDIR to its tsdir, or run make -C native deps.'
+    'Install omx-clap-core (its modules in /usr/share/omx-clap-core/ts), set OMX_CLAP_CORE_TSDIR to its tsdir, or run make -C native deps.'
   );
 }
 

package/tools/mod-host-admit.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright (C) 2026 Pau Aliagas <linuxnow@gmail.com>
+// 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 { createConnection } from "node:net";
+
+const uri = process.argv[2];
+const port = 20000 + (process.pid % 20000);
+const STEP_MS = 10000;
+const INSTANCE = 0;
+const COMMANDS = [
+  ["add", `add ${uri} ${INSTANCE}`],
+  ["remove", `remove ${INSTANCE}`],
+];
+
+const host = spawn("mod-host", ["-n", "-p", String(port)], { stdio: "ignore" });
+let hostEnd; // how the host went, once it has
+host.on("exit", (code, signal) => (hostEnd = signal ?? "exit"));
+const spawnFailed = new Promise((resolve) => host.on("error", (e) => resolve(e.code)));
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function connect() {
+  for (let i = 0; i < 50; i++) {
+    if (hostEnd !== undefined) return undefined;
+    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;
+}
+
+async function main() {
+  if ((await Promise.race([spawnFailed, sleep(200).then(() => undefined)])) === "ENOENT") return { installed: false, steps: [] };
+  const sock = await connect();
+  if (sock === undefined) return { installed: true, steps: [{ cmd: "add", died: hostEnd ?? "closed" }] };
+  let buffer = "";
+  let closed = false;
+  sock.on("data", (d) => (buffer += d.toString()));
+  sock.on("close", () => (closed = true));
+  sock.on("error", () => (closed = true));
+  const steps = [];
+  for (const [cmd, line] of COMMANDS) {
+    buffer = "";
+    sock.write(`${line}\0`);
+    const until = Date.now() + STEP_MS;
+    let resp;
+    while (Date.now() < until && resp === undefined && !closed && hostEnd === undefined) {
+      const m = /resp (-?\d+)/.exec(buffer);
+      if (m !== null) resp = Number(m[1]);
+      else await sleep(20);
+    }
+    if (resp === undefined) {
+      await sleep(100); // a host that dies on the command closes the socket a moment before it is reaped
+      steps.push({ cmd, died: hostEnd ?? (closed ? "closed" : "timeout") });
+      if (hostEnd === undefined && !closed) steps[steps.length - 1] = { cmd };
+      break;
+    }
+    steps.push({ cmd, resp });
+    if (resp < 0) break;
+  }
+  sock.destroy();
+  return { installed: true, steps };
+}
+
+const result = await main();
+host.kill("SIGKILL");
+process.stdout.write(`${JSON.stringify(result)}\n`);
+process.exit(0);