@aexol/spectral 0.9.231 → 0.9.240

package/dist/utils/serve-state.js

@@ -0,0 +1,563 @@
+/**
+ * On-disk rendezvous between `spectral serve` (the relay daemon) and whoever
+ * launched it — today `spectral desktop`, tomorrow any supervisor.
+ *
+ * Two files, both under `getConfigDir()` (`~/.spectral`, or `SPECTRAL_CONFIG_DIR`
+ * in tests/CI):
+ *
+ *   serve.pid        the daemon's own pid (single-instance lock)
+ *   serve-ready.json { pid, ts, version } written once the relay socket is open
+ *
+ * Why both: the pid file alone says "a process exists", not "the relay is
+ * connected" — and the web app at aexol.ai/agent subscribes to the relay the
+ * moment it loads, so opening the browser before the socket is up produces a
+ * `machine_disconnected` on every start (the exact bug the removed Electron app
+ * papered over with a 3-second `setTimeout`). `serve-ready.json` plus the
+ * `SPECTRAL_SERVE_READY` stdout marker give the launcher a real signal.
+ *
+ * A stale pid file (SIGKILL, power loss, crash) is expected: every reader
+ * sanity-checks liveness with `kill(pid, 0)` and removes dead entries, so a
+ * crashed daemon never blocks the next start.
+ *
+ * Ownership is explicit: the pid file is a *claim*, taken atomically with
+ * `O_EXCL` ({@link claimServePidFile}) and only ever rewritten or removed by
+ * whoever holds it ({@link ownsServeState}). A launcher that merely *read* the
+ * file must never treat it as its own, and a process that lost the claim must
+ * not overwrite the state of the daemon that actually owns it.
+ *
+ * All helpers are synchronous and never throw — a daemon must not fail because
+ * a bookkeeping file could not be written.
+ */
+import { fchmodSync, closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, renameSync, statSync, unlinkSync, writeFileSync, writeSync, } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { getConfigDir } from "../config.js";
+/** Line `spectral serve` prints to stdout once the relay socket is open. */
+export const SERVE_READY_MARKER = "SPECTRAL_SERVE_READY";
+/** Serve log size threshold past which `spectral desktop` rotates the log. */
+export const DEFAULT_SERVE_LOG_MAX_BYTES = 10 * 1024 * 1024;
+export function getServePidFile() {
+    return join(getConfigDir(), "serve.pid");
+}
+export function getServeReadyFile() {
+    return join(getConfigDir(), "serve-ready.json");
+}
+/**
+ * @param env env to read `SPECTRAL_SERVE_LOG_PATH` from. Defaults to
+ *   `process.env`, but a caller that holds a custom env (the desktop spawn
+ *   plan) must pass it — otherwise the wrapper watches one file while the
+ *   daemon logs into another.
+ */
+export function getServeLogFile(env = process.env) {
+    const override = env.SPECTRAL_SERVE_LOG_PATH?.trim();
+    if (override)
+        return override;
+    // An empty/whitespace override means "not set", not "log to an empty path".
+    return join(getConfigDir(), "serve.log");
+}
+/**
+ * Is `pid` a live process? Uses signal 0, which performs error checking
+ * without delivering a signal. `EPERM` counts as alive — the process exists,
+ * it just belongs to somebody else.
+ */
+export function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+/** Synchronous sleep that works on the main thread and in workers. */
+function sleepSync(ms) {
+    try {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    }
+    catch {
+        // no SharedArrayBuffer support — fall through, retry immediately
+    }
+}
+/** Parent pid on POSIX (`ps -o ppid=`); null when it cannot be determined. */
+function getParentPid(pid) {
+    if (process.platform === "win32")
+        return null;
+    // A single `ps` probe is not trustworthy under load: test runners and the
+    // spawner itself fork heavily, so ps can transiently time out or fail to
+    // spawn (EAGAIN). `isDescendantOf` reads null as "benefit of the doubt",
+    // which would misclassify a live foreign process as our daemon — so retry
+    // before concluding the genealogy is unreadable.
+    for (let attempt = 0; attempt < 3; attempt++) {
+        if (attempt > 0)
+            sleepSync(50);
+        try {
+            const res = spawnSync("ps", ["-o", "ppid=", "-p", String(pid)], {
+                encoding: "utf8",
+                timeout: 1_000,
+            });
+            if (res.status !== 0)
+                continue;
+            const ppid = Number.parseInt(res.stdout.trim(), 10);
+            if (Number.isInteger(ppid) && ppid > 0)
+                return ppid;
+        }
+        catch {
+            // transient spawn failure (EAGAIN) — retry
+        }
+    }
+    return null;
+}
+/**
+ * Walk the parent chain of `pid` and classify it against `ancestors`.
+ * Strict: an unreadable chain answers `unknown` instead of guessing.
+ */
+function descendantOf(pid, ancestors, maxDepth = 8) {
+    if (ancestors.includes(pid))
+        return "ours";
+    let current = pid;
+    for (let depth = 0; depth < maxDepth; depth++) {
+        const parent = getParentPid(current);
+        if (parent === null)
+            return "unknown";
+        if (ancestors.includes(parent))
+            return "ours";
+        if (parent <= 1 || parent === current)
+            return "not-ours";
+        current = parent;
+    }
+    return "not-ours";
+}
+/**
+ * Is `pid` a descendant of `ancestor`? Used to confirm that the pid file handed
+ * over after a spawn really belongs to the process we launched: under `tsx` the
+ * CLI re-execs, so the daemon is the *child* of the spawned pid.
+ *
+ * Best-effort: when parentage cannot be read (Windows, no `ps`, process gone)
+ * it answers true, i.e. "unknown" is treated as ours — a launcher must never
+ * block a legitimate start over an unverifiable genealogy. Callers that must
+ * keep "ours" apart from "unreadable" (see {@link confirmServePidChild}) use the
+ * strict tri-state verdict instead.
+ */
+export function isDescendantOf(pid, ancestor, maxDepth = 8) {
+    return descendantOf(pid, [ancestor], maxDepth) !== "not-ours";
+}
+function removeFile(file) {
+    try {
+        unlinkSync(file);
+    }
+    catch {
+        // missing or unremovable — nothing to do
+    }
+}
+function writeTextFile(file, text) {
+    // tmp + rename so a concurrent reader never sees a half-written file.
+    const tmp = `${file}.tmp-${process.pid}`;
+    try {
+        mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+        writeFileSync(tmp, text, { encoding: "utf8", mode: 0o600 });
+        renameSync(tmp, file);
+    }
+    catch {
+        // Bookkeeping only — never take the daemon down over it. But do not leak
+        // the scratch file: a stray `serve.pid.tmp-*` is pure clutter in a config
+        // dir that supervisors glob.
+        removeFile(tmp);
+    }
+}
+/** Write the pid file for the current (or given) daemon process. */
+export function writeServePid(pid = process.pid) {
+    writeTextFile(getServePidFile(), `${pid}\n`);
+}
+/**
+ * Read a pid file WITHOUT a liveness check. Returns null when the file is
+ * missing or is not a plain pid. The whole payload must be digits: `parseInt`
+ * turns `"12abc"` into 12, and a launcher would then signal a process nobody
+ * claimed.
+ *
+ * @param file defaults to {@link getServePidFile}; tests and alternative
+ *   layouts may point elsewhere.
+ */
+export function readServePidFile(file = getServePidFile()) {
+    let raw;
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch {
+        return null;
+    }
+    if (!/^\d+\s*$/.test(raw))
+        return null;
+    const pid = Number.parseInt(raw.trim(), 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+/**
+ * Read the pid file WITH a liveness check. A stale entry (process gone) is
+ * deleted and reported as "not running".
+ */
+export function getLiveServePid() {
+    const pid = readServePidFile();
+    if (pid === null)
+        return null;
+    if (isProcessAlive(pid))
+        return pid;
+    removeFile(getServePidFile());
+    removeFile(getServeReadyFile());
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Ownership — who may write or clear the rendezvous files
+// ---------------------------------------------------------------------------
+/**
+ * Does `pid` hold the pid-file claim? Every cleanup and every ready-signal
+ * write is gated on this, so a second daemon (or a wrapper that merely read
+ * the file) can never delete or overwrite the state of the process that owns
+ * it.
+ */
+export function ownsServeState(pid = process.pid) {
+    return readServePidFile() === pid;
+}
+/**
+ * Atomically claim `serve.pid` BEFORE spawning anything.
+ *
+ * The naive version — read the file, ask "is it alive?", then spawn — races two
+ * concurrent `spectral desktop` invocations into starting two daemons, because
+ * both see "not running" before either writes. `open(O_EXCL)` folds the test
+ * and the claim into one syscall: exactly one winner, everyone else gets
+ * `busy`.
+ *
+ * The winner writes its *own* pid as a placeholder — a live pid, so a racer
+ * that arrives microseconds later also sees `busy` — and hands it over with
+ * {@link confirmServePidChild} once the spawn succeeded.
+ */
+export function claimServePidFile(placeholderPid = process.pid) {
+    const file = getServePidFile();
+    try {
+        mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+    }
+    catch {
+        // already there / read-only: openSync below reports the real failure
+    }
+    for (let attempt = 0; attempt < 4; attempt++) {
+        let fd;
+        try {
+            fd = openSync(file, "wx", 0o600);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== "EEXIST") {
+                return { status: "failed", error: `${code ?? "error"}: ${err.message}` };
+            }
+            const holder = readServePidFile();
+            if (holder !== null && isProcessAlive(holder))
+                return { status: "busy", pid: holder };
+            // Stale (crash / SIGKILL) or garbage: prune, then race the next O_EXCL.
+            removeFile(file);
+            removeFile(getServeReadyFile());
+            continue;
+        }
+        try {
+            try {
+                // The mode argument of open(2) is masked by the umask; chmod on the
+                // fresh fd is what actually guarantees 0600 for a file holding a pid
+                // other processes will be signalled from.
+                fchmodSync(fd, 0o600);
+            }
+            catch {
+                // best-effort on filesystems without POSIX modes
+            }
+            writeSync(fd, `${placeholderPid}\n`);
+            return { status: "claimed", placeholderPid };
+        }
+        catch (err) {
+            // Leave an empty file behind rather than unlinking it: it reads as
+            // "no holder" (see readServePidFile) and the next reader prunes it, while
+            // unlinking could delete a claim another process took in the meantime.
+            return { status: "failed", error: err.message };
+        }
+        finally {
+            try {
+                closeSync(fd);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    return { status: "failed", error: "could not claim serve.pid (contended)" };
+}
+/**
+ * After a successful spawn, confirm `serve.pid` records the daemon we launched.
+ *
+ * - `child`   — it holds the spawned pid (the normal standalone/node case).
+ * - `daemon`  — the daemon already rewrote it with its own pid, which happens
+ *   when the CLI re-execs (`tsx` in dev). Accepted only when that pid is
+ *   provably our descendant.
+ * - `foreign` — a live, unrelated process owns it: the caller must warn and
+ *   stop touching the state instead of hijacking it.
+ * - `unknown` — the hand-off write did not land (read-only dir), or a live pid
+ *   this command did not spawn could not be verified as ours (unreadable
+ *   parentage); the caller must warn (unverified holder) but must never signal
+ *   it — readiness still works via the log marker and the ready file.
+ */
+export function confirmServePidChild(childPid, placeholderPid = process.pid, opts = {}) {
+    const current = readServePidFile();
+    if (current === childPid)
+        return { status: "child", pid: current };
+    if (current !== null && current !== placeholderPid && isProcessAlive(current)) {
+        const verdict = opts.genealogy?.(current, [childPid, placeholderPid]) ??
+            descendantOf(current, [childPid, placeholderPid]);
+        if (verdict === "ours") {
+            return { status: "daemon", pid: current };
+        }
+        if (verdict === "not-ours")
+            return { status: "foreign", pid: current };
+        // A live pid we cannot prove is ours must never read as "daemon": the
+        // caller would treat a foreign process's state as its own (and `desktop
+        // start` would signal it when the readiness wait fails).
+        return { status: "unknown", pid: current };
+    }
+    // Still our placeholder (or nothing, or a dead pid): hand ownership over.
+    writeServePid(childPid);
+    const after = readServePidFile();
+    return after === childPid
+        ? { status: "child", pid: after }
+        : { status: "unknown", pid: after };
+}
+/**
+ * Drop a claim taken by {@link claimServePidFile} when the start failed. Only
+ * removes the files while they still record the placeholder or the child we
+ * launched — never a foreign daemon's state.
+ */
+export function releaseServePidClaim(placeholderPid = process.pid, childPid) {
+    const current = readServePidFile();
+    if (current === null || current === placeholderPid || current === childPid) {
+        clearServeState();
+    }
+}
+/** Write the readiness marker next to the pid file. */
+export function writeServeReady(version, pid = process.pid) {
+    const info = { pid, ts: Date.now(), version };
+    writeTextFile(getServeReadyFile(), `${JSON.stringify(info, null, 2)}\n`);
+    return info;
+}
+/** Read `serve-ready.json`, or null when missing/corrupt. */
+export function readServeReadyFile(file = getServeReadyFile()) {
+    let raw;
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.pid !== "number" ||
+            !Number.isInteger(parsed.pid) ||
+            parsed.pid <= 0 ||
+            typeof parsed.ts !== "number" ||
+            typeof parsed.version !== "string") {
+            return null;
+        }
+        return { pid: parsed.pid, ts: parsed.ts, version: parsed.version };
+    }
+    catch {
+        return null;
+    }
+}
+/** Remove both the pid file and the ready file. Idempotent. */
+export function clearServeState() {
+    removeFile(getServePidFile());
+    removeFile(getServeReadyFile());
+}
+/** Current size of a file, 0 when it does not exist yet. */
+export function fileSizeOf(file) {
+    try {
+        return statSync(file).size;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Truncate a daemon log that outgrew {@link DEFAULT_SERVE_LOG_MAX_BYTES} by
+ * moving it aside as `<file>.old` (one generation kept — enough to debug the
+ * previous start, without an unbounded log growing forever).
+ *
+ * Must run BEFORE the new daemon is spawned and before the caller snapshots the
+ * log offset: after a rotate the fresh log starts at byte 0.
+ *
+ * @returns true when a rotation happened.
+ */
+export function rotateServeLogFile(file = getServeLogFile(), maxBytes = DEFAULT_SERVE_LOG_MAX_BYTES) {
+    try {
+        if (statSync(file).size <= maxBytes)
+            return false;
+    }
+    catch {
+        return false; // no log yet
+    }
+    try {
+        removeFile(`${file}.old`);
+        renameSync(file, `${file}.old`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Append-mode read: return the bytes written to `file` since `offset` and the
+ * new offset. The desktop launcher snapshots the log size before spawning so
+ * the `SPECTRAL_SERVE_READY` marker of a *previous* run can never be mistaken
+ * for the current one.
+ *
+ * The returned offset is always the offset to read from next time — including
+ * when there is nothing new, and when the file shrank under us (a rotation).
+ * A caller that only advanced on new text would stay pinned past end-of-file
+ * and never see the next marker.
+ */
+export function readFromOffset(file, offset) {
+    let fd;
+    try {
+        fd = openSync(file, "r");
+        const size = fstatSync(fd).size;
+        if (size <= offset)
+            return { text: "", offset: Math.min(offset, size) };
+        const buffer = Buffer.alloc(size - offset);
+        const bytesRead = readSync(fd, buffer, 0, buffer.length, offset);
+        return { text: buffer.subarray(0, bytesRead).toString("utf8"), offset: offset + bytesRead };
+    }
+    catch {
+        return { text: "", offset };
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+}
+const DEFAULT_READY_TIMEOUT_MS = 15_000;
+const DEFAULT_READY_INTERVAL_MS = 100;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Wait for the daemon to announce readiness, by either signal:
+ *   - `SPECTRAL_SERVE_READY` appearing in the serve log after `logOffset`, or
+ *   - a live `serve-ready.json`.
+ *
+ * A signal only counts when it belongs to THIS launch:
+ *   - the pid it reports is the spawned pid, or the pid `serve.pid` currently
+ *     records (the daemon's own pid once it re-exec'd), and
+ *   - its timestamp is not older than `sinceMs`, and
+ *   - that pid is alive.
+ *
+ * The log marker carries no pid of its own, so whenever a ready file exists it
+ * must pass the same check — a marker can never be trusted on its own while the
+ * ready file proves the signal came from a foreign or stale daemon.
+ *
+ * Gives up early when the child dies (registration/auth/sqlite failures) so the
+ * user sees the real error instead of waiting out the timeout, and always
+ * returns (never throws) with the tail of the log for diagnostics.
+ */
+export async function waitForServeReady(opts) {
+    const logFile = opts.logFile ?? getServeLogFile();
+    const readyFile = opts.readyFile ?? getServeReadyFile();
+    const pidFile = opts.pidFile ?? getServePidFile();
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
+    const intervalMs = opts.intervalMs ?? DEFAULT_READY_INTERVAL_MS;
+    const alive = opts.alive ?? isProcessAlive;
+    const sinceMs = opts.sinceMs ?? 0;
+    const start = Date.now();
+    const deadline = start + timeoutMs;
+    let logOffset = opts.logOffset ?? 0;
+    let logTail = "";
+    const grabLog = () => {
+        const chunk = readFromOffset(logFile, logOffset);
+        // Advance unconditionally, even when nothing new was appended.
+        logOffset = chunk.offset;
+        if (chunk.text) {
+            logTail = (logTail + chunk.text).slice(-2000);
+        }
+    };
+    /**
+     * Pids a ready signal may legitimately report. The spawned pid always
+     * qualifies; so does whatever the pid file currently records, because the
+     * daemon writes its own pid there before announcing readiness — that is what
+     * keeps a re-exec launch (tsx in dev) valid.
+     */
+    const acceptedPids = () => {
+        const pids = new Set(opts.expectedPids ?? []);
+        pids.add(opts.pid);
+        const holder = readServePidFile(pidFile);
+        if (holder !== null && (holder === opts.pid || alive(holder)))
+            pids.add(holder);
+        return pids;
+    };
+    /**
+     * Ownership of a ready signal: the reported pid must be one of ours and the
+     * signal must not predate this launch. `requireAlive` is what distinguishes
+     * the two uses:
+     *   - the ready *file* is the answer to "is my agent up right now" → liveness
+     *     required;
+     *   - corroborating a *marker* only has to prove the marker is ours — the
+     *     writer's liveness is already covered by the child check below, and a
+     *     daemon that started, announced and died between two polls must still
+     *     be recognised as the one we launched.
+     */
+    const isOurSignal = (info) => info !== null && info.ts >= sinceMs && acceptedPids().has(info.pid);
+    const isOurLiveSignal = (info) => isOurSignal(info) && alive(info.pid);
+    for (;;) {
+        // The ready file is the authoritative signal (it carries pid + version),
+        // and it survives a log-rotation, so check it first.
+        if (existsSync(readyFile)) {
+            const info = readServeReadyFile(readyFile);
+            if (isOurLiveSignal(info)) {
+                return {
+                    ok: true,
+                    reason: "ready-file",
+                    waitedMs: Date.now() - start,
+                    info,
+                    logTail,
+                };
+            }
+        }
+        grabLog();
+        if (logTail.includes(SERVE_READY_MARKER)) {
+            const info = readServeReadyFile(readyFile);
+            // No ready file → the marker stands alone (the daemon could not write
+            // bookkeeping). With one present, it has to corroborate the marker.
+            if (!info || isOurSignal(info)) {
+                return {
+                    ok: true,
+                    reason: "marker",
+                    waitedMs: Date.now() - start,
+                    info: info ?? undefined,
+                    logTail,
+                };
+            }
+        }
+        // Fast-fail on a dead child: registration/auth/sqlite errors exit
+        // immediately, and the user should see the log tail instead of waiting out
+        // the timeout. Skipped for re-exec launches, where this pid is the wrapper.
+        if (!opts.expectReExec && !alive(opts.pid)) {
+            return {
+                ok: false,
+                reason: "process-exited",
+                waitedMs: Date.now() - start,
+                logTail,
+            };
+        }
+        if (Date.now() >= deadline) {
+            return { ok: false, reason: "timeout", waitedMs: Date.now() - start, logTail };
+        }
+        await sleep(intervalMs);
+    }
+}

package/dist/utils/standalone.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Is spectral running as a self-contained compiled binary (Bun `--compile`)
+ * rather than as a script under `node`?
+ *
+ * Two signals, either sufficient:
+ *   - the Bun global with embedded files (the standalone build embeds data),
+ *   - `process.execPath` naming something that is not a JS runtime — i.e. the
+ *     `spectral` binary itself is the executable.
+ *
+ * Used by `spectral update` (only a standalone binary can self-update) and by
+ * `spectral desktop` (to decide what to spawn for a detached `serve`).
+ */
+export declare function isStandaloneBinary(): boolean;
+//# sourceMappingURL=standalone.d.ts.map

package/dist/utils/standalone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standalone.d.ts","sourceRoot":"","sources":["../../src/utils/standalone.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAS5C"}

package/dist/utils/standalone.js

@@ -0,0 +1,23 @@
+import { basename } from "node:path";
+/**
+ * Is spectral running as a self-contained compiled binary (Bun `--compile`)
+ * rather than as a script under `node`?
+ *
+ * Two signals, either sufficient:
+ *   - the Bun global with embedded files (the standalone build embeds data),
+ *   - `process.execPath` naming something that is not a JS runtime — i.e. the
+ *     `spectral` binary itself is the executable.
+ *
+ * Used by `spectral update` (only a standalone binary can self-update) and by
+ * `spectral desktop` (to decide what to spawn for a detached `serve`).
+ */
+export function isStandaloneBinary() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const Bun = globalThis.Bun;
+    if (Bun && typeof Bun === "object" && "embeddedFiles" in Bun) {
+        return true;
+    }
+    const execName = basename(process.execPath).replace(/\.exe$/i, "");
+    const isRuntime = execName === "node" || execName === "bun";
+    return !isRuntime;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aexol/spectral",
-  "version": "0.9.231",
+  "version": "0.9.240",
   "description": "AI coding agent for Aexol with relay-based browser access.",
   "type": "module",
   "private": false,
@@ -16,6 +16,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./sdk": {
+      "types": "./dist/sdk-public.d.ts",
+      "import": "./dist/sdk-public.js",
+      "default": "./dist/sdk-public.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -31,12 +36,11 @@
     "dev": "tsx src/cli.ts",
     "test": "vitest run",
     "test:watch": "vitest",
+    "generate-video-models": "tsx scripts/generate-video-models.ts",
     "benchmark:cache": "tsx scripts/benchmark-cache.ts",
     "prepublishOnly": "npm run build && npm test",
     "build:standalone": "bash scripts/build-standalone.sh",
     "build:standalone:all": "bash scripts/build-standalone.sh --all",
-    "build:electron": "bash scripts/build-electron.sh",
-    "build:electron:all": "bash scripts/build-electron.sh --all",
     "postinstall": "node scripts/postinstall.mjs"
   },
   "overrides": {