overlay-factory-worker 0.1.0

package/worker/service.mjs

@@ -0,0 +1,404 @@
+// Background-service install/uninstall for the Overlay Factory worker.
+//
+// Modelled on goosetools-worker's service.js so all four workers behave the
+// same way: the token lands in ~/.goosetools/env (shared — one connected
+// computer, one token), a stable copy of this package is installed under
+// ~/.goosetools/overlay-app, and a launchd LaunchAgent runs it whenever the
+// machine is on.
+//
+// Two deliberate differences from the other workers:
+//
+//   1. macOS only. The composite pass encodes with hevc_videotoolbox, which
+//      is an Apple framework — there is no Windows path to fall back to yet.
+//   2. `uninstall` does NOT remove ~/.goosetools. The carousel worker can:
+//      everything it keeps there is re-derivable from the server. This one
+//      keeps the puzzle library, the learned looks, and the used-card record
+//      in ~/.goosetools/overlay, and none of that exists anywhere else.
+
+import { execSync } from "node:child_process";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export const GOOSE_DIR = join(homedir(), ".goosetools");
+const ENV_FILE = join(GOOSE_DIR, "env");
+const APP_PREFIX = join(GOOSE_DIR, "overlay-app");
+const STATE_DIR = join(GOOSE_DIR, "overlay");
+const PKG = "overlay-factory-worker";
+const INSTALLED_CLI = join(APP_PREFIX, "node_modules", PKG, "worker", "cli.mjs");
+
+const MAC_LABEL = "com.goosetools.overlay";
+const MAC_PLIST = join(homedir(), "Library", "LaunchAgents", `${MAC_LABEL}.plist`);
+const LOG = join(GOOSE_DIR, "overlay-worker.log");
+const ERR_LOG = join(GOOSE_DIR, "overlay-worker.err.log");
+
+function sh(cmd, opts = {}) {
+  return execSync(cmd, { stdio: ["ignore", "pipe", "pipe"], ...opts })
+    .toString()
+    .trim();
+}
+
+function quietSh(cmd) {
+  try {
+    sh(cmd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isEmptyDir(dir) {
+  try {
+    return readdirSync(dir).length === 0;
+  } catch {
+    return true;
+  }
+}
+
+export function hasFfmpeg() {
+  return quietSh("ffmpeg -version") && quietSh("ffprobe -version");
+}
+
+function npmGlobalBin() {
+  try {
+    return join(sh("npm prefix -g", { shell: true }), "bin");
+  } catch {
+    return "";
+  }
+}
+
+// launchd starts an agent with an almost empty environment. The render shells
+// out to ffmpeg, npx and claude, so PATH is spelled out here — inheriting the
+// interactive shell's PATH is exactly what does not happen, and it's the usual
+// way one of these agents ends up running but failing every job.
+function servicePath() {
+  const parts = [
+    dirname(process.execPath),
+    npmGlobalBin(),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    `${process.env.HOME ?? ""}/.local/bin`,
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin",
+  ].filter(Boolean);
+  return [...new Set(parts)].join(":");
+}
+
+function readEnvFile() {
+  if (!existsSync(ENV_FILE)) return {};
+  return Object.fromEntries(
+    readFileSync(ENV_FILE, "utf8")
+      .split("\n")
+      .filter((l) => l.includes("=") && !l.trim().startsWith("#"))
+      .map((l) => [
+        l.slice(0, l.indexOf("=")).trim(),
+        l.slice(l.indexOf("=") + 1).trim(),
+      ]),
+  );
+}
+
+// One token file for every worker on this machine. Whichever installer runs
+// last writes it, and they all write the same two keys — so `goosetools
+// install --token gt_…` leaves every worker pointing at the same credential.
+function writeEnvFile({ url, token }) {
+  mkdirSync(GOOSE_DIR, { recursive: true });
+  writeFileSync(ENV_FILE, `GOOSETOOLS_URL=${url}\nWORKER_TOKEN=${token}\n`);
+  chmodSync(ENV_FILE, 0o600);
+}
+
+function installStableCopy(root) {
+  console.log("Setting up the background copy (this can take a few minutes)…");
+  mkdirSync(APP_PREFIX, { recursive: true });
+  // From a git checkout (development), install the checkout itself; normal
+  // npx users get the published package.
+  const source = existsSync(join(root, ".git")) ? `"${root}"` : `${PKG}@latest`;
+  execSync(
+    `npm install --no-fund --no-audit --loglevel=error --prefix "${APP_PREFIX}" ${source}`,
+    { stdio: ["ignore", "inherit", "inherit"], shell: true },
+  );
+  if (!existsSync(INSTALLED_CLI)) {
+    throw new Error("background copy did not install where expected");
+  }
+}
+
+// ── macOS (launchd) ─────────────────────────────────────────────────────────
+
+function macPlist() {
+  const esc = (s) =>
+    s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${MAC_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${esc(process.execPath)}</string>
+        <string>${esc(INSTALLED_CLI)}</string>
+        <string>run</string>
+    </array>
+    <key>WorkingDirectory</key>
+    <string>${esc(join(APP_PREFIX, "node_modules", PKG))}</string>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>ThrottleInterval</key>
+    <integer>30</integer>
+    <key>StandardOutPath</key>
+    <string>${esc(LOG)}</string>
+    <key>StandardErrorPath</key>
+    <string>${esc(ERR_LOG)}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${esc(servicePath())}</string>
+        <key>HOME</key>
+        <string>${esc(homedir())}</string>
+    </dict>
+</dict>
+</plist>
+`;
+}
+
+function macInstall() {
+  mkdirSync(dirname(MAC_PLIST), { recursive: true });
+  writeFileSync(MAC_PLIST, macPlist());
+  const uid = process.getuid();
+  quietSh(`launchctl bootout gui/${uid}/${MAC_LABEL}`);
+  if (!quietSh(`launchctl bootstrap gui/${uid} "${MAC_PLIST}"`)) {
+    quietSh(`launchctl unload "${MAC_PLIST}"`);
+    execSync(`launchctl load -w "${MAC_PLIST}"`, { stdio: "ignore" });
+  }
+}
+
+function macUninstall() {
+  quietSh(`launchctl bootout gui/${process.getuid()}/${MAC_LABEL}`);
+  quietSh(`launchctl unload "${MAC_PLIST}"`);
+  rmSync(MAC_PLIST, { force: true });
+}
+
+function requireMac() {
+  if (process.platform === "darwin") return;
+  console.error(
+    "\nThe Overlay Factory worker runs on macOS only — the render encodes with\n" +
+      "hevc_videotoolbox, an Apple framework. The other Goose Tools workers\n" +
+      "(Carousel, Caption, Brand) work here; only reels need a Mac.\n",
+  );
+  process.exit(1);
+}
+
+// ── Public commands ─────────────────────────────────────────────────────────
+
+export function install({ url, token, root }) {
+  requireMac();
+  if (!token) {
+    console.error(
+      `Missing worker token. Run: npx ${PKG} install --url ${url} --token gt_…`,
+    );
+    process.exit(1);
+  }
+  writeEnvFile({ url, token });
+  mkdirSync(STATE_DIR, { recursive: true });
+  installStableCopy(root);
+  macInstall();
+  console.log(
+    "\n✓ Overlay Factory connected. This computer renders reels in the\n" +
+      "  background whenever it's on, even after a restart.\n\n" +
+      `  Logs:      ${LOG}\n` +
+      `  Your work: ${STATE_DIR}  (puzzles, looks, cards — kept across updates)\n` +
+      `  Turn off:  npx --yes ${PKG} uninstall\n`,
+  );
+  // Anyone who ran this worker from a reel-factory checkout has a puzzle
+  // library and learned looks sitting in that repo. The packaged worker reads
+  // the state dir instead, so say where to bring them across rather than
+  // letting it look like the work vanished.
+  if (isEmptyDir(STATE_DIR)) {
+    console.log(
+      "  Ran this from a reel-factory checkout before? Bring your work over:\n\n" +
+        `      cp -R ~/code/reel-factory/{episodes,puzzles,series} ${STATE_DIR}/\n` +
+        `      cp -R ~/code/reel-factory/public/assets ${STATE_DIR}/assets\n`,
+    );
+  }
+  if (!hasFfmpeg()) {
+    console.log(
+      "  One thing left — reels need ffmpeg, which isn't installed yet:\n\n" +
+        "      brew install ffmpeg\n\n" +
+        "  Everything else on this computer works without it. Renders will\n" +
+        "  fail with that same message until it's there.\n",
+    );
+  }
+}
+
+export function uninstall() {
+  macUninstall();
+  rmSync(APP_PREFIX, { recursive: true, force: true });
+  console.log(
+    "✓ Overlay Factory worker removed — this computer no longer renders reels.\n" +
+      `  Kept: ${STATE_DIR} (puzzles, looks, used-card record). Delete it by hand\n` +
+      "  if you want it gone; nothing else has a copy.",
+  );
+}
+
+// The daemon runs the COPY under ~/.goosetools/overlay-app, not wherever this
+// was run from — so new code only reaches it by reinstalling that copy.
+// Re-registering the service restarts it, which is what actually loads the new
+// code (Node reads every module once, at startup).
+export function update({ root }) {
+  requireMac();
+  const saved = readEnvFile();
+  if (!saved.WORKER_TOKEN) {
+    console.error(
+      "No saved worker token — this computer hasn't been connected yet.\n" +
+        "Get your connect command at https://goosetools.com/dashboard/setup",
+    );
+    process.exit(1);
+  }
+  const before = installedVersion();
+  installStableCopy(root);
+  macInstall();
+  const after = installedVersion();
+  console.log(
+    after && before && after !== before
+      ? `\n✓ Updated ${before} → ${after} and restarted. Nothing else to do.\n`
+      : `\n✓ Worker reinstalled (version ${after ?? "unknown"}) and restarted.\n`,
+  );
+}
+
+// ── status ──────────────────────────────────────────────────────────────────
+
+function installedVersion() {
+  try {
+    const pkg = join(APP_PREFIX, "node_modules", PKG, "package.json");
+    return JSON.parse(readFileSync(pkg, "utf8")).version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function latestVersion() {
+  try {
+    return sh(`npm view ${PKG} version`, { shell: true, timeout: 15000 });
+  } catch {
+    return null; // offline, or npm unreachable — not worth failing on
+  }
+}
+
+function compareVersions(a, b) {
+  const parts = (v) =>
+    String(v)
+      .split(".")
+      .map((n) => Number.parseInt(n, 10) || 0);
+  const [pa, pb] = [parts(a), parts(b)];
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) < (pb[i] ?? 0) ? -1 : 1;
+  }
+  return 0;
+}
+
+// launchctl prints "<pid>\t<last exit>\t<label>"; a "-" pid means registered
+// but not currently running.
+function servicePid() {
+  try {
+    const line = sh(`launchctl list | grep ${MAC_LABEL}`, { shell: true });
+    const pid = line.split(/\s+/)[0];
+    return pid === "-" ? null : pid;
+  } catch {
+    return null;
+  }
+}
+
+function tail(file, n) {
+  try {
+    return readFileSync(file, "utf8").trimEnd().split("\n").slice(-n).join("\n");
+  } catch {
+    return "";
+  }
+}
+
+// How long ago a log was last written. Without this, days-old errors read as
+// a live outage — the single most misleading thing in a log tail.
+function lastWritten(file) {
+  try {
+    const mins = Math.round((Date.now() - statSync(file).mtimeMs) / 60000);
+    if (mins < 1) return "just now";
+    if (mins < 60) return `${mins} min ago`;
+    const hours = Math.round(mins / 60);
+    if (hours < 24) return `${hours} hr ago`;
+    return `${Math.round(hours / 24)} days ago`;
+  } catch {
+    return "unknown";
+  }
+}
+
+export function status() {
+  const ok = (b) => (b ? "✓" : "✗");
+  const env = readEnvFile();
+  const installed = installedVersion();
+  const latest = latestVersion();
+  const pid = servicePid();
+  const url = env.GOOSETOOLS_URL ?? "https://goosetools.com";
+  const ffmpeg = hasFfmpeg();
+
+  console.log("\nOverlay Factory worker — status\n");
+  console.log(`  ${ok(installed)} Installed        ${installed ?? "not installed"}`);
+  const cmp = installed && latest ? compareVersions(installed, latest) : 0;
+  const stale = cmp < 0;
+  if (latest) {
+    const note = stale
+      ? "  ← update available"
+      : cmp > 0
+        ? "  (you're ahead — local dev build)"
+        : "";
+    console.log(`  ${ok(!stale)} Latest on npm    ${latest}${note}`);
+  } else {
+    console.log("  · Latest on npm    couldn't check (offline?)");
+  }
+  console.log(`  ${ok(pid)} Running          ${pid ? `yes (pid ${pid})` : "no"}`);
+  console.log(
+    `  ${ok(env.WORKER_TOKEN)} Token saved      ${
+      env.WORKER_TOKEN ? "yes" : "no — reconnect at goosetools.com/dashboard/setup"
+    }`,
+  );
+  console.log(
+    `  ${ok(ffmpeg)} ffmpeg           ${
+      ffmpeg ? "found" : "missing — renders fail without it: brew install ffmpeg"
+    }`,
+  );
+  console.log(`  · Server           ${url}`);
+  console.log(`  · Your work        ${STATE_DIR}`);
+  console.log(`  · Logs             ${LOG}`);
+
+  const errors = tail(ERR_LOG, 15);
+  if (errors) {
+    console.log(
+      `\nErrors (last written ${lastWritten(ERR_LOG)}):\n${errors.replace(/^/gm, "  ")}`,
+    );
+  }
+  const log = tail(LOG, 15);
+  if (log) {
+    console.log(
+      `\nActivity (last written ${lastWritten(LOG)}):\n${log.replace(/^/gm, "  ")}`,
+    );
+  }
+
+  if (stale) {
+    console.log(`\nTo update:  npx --yes ${PKG}@latest update\n`);
+  } else if (!pid && installed) {
+    console.log(`\nNot running. Restart it with:  npx --yes ${PKG}@latest update\n`);
+  } else {
+    console.log("");
+  }
+}