hyperframes 0.8.79 → 0.8.80

package/dist/skills/media-use/scripts/lib/config-lock.mjs

@@ -0,0 +1,45 @@
+// The one lock on ~/.hyperframes/config.json, for the CLI, its auto-update step and media-use. The auto-update step
+// embeds this function's source, so it must use only its arguments and globals.
+export function withFileLock(lockPath, fs, task) {
+  const token = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const started = Date.now();
+  for (;;) {
+    let fd;
+    try {
+      fd = fs.openSync(lockPath, "wx");
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      // Never taken over: a lock older than any hold was left by a process that stopped, and a person removes it.
+      let leftover = false;
+      try {
+        leftover = Date.now() - fs.statSync(lockPath).mtimeMs > 5000;
+      } catch {}
+      if (leftover || Date.now() - started > 10000)
+        throw Object.assign(
+          new Error(
+            `Settings are locked by another hyperframes process. If none is running, delete ${lockPath}`,
+          ),
+          { code: "HF_SETTINGS_LOCKED" },
+        );
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+      continue;
+    }
+    try {
+      fs.writeSync(fd, token);
+    } catch (error) {
+      fs.rmSync(lockPath, { force: true });
+      throw error;
+    } finally {
+      fs.closeSync(fd);
+    }
+    break;
+  }
+  try {
+    return task();
+  } finally {
+    // No code removes another's lock, so release needs no check (only a person deleting a live one defeats it).
+    try {
+      fs.rmSync(lockPath);
+    } catch {}
+  }
+}

package/dist/skills/media-use/scripts/lib/config-lock.test.mjs

@@ -0,0 +1,79 @@
+import { strict as assert } from "node:assert";
+import { spawn } from "node:child_process";
+import { test } from "node:test";
+import * as fs from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { withFileLock } from "./config-lock.mjs";
+
+function lockIn() {
+  const dir = fs.mkdtempSync(join(tmpdir(), "hf-config-lock-"));
+  return {
+    lock: join(dir, "config.json.lock"),
+    cleanup: () => fs.rmSync(dir, { recursive: true }),
+  };
+}
+
+test("returns the task's result even when the lock cannot be released", () => {
+  const { lock, cleanup } = lockIn();
+  try {
+    const refusing = {
+      ...fs,
+      rmSync(path, options) {
+        if (path === lock) throw Object.assign(new Error("EPERM"), { code: "EPERM" });
+        return fs.rmSync(path, options);
+      },
+    };
+    assert.equal(
+      withFileLock(lock, refusing, () => "saved"),
+      "saved",
+    );
+  } finally {
+    cleanup();
+  }
+});
+
+test("refuses a lock left by a process that stopped, names it, and never removes it", () => {
+  const { lock, cleanup } = lockIn();
+  try {
+    fs.writeFileSync(lock, "dead");
+    const past = new Date(Date.now() - 60_000);
+    fs.utimesSync(lock, past, past);
+    const started = Date.now();
+    let ran = false;
+
+    assert.throws(
+      () => withFileLock(lock, fs, () => (ran = true)),
+      (error) => error.code === "HF_SETTINGS_LOCKED" && error.message.includes(lock),
+    );
+    assert.ok(Date.now() - started < 1000);
+    assert.equal(ran, false);
+    assert.equal(fs.readFileSync(lock, "utf8"), "dead");
+  } finally {
+    cleanup();
+  }
+});
+
+test("waits for a process that holds the lock, then takes it", async () => {
+  const { lock, cleanup } = lockIn();
+  try {
+    const script = `
+      const fs = require("fs");
+      const lock = process.argv[1];
+      fs.writeFileSync(lock, "other", { flag: "wx" });
+      process.stdout.write("locked\\n");
+      setTimeout(() => {
+        fs.writeFileSync(lock + ".released", String(Date.now()));
+        fs.rmSync(lock);
+      }, 300);`;
+    const other = spawn(process.execPath, ["-e", script, lock]);
+    await new Promise((ready) => other.stdout.once("data", ready));
+
+    const ranAt = withFileLock(lock, fs, () => Date.now());
+
+    assert.ok(ranAt >= Number(fs.readFileSync(`${lock}.released`, "utf8")));
+    await new Promise((exited) => other.once("exit", exited));
+  } finally {
+    cleanup();
+  }
+});

package/dist/skills/media-use/scripts/lib/telemetry.mjs

@@ -2,9 +2,11 @@
 // never carry intent text, file names, or paths.
 
 import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import * as fs from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
+import { withFileLock } from "./config-lock.mjs";
 import { globalMediaDir } from "./media-home.mjs";
 
 const POSTHOG_API_KEY = "phc_zjjbX0PnWxERXrMHhkEJWj9A9BhGVLRReICgsfTMmpx";
@@ -62,10 +64,24 @@ function readSharedConfig() {
   return {};
 }
 
-function writeSharedConfig(config) {
-  const dir = join(homedir(), ".hyperframes");
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2) + "\n");
+// Best effort: skipped when the lock cannot be taken or the file cannot be read, never written unlocked.
+function updateSharedConfig(patch) {
+  const file = sharedConfigPath();
+  mkdirSync(dirname(file), { recursive: true });
+  try {
+    withFileLock(`${file}.lock`, fs, () => {
+      let config = {};
+      try {
+        config = JSON.parse(readFileSync(file, "utf8"));
+      } catch (error) {
+        if (error.code !== "ENOENT") return;
+      }
+      if (!config || typeof config !== "object" || Array.isArray(config)) return;
+      const tmp = `${file}.${process.pid}.tmp`;
+      writeFileSync(tmp, JSON.stringify({ ...config, ...patch }, null, 2) + "\n", { mode: 0o600 });
+      renameSync(tmp, file);
+    });
+  } catch {}
 }
 
 // Adopt a pre-existing media-use-only id (~/.media/anon-id from before this
@@ -93,7 +109,7 @@ function anonymousId() {
       return config.anonymousId.trim();
     }
     const id = legacyMediaAnonId() || randomUUID();
-    writeSharedConfig({ ...config, anonymousId: id });
+    updateSharedConfig({ anonymousId: id });
     return id;
   } catch {
     return "anon"; // best-effort; a shared bucket is fine if the fs is read-only
@@ -133,7 +149,7 @@ function showTelemetryNotice() {
         "If you sign in to HeyGen, usage links to your account email or username. Opt out with HYPERFRAMES_NO_TELEMETRY=1 or DO_NOT_TRACK=1.",
       ].join("\n"),
     );
-    writeSharedConfig({ ...config, telemetryNoticeShown: true });
+    updateSharedConfig({ telemetryNoticeShown: true });
   } catch {
     // notice is best-effort; never surface into the command
   }

package/dist/skills/media-use/scripts/lib/telemetry.test.mjs

@@ -1,4 +1,5 @@
 import { strict as assert } from "node:assert";
+import { spawn } from "node:child_process";
 import { test } from "node:test";
 import {
   existsSync,
@@ -372,3 +373,65 @@ test("read-only telemetry state degrades without throwing", async () => {
     __resetTelemetryForTest();
   }
 });
+
+async function trackQuietly(home) {
+  const originalFetch = globalThis.fetch;
+  const originalError = console.error;
+  globalThis.fetch = async () => ({ ok: true });
+  console.error = () => {};
+  try {
+    withoutTelemetryOptOut();
+    await track("media_use_resolve", { type: "bgm" });
+    return readFileSync(join(home, ".hyperframes/config.json"), "utf8");
+  } finally {
+    globalThis.fetch = originalFetch;
+    console.error = originalError;
+  }
+}
+
+test("waits for another process's locked settings write, then keeps the no it saved", async () => {
+  const savedEnv = { ...process.env };
+  const { root, home } = sandbox();
+  const dir = join(home, ".hyperframes");
+  mkdirSync(dir, { recursive: true });
+  const holder = spawn(process.execPath, [
+    "-e",
+    `const fs = require("fs");
+      const dir = process.argv[1];
+      fs.writeFileSync(dir + "/config.json.lock", "", { flag: "wx" });
+      process.stdout.write("locked\\n");
+      setTimeout(() => {
+        fs.writeFileSync(dir + "/other.tmp", JSON.stringify({ localEmbeddingEnabled: false }));
+        fs.renameSync(dir + "/other.tmp", dir + "/config.json");
+        fs.rmSync(dir + "/config.json.lock");
+      }, 1000);`,
+    dir,
+  ]);
+  const exited = new Promise((done) => holder.on("exit", done));
+  try {
+    await new Promise((locked) => holder.stdout.once("data", locked));
+    const saved = JSON.parse(await trackQuietly(home));
+    await exited;
+    assert.equal(saved.localEmbeddingEnabled, false);
+    assert.equal(saved.telemetryNoticeShown, true);
+    assert.equal(typeof saved.anonymousId, "string");
+  } finally {
+    restoreEnv(savedEnv);
+    rmSync(root, { recursive: true, force: true });
+    __resetTelemetryForTest();
+  }
+});
+
+test("leaves a settings file it cannot read untouched", async () => {
+  const savedEnv = { ...process.env };
+  const { root, home } = sandbox();
+  mkdirSync(join(home, ".hyperframes"), { recursive: true });
+  writeFileSync(join(home, ".hyperframes/config.json"), "{not json");
+  try {
+    assert.equal(await trackQuietly(home), "{not json");
+  } finally {
+    restoreEnv(savedEnv);
+    rmSync(root, { recursive: true, force: true });
+    __resetTelemetryForTest();
+  }
+});

package/dist/skills/registry/localSemantic.js

@@ -50,30 +50,10 @@ var CACHE_DIR = join(homedir(), ".cache", "hyperframes", "optional");
 function optionalPackageDir(name, cacheDir = CACHE_DIR) {
   return join(cacheDir, `${name.replace("/", "__")}@${OPTIONAL_PACKAGES[name]}`);
 }
-async function loadOptionalPackage(name, feature, deps = defaultDeps) {
-  const beside = deps.loadBesideCli(name);
-  if (beside !== null) return beside;
-  const dir = optionalPackageDir(name, deps.cacheDir);
-  const installed = deps.loadInstalled(dir, name);
-  if (installed !== null) return installed;
-  const version = OPTIONAL_PACKAGES[name];
-  deps.log(`installing ${name} for ${feature}, once`);
-  try {
-    await deps.install(dir, name, version);
-  } catch (err) {
-    const output = err.message.trim();
-    const advice = NETWORK_FAILURE.test(output) ? "Check your network connection, then retry" : "Retry";
-    throw new Error(
-      `${feature} needs ${name}, and installing it failed (${output.split("\n")[0]}). ${advice}, or install it yourself: npm install ${name}@${version} --prefix "${dir}"`
-    );
-  }
-  const loaded = deps.loadInstalled(dir, name);
-  if (loaded === null) {
-    throw new Error(`${name}@${version} installed into ${dir} but could not be loaded.`);
-  }
-  return loaded;
+function loadInstalledOptionalPackage(name, deps = defaultDeps) {
+  const found = deps.loadBesideCli(name) ?? deps.loadInstalled(optionalPackageDir(name, deps.cacheDir), name);
+  return found;
 }
-var NETWORK_FAILURE = /ENOTFOUND|ETIMEDOUT|EAI_AGAIN|ECONNRESET|ECONNREFUSED|network/i;
 function manifestPath(dir, name) {
   return join(dir, "node_modules", name, "package.json");
 }
@@ -187,6 +167,7 @@ import { Transform } from "stream";
 import { pipeline } from "stream/promises";
 
 // src/telemetry/config.ts
+import * as fs from "fs";
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
@@ -333,9 +314,9 @@ function isChinese(code) {
 
 // src/registry/localEmbedder.ts
 var MAX_TOKENS = 512;
-var FEATURE = "on-device search";
 async function loadLocalEmbedder() {
-  const ort = await loadOptionalPackage("onnxruntime-node", FEATURE);
+  const ort = loadInstalledOptionalPackage("onnxruntime-node");
+  if (ort === null) throw new Error("the on-device runtime is not installed yet");
   const config = configFromTokenizerJson(readFileSync4(localTokenizerPath(), "utf-8"));
   const session = await ort.InferenceSession.create(localModelPath());
   return {