@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/skills/media-use/audio/scripts/lib/heygen.test.mjs

@@ -0,0 +1,185 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  heygenAuthHeaders,
+  heygenAuthMethod,
+  heygenCredential,
+  loadEnvFromDir,
+} from "./heygen.mjs";
+
+function withCleanHeygenEnv(fn) {
+  const previousAccessToken = process.env.HEYGEN_ACCESS_TOKEN;
+  const previousApiKey = process.env.HEYGEN_API_KEY;
+  const previousHyperframesApiKey = process.env.HYPERFRAMES_API_KEY;
+  const previousConfigDir = process.env.HEYGEN_CONFIG_DIR;
+  try {
+    delete process.env.HEYGEN_ACCESS_TOKEN;
+    delete process.env.HEYGEN_API_KEY;
+    delete process.env.HYPERFRAMES_API_KEY;
+    delete process.env.HEYGEN_CONFIG_DIR;
+    return fn();
+  } finally {
+    if (previousAccessToken === undefined) delete process.env.HEYGEN_ACCESS_TOKEN;
+    else process.env.HEYGEN_ACCESS_TOKEN = previousAccessToken;
+    if (previousApiKey === undefined) delete process.env.HEYGEN_API_KEY;
+    else process.env.HEYGEN_API_KEY = previousApiKey;
+    if (previousHyperframesApiKey === undefined) delete process.env.HYPERFRAMES_API_KEY;
+    else process.env.HYPERFRAMES_API_KEY = previousHyperframesApiKey;
+    if (previousConfigDir === undefined) delete process.env.HEYGEN_CONFIG_DIR;
+    else process.env.HEYGEN_CONFIG_DIR = previousConfigDir;
+  }
+}
+
+test("heygenAuthHeaders does not tag API-key requests as CLI traffic, but still carries the media-use tool tag", () => {
+  withCleanHeygenEnv(() => {
+    process.env.HEYGEN_API_KEY = "hg_test";
+    // API-key requests use normal billing; the backend ignores the cli-source
+    // header for them, so it's not sent. The tool-attribution header IS sent on
+    // every media-use call (any auth type) so the backend can isolate media-use.
+    assert.deepEqual(heygenAuthHeaders(), {
+      "X-Api-Key": "hg_test",
+      "X-HeyGen-Client-Source": "media-use",
+    });
+  });
+});
+
+test("heygenAuthHeaders tags OAuth requests as CLI traffic and with the media-use tool tag", () => {
+  withCleanHeygenEnv(() => {
+    const dir = mkdtempSync(join(tmpdir(), "heygen-cred-"));
+    try {
+      process.env.HEYGEN_CONFIG_DIR = dir;
+      writeFileSync(
+        join(dir, "credentials"),
+        JSON.stringify({
+          oauth: {
+            access_token: "at_test",
+            expires_at: "2099-01-01T00:00:00Z",
+          },
+        }),
+      );
+      assert.deepEqual(heygenAuthHeaders(), {
+        Authorization: "Bearer at_test",
+        "X-HeyGen-Source": "cli",
+        "X-HeyGen-Client-Source": "media-use",
+      });
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+test("a host-injected HEYGEN_ACCESS_TOKEN wins over an API key and is treated as OAuth", () => {
+  withCleanHeygenEnv(() => {
+    process.env.HEYGEN_ACCESS_TOKEN = "at_host";
+    process.env.HEYGEN_API_KEY = "hg_test";
+    assert.deepEqual(heygenAuthHeaders(), {
+      Authorization: "Bearer at_host",
+      "X-HeyGen-Source": "cli",
+      "X-HeyGen-Client-Source": "media-use",
+    });
+    assert.equal(heygenAuthMethod(), "oauth");
+  });
+});
+
+test("heygenAuthMethod returns api_key for an env API key, without tagging headers", () => {
+  withCleanHeygenEnv(() => {
+    process.env.HEYGEN_API_KEY = "hg_test";
+    assert.equal(heygenAuthMethod(), "api_key");
+  });
+});
+
+test("heygenAuthMethod returns oauth for a live OAuth credential", () => {
+  withCleanHeygenEnv(() => {
+    const dir = mkdtempSync(join(tmpdir(), "heygen-cred-"));
+    try {
+      process.env.HEYGEN_CONFIG_DIR = dir;
+      writeFileSync(
+        join(dir, "credentials"),
+        JSON.stringify({
+          oauth: {
+            access_token: "at_test",
+            expires_at: "2099-01-01T00:00:00Z",
+          },
+        }),
+      );
+      assert.equal(heygenAuthMethod(), "oauth");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+test("heygenAuthMethod returns null with no credential at all", () => {
+  withCleanHeygenEnv(() => {
+    const dir = mkdtempSync(join(tmpdir(), "heygen-cred-"));
+    try {
+      process.env.HEYGEN_CONFIG_DIR = dir; // no credentials file written
+      assert.equal(heygenAuthMethod(), null);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+test("loadEnvFromDir skips a .env folder and loads the .env file above it", () => {
+  const root = mkdtempSync(join(tmpdir(), "heygen-env-"));
+  const project = join(root, "project");
+  mkdirSync(join(project, ".env"), { recursive: true });
+  writeFileSync(join(root, ".env"), "MEDIA_USE_ENV_DIR_TEST=from-parent\n");
+  try {
+    loadEnvFromDir(project);
+    assert.equal(process.env.MEDIA_USE_ENV_DIR_TEST, "from-parent");
+  } finally {
+    delete process.env.MEDIA_USE_ENV_DIR_TEST;
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("heygenAuthMethod returns null when the credentials path is a folder", () => {
+  withCleanHeygenEnv(() => {
+    const dir = mkdtempSync(join(tmpdir(), "heygen-cred-"));
+    try {
+      mkdirSync(join(dir, "credentials"));
+      process.env.HEYGEN_CONFIG_DIR = dir;
+      assert.equal(heygenAuthMethod(), null);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+test("heygenAuthMethod returns null when the credentials path is a symlink loop", () => {
+  withCleanHeygenEnv(() => {
+    const dir = mkdtempSync(join(tmpdir(), "heygen-cred-"));
+    try {
+      symlinkSync(join(dir, "credentials"), join(dir, "credentials"));
+      process.env.HEYGEN_CONFIG_DIR = dir;
+      assert.equal(heygenAuthMethod(), null);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
+test("heygenAuthHeaders says to fix an unreadable credentials path, and to log in when there is none", () => {
+  withCleanHeygenEnv(() => {
+    const dir = mkdtempSync(join(tmpdir(), "heygen-cred-"));
+    try {
+      process.env.HEYGEN_CONFIG_DIR = dir;
+      assert.throws(() => heygenAuthHeaders(), /no HeyGen credentials/);
+      mkdirSync(join(dir, "credentials"));
+      assert.equal(heygenCredential(), null);
+      assert.throws(
+        () => heygenAuthHeaders(),
+        (error) =>
+          error.message.includes(join(dir, "credentials")) &&
+          /fix or remove that path/.test(error.message),
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/vendor/hyperframes/dist/skills/media-use/audio/scripts/lib/media-record.mjs

@@ -0,0 +1,114 @@
+import { existsSync } from "node:fs";
+import { extname, join } from "node:path";
+import { AGENT_SOURCES, latestRecordFor, recordInPlace } from "../../../scripts/lib/manifest.mjs";
+import { regenerateIndex } from "../../../scripts/lib/index-gen.mjs";
+
+/**
+ * Where the engine may write `rel`: there, unless another file of this run has `taken` it or the file there is
+ * the person's (not `reusable` and not recorded as agent-made). Then the first free `name-2.ext`, with an anomaly.
+ */
+export function agentWritePath(
+  hyperframesDir,
+  rel,
+  { anomalies, taken = new Set(), reusable = () => false },
+) {
+  const free = (path) =>
+    !taken.has(path) &&
+    (!existsSync(join(hyperframesDir, path)) ||
+      reusable(path) ||
+      AGENT_SOURCES.includes(latestRecordFor(hyperframesDir, path)?.source));
+  if (free(rel)) return rel;
+  const ext = extname(rel);
+  const stem = rel.slice(0, rel.length - ext.length);
+  let n = 2;
+  while (!free(`${stem}-${n}${ext}`)) n++;
+  const path = `${stem}-${n}${ext}`;
+  const why = taken.has(rel)
+    ? "another file of this run goes there"
+    : "the file there is yours (the media manifest does not record it as made by the engine)";
+  const note = `${rel}: kept, because ${why}; writing ${path} instead (audio_meta.json has the path used)`;
+  if (!anomalies.includes(note)) anomalies.push(note);
+  return path;
+}
+
+/** Each spoken line's file, picked before lines synthesize concurrently so two never land on one free name. */
+export function voicePaths(hyperframesDir, lines, anomalies) {
+  const taken = new Set();
+  const paths = new Map();
+  for (const line of lines.filter((l) => String(l.text ?? "").trim())) {
+    const rel = agentWritePath(hyperframesDir, `assets/voice/${line.id}.wav`, { anomalies, taken });
+    taken.add(rel);
+    paths.set(String(line.id), rel);
+  }
+  return paths;
+}
+
+const SFX_SOURCES = { heygen: "search", local: "bundled" };
+
+// The files one engine run wrote, each with how it was made, for the project's media manifest.
+export function writtenAssets({ only, lines, voices, ttsProvider, bgm, bgmFields, sfx }) {
+  const textById = new Map(lines.map((line) => [String(line.id), String(line.text ?? "").trim()]));
+  const assets = [];
+  if (only.has("tts")) {
+    for (const voice of voices) {
+      assets.push({
+        path: voice.path,
+        type: "voice",
+        source: "generated",
+        intent: textById.get(voice.id),
+        duration: voice.duration_s,
+        provider: ttsProvider,
+      });
+    }
+  }
+  if (only.has("bgm") && bgm && !bgmFields.bgm_pending) {
+    assets.push({
+      path: bgm.path,
+      type: "bgm",
+      source: bgmFields.bgm_mode === "retrieve" ? "search" : "generated",
+      intent: bgm.query,
+      duration: bgm.duration_s,
+      provider: bgmFields.bgm_provider,
+    });
+  }
+  if (only.has("sfx")) {
+    for (const cue of new Map(sfx.map((entry) => [entry.file, entry])).values()) {
+      const source = SFX_SOURCES[cue.source];
+      const provider = source === "search" ? "heygen" : "bundled.sfx";
+      assets.push({
+        path: cue.file,
+        type: "sfx",
+        source,
+        intent: cue.name,
+        duration: cue.duration_s,
+        provider,
+      });
+    }
+  }
+  return assets;
+}
+
+/** Records each asset where it lies; returns one anomaly per file left unrecorded. */
+export function recordInManifest(hyperframesDir, assets) {
+  const anomalies = [];
+  for (const { path, type, source, intent, duration, provider } of assets) {
+    try {
+      recordInPlace(hyperframesDir, {
+        type,
+        path,
+        source,
+        description: intent,
+        duration,
+        provenance: { provider: provider || "local", ...(intent && { prompt: intent }) },
+      });
+    } catch (error) {
+      anomalies.push(`${path}: not recorded in the media manifest (${error.message})`);
+    }
+  }
+  try {
+    if (anomalies.length < assets.length) regenerateIndex(hyperframesDir);
+  } catch (error) {
+    anomalies.push(`.media/index.md: not refreshed (${error.message})`);
+  }
+  return anomalies;
+}

package/vendor/hyperframes/dist/skills/media-use/audio/scripts/lib/media-record.test.mjs

@@ -0,0 +1,205 @@
+import { strict as assert } from "node:assert";
+import { test } from "node:test";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { findByPrompt, readManifest } from "../../../scripts/lib/manifest.mjs";
+import { agentWritePath, recordInManifest, voicePaths, writtenAssets } from "./media-record.mjs";
+
+const noBgm = { bgm: null, bgmFields: { bgm_pending: false } };
+
+function project(t) {
+  const dir = mkdtempSync(join(tmpdir(), "mu-record-"));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  return dir;
+}
+
+test("a voice run leaves a manifest entry marked generated", (t) => {
+  const dir = project(t);
+  const assets = writtenAssets({
+    only: new Set(["tts"]),
+    lines: [{ id: "01", text: "Welcome to the launch" }],
+    voices: [{ id: "01", path: "assets/voice/01.wav", duration_s: 2.34 }],
+    ttsProvider: "kokoro",
+    sfx: [],
+    ...noBgm,
+  });
+
+  assert.deepEqual(recordInManifest(dir, assets), []);
+
+  assert.deepEqual(
+    readManifest(dir).map(({ path, type, source, description, duration, provenance }) => ({
+      path,
+      type,
+      source,
+      description,
+      duration,
+      provenance,
+    })),
+    [
+      {
+        path: "assets/voice/01.wav",
+        type: "voice",
+        source: "generated",
+        description: "Welcome to the launch",
+        duration: 2.3,
+        provenance: { provider: "kokoro", prompt: "Welcome to the launch" },
+      },
+    ],
+  );
+});
+
+const voiceLine = (intent, duration) => [
+  { path: "assets/voice/01.wav", type: "voice", source: "generated", intent, duration },
+];
+
+test("a rerun that writes the same take keeps one record, and a new length is a new take", (t) => {
+  const dir = project(t);
+
+  recordInManifest(dir, voiceLine("Hello world", 1.25));
+  recordInManifest(dir, voiceLine("Hello world", 1.25));
+  assert.equal(readManifest(dir).length, 1);
+
+  recordInManifest(dir, voiceLine("Hello world", 2));
+  assert.deepEqual(
+    readManifest(dir).map(({ duration }) => duration),
+    [1.3, 2],
+  );
+});
+
+test("a rerun with new text records the new take, and the old text no longer finds the file", (t) => {
+  const dir = project(t);
+
+  recordInManifest(dir, voiceLine("Hello world", 1.25));
+  recordInManifest(dir, voiceLine("Welcome back to the show", 3.5));
+
+  assert.deepEqual(
+    readManifest(dir).map(({ description, duration }) => [description, duration]),
+    [
+      ["Hello world", 1.3],
+      ["Welcome back to the show", 3.5],
+    ],
+  );
+  assert.equal(findByPrompt(dir, "Hello world", "voice"), null);
+  const index = readFileSync(join(dir, ".media/index.md"), "utf8");
+  assert.match(index, /Welcome back to the show/);
+  assert.doesNotMatch(index, /Hello world/);
+  assert.equal(findByPrompt(dir, "Welcome back to the show", "voice")?.path, "assets/voice/01.wav");
+});
+
+test("music and sound effects are marked by where they came from", () => {
+  const assets = writtenAssets({
+    only: new Set(["bgm", "sfx"]),
+    lines: [],
+    voices: [{ id: "01", path: "assets/voice/01.wav" }],
+    bgm: { path: "assets/bgm/track.mp3", query: "calm" },
+    bgmFields: { bgm_pending: false, bgm_mode: "retrieve" },
+    sfx: [
+      { file: "assets/sfx/whoosh.mp3", name: "whoosh", source: "local" },
+      { file: "assets/sfx/whoosh.mp3", name: "whoosh", source: "local" },
+      { file: "assets/sfx/glass.mp3", name: "glass", source: "heygen" },
+    ],
+  });
+
+  assert.deepEqual(
+    assets.map(({ path, source, provider }) => [path, source, provider]),
+    [
+      ["assets/bgm/track.mp3", "search", undefined],
+      ["assets/sfx/whoosh.mp3", "bundled", "bundled.sfx"],
+      ["assets/sfx/glass.mp3", "search", "heygen"],
+    ],
+  );
+});
+
+test("music made locally is marked generated once it is ready, not while pending", () => {
+  const written = (bgm_pending) =>
+    writtenAssets({
+      only: new Set(["bgm"]),
+      lines: [],
+      voices: [],
+      sfx: [],
+      bgm: { path: "assets/bgm/track.wav" },
+      bgmFields: { bgm_pending, bgm_mode: "detached-single" },
+    }).map(({ source }) => source);
+
+  assert.deepEqual(written(true), []);
+  assert.deepEqual(written(false), ["generated"]);
+});
+
+test("a file that cannot be recorded becomes an anomaly, not a failure", (t) => {
+  const dir = project(t);
+  writeFileSync(join(dir, ".media"), "a file where the media folder should be");
+
+  const anomalies = recordInManifest(dir, [
+    { path: "assets/voice/01.wav", type: "voice", source: "generated" },
+  ]);
+
+  assert.equal(anomalies.length, 1);
+  assert.match(anomalies[0], /^assets\/voice\/01\.wav: not recorded in the media manifest/);
+});
+
+test("the engine writes over only its own files, else the next free name", (t) => {
+  const dir = project(t);
+  mkdirSync(join(dir, "assets/sfx"), { recursive: true });
+  const names = ["mine", "made", "adopted", "twice", "twice-2", "kept", "kept-2"];
+  for (const name of names) writeFileSync(join(dir, `assets/sfx/${name}.mp3`), name);
+  for (const path of ["assets/sfx/made.mp3", "assets/sfx/kept-2.mp3"])
+    recordInManifest(dir, [{ path, type: "sfx", source: "search" }]);
+  recordInManifest(dir, [{ path: "assets/sfx/adopted.mp3", type: "sfx", source: "existing" }]);
+  const anomalies = [];
+  const at = (name, reusable) =>
+    agentWritePath(dir, `assets/sfx/${name}.mp3`, { anomalies, reusable });
+
+  assert.equal(at("new"), "assets/sfx/new.mp3");
+  assert.equal(at("made"), "assets/sfx/made.mp3");
+  assert.equal(
+    at("mine", (path) => path === "assets/sfx/mine.mp3"),
+    "assets/sfx/mine.mp3",
+  );
+  assert.deepEqual(anomalies, []);
+  assert.equal(at("mine"), "assets/sfx/mine-2.mp3");
+  assert.equal(at("adopted"), "assets/sfx/adopted-2.mp3");
+  assert.equal(at("twice"), "assets/sfx/twice-3.mp3");
+  assert.equal(at("kept"), "assets/sfx/kept-2.mp3");
+  assert.equal(anomalies.length, 4);
+  assert.match(
+    anomalies[0],
+    /^assets\/sfx\/mine\.mp3: kept, .* writing assets\/sfx\/mine-2\.mp3 instead/,
+  );
+});
+
+test("two spoken lines never share a file when one's name is taken by the person", (t) => {
+  const dir = project(t);
+  mkdirSync(join(dir, "assets/voice"), { recursive: true });
+  writeFileSync(join(dir, "assets/voice/hook.wav"), "the person's own hook");
+  const anomalies = [];
+
+  const paths = voicePaths(
+    dir,
+    [
+      { id: "hook", text: "First" },
+      { id: "hook-2", text: "Second" },
+      { id: "blank", text: " " },
+    ],
+    anomalies,
+  );
+
+  assert.deepEqual(Object.fromEntries(paths), {
+    hook: "assets/voice/hook-2.wav",
+    "hook-2": "assets/voice/hook-2-2.wav",
+  });
+  assert.equal(anomalies.length, 2);
+});
+
+test("a record never takes the id of a download still in flight", (t) => {
+  const dir = project(t);
+  mkdirSync(join(dir, ".media/audio/bgm"), { recursive: true });
+  writeFileSync(join(dir, ".media/audio/bgm/bgm_001.mp3"), "");
+
+  recordInManifest(dir, [{ path: "assets/bgm/track.wav", type: "bgm", source: "generated" }]);
+
+  assert.deepEqual(
+    readManifest(dir).map(({ id }) => id),
+    ["bgm_002"],
+  );
+});

package/vendor/hyperframes/dist/skills/media-use/audio/scripts/lib/python.mjs

@@ -0,0 +1,77 @@
+// python.mjs — resolve which Python 3 executable to spawn, per platform.
+//
+// The audio engine (tts.mjs, bgm.mjs) shells out to `python3` for ElevenLabs
+// TTS and the local Lyria/MusicGen BGM paths. `python3` is the right name on
+// macOS/Linux, but on Windows the python.org installer only creates
+// `python.exe` plus the `py` launcher — there is no `python3.exe` (only the
+// Microsoft Store build adds one). So a bare `spawn("python3", …)` ENOENTs on a
+// standard Windows Python install, silently disabling every Python-backed audio
+// feature until the user hand-creates a `python3.exe` shim (reported twice).
+//
+// Resolve once, per process: probe the platform's candidates in order and take
+// the first that actually runs. `py` is the launcher, so it needs a `-3` arg to
+// select Python 3 — hence candidates are argv PREFIXES, not bare names.
+//
+// `HYPERFRAMES_PYTHON` (the documented PEP 668 venv setup) wins over the PATH probe, matching
+// the CLI's `findPython()`; ignoring it made BGM silently disable itself (#4614).
+
+import { spawnSync } from "node:child_process";
+
+// Accept only an interpreter whose `--version` reports Python 3, as the CLI's
+// `validatePythonOverride()` does. Exit status alone would take a Python 2
+// `python` (or any executable that exits 0) that `doctor` rejects. Python 2
+// prints its version to stderr, so read both streams.
+export function defaultProbe(cmd, args) {
+  try {
+    const result = spawnSync(cmd, args, { encoding: "utf-8", timeout: 5000 });
+    return result.status === 0 && /Python 3/.test(`${result.stdout}${result.stderr}`);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Pick the argv prefix that launches Python 3 on this platform.
+ * Returns e.g. `["python3"]`, `["python"]`, or `["py", "-3"]`.
+ *
+ * Pure except for `probe` (which runs `<cmd> … --version`); `platform`, `probe`
+ * and `env` are injectable so every branch is unit-testable without spawning.
+ * If nothing probes OK, falls back to the canonical name for the platform so
+ * the eventual spawn fails loudly exactly as it did before — never worse.
+ */
+export function resolvePythonCommand(
+  platform = process.platform,
+  probe = defaultProbe,
+  env = process.env,
+) {
+  const override = env.HYPERFRAMES_PYTHON;
+  if (override && probe(override, ["--version"])) return [override];
+  const candidates =
+    platform === "win32" ? [["python3"], ["python"], ["py", "-3"]] : [["python3"], ["python"]];
+  for (const prefix of candidates) {
+    if (probe(prefix[0], [...prefix.slice(1), "--version"])) return prefix;
+  }
+  return candidates[0];
+}
+
+let cached = null;
+
+/** Cached `resolvePythonCommand()` — probing spawns, so resolve at most once. */
+export function pythonCommand() {
+  if (!cached) cached = resolvePythonCommand();
+  return cached;
+}
+
+/**
+ * Build a `{ cmd, args }` for running Python 3 with `extraArgs`, using the
+ * resolved (or supplied) prefix. Keeps the launcher's `-3` (and any future
+ * prefix args) ahead of the caller's own arguments.
+ */
+export function pythonInvocation(extraArgs, prefix = pythonCommand()) {
+  return { cmd: prefix[0], args: [...prefix.slice(1), ...extraArgs] };
+}
+
+/** Test-only: clear the cached resolution so a test can re-probe. */
+export function _resetPythonCommandCacheForTests() {
+  cached = null;
+}