goosetools-worker 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goosetools-worker",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "The Goose Tools carousel worker — your computer drafts and renders carousel slides for goosetools.com using your own Claude account.",
   "repository": {
     "type": "git",
@@ -25,7 +25,8 @@
   "scripts": {
     "render": "node src/render.js",
     "demo": "node src/render.js carousels/demo",
-    "worker": "node worker/index.js"
+    "worker": "node worker/index.js",
+    "prepublishOnly": "node ../sync-shared.mjs --check"
   },
   "dependencies": {
     "@vercel/blob": "^0.27.0",

package/worker/agent-cli.js

@@ -1,9 +1,11 @@
 // Agent CLI adapter — runs a job's prompt through whichever coding-agent CLI
 // the user picked on goosetools.com (claim payloads carry `agentCli`).
 //
-// VENDORED FILE: keep byte-identical across brand-manager-worker,
-// caption-maker, and carousel-maker (worker/agent-cli.js in each). Fix a bug
-// here, copy it to the other two.
+// SHARED FILE: the source of truth is workers/shared/agent-cli.js in the
+// goosetools repo. Each worker ships its own copy (worker/agent-cli.js) so the
+// npm packages stay self-contained. Edit the shared one, then run
+// `npm run workers:sync` from the repo root; `npm run workers:check` fails if
+// a copy has drifted.
 //
 // Modes, chosen for speed-vs-capability (see brand-manager commit c0c1b33 —
 // tool-looping turned 36-second drafts into 10-minute ones):

package/worker/cli-core.js

@@ -0,0 +1,88 @@
+// SHARED FILE: the source of truth is workers/shared/cli-core.js in the
+// goosetools repo; each worker ships a copy as worker/cli-core.js. Edit the
+// shared one, then `npm run workers:sync`.
+//
+// The command-line entrypoint every worker shares. Each worker's
+// worker/cli.js (its npm `bin`) is a few lines calling runCli().
+//
+//   install    save token + register a login service (worker runs forever)
+//   update     pull the newest code into the background copy + restart
+//   status     what's installed, whether it's running, recent log lines
+//   uninstall  remove the service (the shared token stays)
+//   doctor     which coding-agent CLIs are installed
+//   run        run the worker loop in this window (default)
+
+import { execSync } from "node:child_process";
+
+const COMMANDS = ["install", "update", "status", "uninstall", "run", "doctor"];
+
+function flag(name) {
+  const i = process.argv.indexOf(name);
+  return i !== -1 ? process.argv[i + 1] : undefined;
+}
+
+function has(cmd) {
+  try {
+    execSync(process.platform === "win32" ? `where ${cmd}` : `command -v ${cmd}`, {
+      stdio: "ignore",
+      shell: true,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {object} opts
+ * @param {string} opts.root                  the package root (parent of worker/)
+ * @param {string} opts.writes                finishes "Claude Code isn't installed yet (it writes …)"
+ * @param {() => Promise<{install, update, uninstall, status}>} opts.service  loads worker/service.js
+ * @param {() => Promise<unknown>} opts.worker                                 loads worker/index.js
+ * @param {() => void} [opts.preflight]       extra setup before install/update/run (e.g. a browser)
+ */
+export async function runCli({ root, writes, service, worker, preflight }) {
+  const command = COMMANDS.includes(process.argv[2]) ? process.argv[2] : "run";
+
+  // These only inspect or tear down what's already there, so they skip the
+  // preflight below — `status` in particular has to work precisely when
+  // something IS wrong.
+  if (command === "uninstall") return (await service()).uninstall();
+  if (command === "status") return (await service()).status();
+
+  // Claude Code is the default agent, so it's required to set up; the other
+  // agents (picked in Setup on goosetools.com) are checked lazily per job and
+  // reported here.
+  if (command === "doctor") {
+    const { AGENT_IDS, detect } = await import("./agent-cli.js");
+    for (const id of AGENT_IDS) {
+      const d = detect(id);
+      console.log(`${d.installed ? "✓" : "✗"} ${d.label}${d.installed ? "" : `  — install: ${d.hint}`}`);
+    }
+    return;
+  }
+
+  if (!has("claude")) {
+    console.error(
+      `\nClaude Code isn't installed yet (it writes ${writes}).\n` +
+        "Install it with:  npm install -g @anthropic-ai/claude-code\n" +
+        "Then run:         claude   (once, to sign in — type /exit to leave)\n" +
+        "Then run this command again.\n",
+    );
+    process.exit(1);
+  }
+
+  preflight?.();
+
+  if (command === "install") {
+    // No --url means "keep the saved server, else goosetools.com" — decided in
+    // install(), which can see the saved one.
+    return (await service()).install({
+      url: flag("--url")?.replace(/\/$/, ""),
+      token: flag("--token"),
+      root,
+    });
+  }
+  if (command === "update") return (await service()).update({ root });
+  await worker();
+}

package/worker/cli.js

@@ -1,124 +1,56 @@
 #!/usr/bin/env node
-// goosetools-worker entrypoint — makes first run painless for non-technical
-// users: checks for Claude Code + the Playwright browser, installs the
-// browser if missing, then runs the requested command.
-//
-//   install    save token + register a login service (worker runs forever)
-//   update     pull the newest code into the background copy + restart
-//   status     what's installed, whether it's running, recent log lines
-//   uninstall  remove the service + saved token
-//   run        run the worker loop in this window (default)
+// goosetools-worker (Carousel Maker) entrypoint. The commands live in
+// worker/cli-core.js (shared by every worker); this adds the one thing
+// carousels need first: the Playwright browser that renders slides, installed
+// if missing so first run is painless for non-technical users.
 
-import { execFileSync, execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { runCli } from "./cli-core.js";
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
-const command = ["install", "update", "status", "uninstall", "run", "doctor"].includes(process.argv[2])
-  ? process.argv[2]
-  : "run";
-
-// These two only inspect or tear down what's already there, so they skip the
-// Claude Code / browser preflight below — `status` in particular has to work
-// precisely when something IS wrong.
-if (command === "uninstall") {
-  const { uninstall } = await import("./service.js");
-  uninstall();
-  process.exit(0);
-}
-
-if (command === "status") {
-  const { status } = await import("./service.js");
-  status();
-  process.exit(0);
-}
-
-function flag(name) {
-  const i = process.argv.indexOf(name);
-  return i !== -1 ? process.argv[i + 1] : undefined;
-}
-
-function has(cmd) {
+// Make sure the rendering browser is present (quiet no-op when it is).
+function ensureBrowser() {
+  // Run the playwright CLI that ships with our own dependencies via node —
+  // going through `npx playwright` instead prints a scary warning box.
   try {
-    execSync(process.platform === "win32" ? `where ${cmd}` : `command -v ${cmd}`, {
-      stdio: "ignore",
-      shell: true,
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// Claude Code is the default agent, so it's required to set up; the other
-// agents (picked in Setup on goosetools.com) are checked lazily per job and
-// reported by `doctor`.
-if (command === "doctor") {
-  const { AGENT_IDS, detect } = await import("./agent-cli.js");
-  for (const id of AGENT_IDS) {
-    const d = detect(id);
-    console.log(
-      `${d.installed ? "✓" : "✗"} ${d.label}${d.installed ? "" : `  — install: ${d.hint}`}`,
+    console.log("Checking the rendering browser (first run can take a minute)…");
+    const require = createRequire(join(ROOT, "package.json"));
+    const playwrightCli = join(
+      dirname(require.resolve("playwright/package.json")),
+      "cli.js",
     );
+    if (existsSync(playwrightCli)) {
+      // Quiet on success — playwright's CLI prints a misleading "run npm
+      // install first" box in the npx cache layout. Its output is only shown
+      // (via the catch below) when the install genuinely fails.
+      execFileSync(process.execPath, [playwrightCli, "install", "chromium"], {
+        cwd: ROOT,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+    } else {
+      execFileSync("npx", ["--yes", "playwright", "install", "chromium"], {
+        cwd: ROOT,
+        stdio: "inherit",
+        shell: process.platform === "win32",
+      });
+    }
+  } catch (err) {
+    const detail = err?.stderr?.toString().trim();
+    if (detail) console.error(detail);
+    console.error("Couldn't install the rendering browser — check your internet connection and retry.");
+    process.exit(1);
   }
-  process.exit(0);
 }
 
-if (!has("claude")) {
-  console.error(
-    "\nClaude Code isn't installed yet (it writes your slides).\n" +
-      "Install it with:  npm install -g @anthropic-ai/claude-code\n" +
-      "Then run:         claude   (once, to sign in — type /exit to leave)\n" +
-      "Then run this command again.\n",
-  );
-  process.exit(1);
-}
-
-// Make sure the rendering browser is present (quiet no-op when it is).
-// Run the playwright CLI that ships with our own dependencies via node —
-// going through `npx playwright` instead prints a scary warning box.
-try {
-  console.log("Checking the rendering browser (first run can take a minute)…");
-  const require = createRequire(join(ROOT, "package.json"));
-  const playwrightCli = join(
-    dirname(require.resolve("playwright/package.json")),
-    "cli.js",
-  );
-  if (existsSync(playwrightCli)) {
-    // Quiet on success — playwright's CLI prints a misleading "run npm
-    // install first" box in the npx cache layout. Its output is only shown
-    // (via the catch below) when the install genuinely fails.
-    execFileSync(process.execPath, [playwrightCli, "install", "chromium"], {
-      cwd: ROOT,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-  } else {
-    execFileSync("npx", ["--yes", "playwright", "install", "chromium"], {
-      cwd: ROOT,
-      stdio: "inherit",
-      shell: process.platform === "win32",
-    });
-  }
-} catch (err) {
-  const detail = err?.stderr?.toString().trim();
-  if (detail) console.error(detail);
-  console.error("Couldn't install the rendering browser — check your internet connection and retry.");
-  process.exit(1);
-}
-
-if (command === "install") {
-  const { install } = await import("./service.js");
-  install({
-    url: (flag("--url") ?? "https://goosetools.com").replace(/\/$/, ""),
-    token: flag("--token"),
-    root: ROOT,
-  });
-} else if (command === "update") {
-  const { update } = await import("./service.js");
-  update({ root: ROOT });
-} else {
-  await import("./index.js");
-}
+await runCli({
+  root: ROOT,
+  writes: "your slides",
+  service: () => import("./service.js"),
+  worker: () => import("./index.js"),
+  preflight: ensureBrowser,
+});

package/worker/index.js

@@ -11,11 +11,19 @@ import { join, dirname, resolve, extname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import yaml from "js-yaml";
-import { upload } from "@vercel/blob/client";
+import { upload } from "./upload.js";
 import { skillSection } from "./skill.js";
 import { extFromUrl } from "./style.js";
 import { FONT_SPECS, sanitizeFonts } from "../src/fonts.js";
 import { assertFfmpeg, isVideoPath, posterFrame } from "../src/video.js";
+import { acquireWorkerLock } from "./lock.js";
+
+// One worker of each kind per machine — a second one would split the queue
+// with this one. Stands down with an explanation if another already holds it.
+acquireWorkerLock("worker", {
+  label: "The Carousel Maker worker",
+  stopHint: "launchctl bootout gui/$(id -u)/com.goosetools.worker   (or close its terminal)",
+});
 
 const execFileAsync = promisify(execFile);
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
@@ -683,11 +691,10 @@ Do not rewrite any slide's text and do not switch templates.`;
   await api("complete", { jobId: job.id, ok: true, slidesYml, resultUrls });
   console.log(`✓ job ${job.id}: ${resultUrls.length} slides uploaded`);
 
-  // The slides are safely in Blob storage now, so the local scratch dir (photos
-  // + rendered PNGs, tens of MB per job) has done its job. Without this it
-  // accumulates forever under carousels/. Only reached on success — a failed
-  // job keeps its dir for debugging (the main loop's catch handles those).
-  rmSync(dir, { recursive: true, force: true });
+  // The local copy stays. carousels/web-<id>/output/ is the creator's own
+  // archive of every deck this machine rendered — it is what let the renders
+  // the 2026 retention purge deleted be put back. Disk is theirs to spend;
+  // nothing a creator made is thrown away by a tool.
 }
 
 // ── Main loop ────────────────────────────────────────────────────────────────

package/worker/lock.js

@@ -0,0 +1,103 @@
+// One worker of each kind per machine.
+//
+// Nothing stops you starting a second worker: the daemon runs in the
+// background, and `run` in a terminal is the normal way to watch one work or
+// to try a change from a checkout. Both then poll the same queue with the same
+// token.
+//
+// The server is safe — claiming a job is a single compare-and-set, so two
+// workers never get the same one. The damage is quieter than that. They SPLIT
+// the queue, so jobs land on whichever copy happened to pick them up: half
+// from the code you're editing, half from the installed release, with a
+// different state directory behind each. And the polling doubles, which is
+// what the idle interval exists to keep down in the first place.
+//
+// So: whoever gets here first holds the lock, and the second one stands down
+// with an explanation instead of quietly competing.
+
+import { execFileSync } from "node:child_process";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const LOCK_DIR = join(homedir(), ".goosetools", "locks");
+
+/**
+ * Take the lock for `name` ("worker", "caption", "brand", "overlay"), or print
+ * who has it and exit. Returns nothing — it either succeeds or ends the
+ * process.
+ *
+ * `stopHint` is the command that stops the OTHER copy, and it's the whole
+ * point of the message: "already running" without it just moves the puzzle.
+ */
+export function acquireWorkerLock(name, { label, stopHint }) {
+  mkdirSync(LOCK_DIR, { recursive: true });
+  const file = join(LOCK_DIR, `${name}.pid`);
+
+  const holder = readHolder(file);
+  if (holder && isAlive(holder.pid)) {
+    console.log(
+      `\n${label} is already running on this computer (pid ${holder.pid}${
+        holder.since ? `, since ${holder.since}` : ""
+      }).\n\n` +
+        "Two of them would split the queue between them — some jobs done by\n" +
+        "one copy, some by the other. Stopping here instead.\n\n" +
+        `  Stop the other one:  ${stopHint}\n`,
+    );
+    process.exit(0);
+  }
+
+  // Either no lock, or one left behind by a worker that was killed. Both are
+  // ours to take: an O_EXCL create loses to a worker that beat us here by
+  // milliseconds, which is the one race worth caring about.
+  if (holder) rmSync(file, { force: true });
+  let fd;
+  try {
+    fd = openSync(file, "wx");
+  } catch {
+    console.log(`\n${label} started somewhere else a moment ago. Stopping here.\n`);
+    process.exit(0);
+  }
+  writeSync(fd, `${process.pid}\n${new Date().toISOString()}\n`);
+  closeSync(fd);
+
+  const release = () => rmSync(file, { force: true });
+  process.on("exit", release);
+  for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+    process.on(sig, () => {
+      release();
+      process.exit(0);
+    });
+  }
+}
+
+function readHolder(file) {
+  if (!existsSync(file)) return null;
+  try {
+    const [pid, since] = readFileSync(file, "utf8").split("\n");
+    const n = Number.parseInt(pid, 10);
+    return Number.isFinite(n) ? { pid: n, since: since?.trim() || null } : null;
+  } catch {
+    return null;
+  }
+}
+
+// A pid file outlives a SIGKILLed worker, and pids get reused — so "is that
+// pid alive" isn't enough on its own. Checking that it's a node process is
+// cheap and rules out the reuse case that would otherwise lock out the daemon
+// until someone deleted the file by hand.
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return false;
+  }
+  try {
+    return /node/.test(execFileSync("ps", ["-p", String(pid), "-o", "command="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }));
+  } catch {
+    return false;
+  }
+}

package/worker/service-core.js

@@ -0,0 +1,411 @@
+// SHARED FILE: the source of truth is workers/shared/service-core.js in the
+// goosetools repo; each worker ships a copy as worker/service-core.js. Edit the
+// shared one, then `npm run workers:sync`.
+//
+// Background-service install/uninstall for a Goose Tools worker. Each worker's
+// own worker/service.js is a thin config around this (package name, service
+// label, log paths, wording), so the three can't drift apart again.
+//
+// `install` makes the worker persistent: token saved to ~/.goosetools/env, a
+// stable copy of the package installed under ~/.goosetools/<appDir>, and a
+// login service registered (launchd LaunchAgent on macOS, a logon Scheduled
+// Task on Windows) so the worker runs whenever the computer is on — no
+// terminal window needed. `update` re-runs that install against the newest
+// code, reusing the saved token; `status` reports what's actually running.
+//
+// The worker TOKEN is shared: every worker reads ~/.goosetools/env, so a
+// computer already connected for one tool needs no --token for the next.
+//
+// Service labels, app dirs and log names are per worker and must never change:
+// an update re-registers the service under the same name, which is what
+// replaces the old one on machines that already have it.
+
+import { execSync } from "node:child_process";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  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 DEFAULT_URL = "https://goosetools.com";
+
+function sh(cmd, opts = {}) {
+  return execSync(cmd, { stdio: ["ignore", "pipe", "pipe"], ...opts })
+    .toString()
+    .trim();
+}
+
+export function quietSh(cmd) {
+  try {
+    sh(cmd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function npmGlobalBin() {
+  try {
+    const prefix = sh("npm prefix -g", { shell: true });
+    return process.platform === "win32" ? prefix : join(prefix, "bin");
+  } catch {
+    return "";
+  }
+}
+
+// Everything the daemon needs to find: node itself, the npm-global bin (where
+// `claude` lives), plus the usual suspects.
+function servicePath() {
+  const parts = [
+    dirname(process.execPath),
+    npmGlobalBin(),
+    ...(process.platform === "win32"
+      ? [process.env.PATH ?? ""]
+      : [
+          "/opt/homebrew/bin",
+          "/usr/local/bin",
+          // opencode's installer and some npm setups drop binaries here.
+          `${process.env.HOME ?? ""}/.local/bin`,
+          "/usr/bin",
+          "/bin",
+          "/usr/sbin",
+          "/sbin",
+        ]),
+  ].filter(Boolean);
+  return [...new Set(parts)].join(process.platform === "win32" ? ";" : ":");
+}
+
+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()]),
+  );
+}
+
+function writeEnvFile({ url, token }) {
+  mkdirSync(GOOSE_DIR, { recursive: true });
+  writeFileSync(ENV_FILE, `GOOSETOOLS_URL=${url}\nWORKER_TOKEN=${token}\n`);
+  chmodSync(ENV_FILE, 0o600);
+}
+
+function compareVersions(a, b) {
+  // -1 / 0 / 1, comparing x.y.z numerically. Anything unparseable sorts equal
+  // so an odd version string never nags the user to "update" in a loop.
+  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;
+}
+
+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 ms = Date.now() - statSync(file).mtimeMs;
+    const mins = Math.round(ms / 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";
+  }
+}
+
+/**
+ * @param {object} cfg
+ * @param {string} cfg.pkg          npm package name, e.g. "caption-maker-worker"
+ * @param {string} cfg.name         for messages, e.g. "Caption worker"
+ * @param {string} cfg.appDir       background copy under ~/.goosetools, e.g. "caption-app"
+ * @param {string} cfg.macLabel     launchd label, e.g. "com.goosetools.caption"
+ * @param {string} cfg.winTask      Scheduled Task name
+ * @param {string} cfg.winVbs       launcher file name under ~/.goosetools
+ * @param {string} cfg.logName      log file name under ~/.goosetools (".log" / ".err.log" appended)
+ * @param {string} cfg.dashboard    where a token comes from, e.g. "/dashboard/caption"
+ * @param {string} cfg.doing        finishes "This computer now …", e.g. "writes your captions"
+ * @param {() => string | void} [cfg.afterInstall]  extra lines printed after a successful install
+ * @param {() => string[]} [cfg.statusLines]        extra "  ✓ Label   value" rows for status
+ */
+export function createService(cfg) {
+  const APP_PREFIX = join(GOOSE_DIR, cfg.appDir);
+  const INSTALLED_CLI = join(APP_PREFIX, "node_modules", cfg.pkg, "worker", "cli.js");
+  const MAC_PLIST = join(homedir(), "Library", "LaunchAgents", `${cfg.macLabel}.plist`);
+  const WIN_VBS = join(GOOSE_DIR, cfg.winVbs);
+  const LOG_FILE = join(GOOSE_DIR, `${cfg.logName}.log`);
+  const ERR_FILE = join(GOOSE_DIR, `${cfg.logName}.err.log`);
+  const connectHint =
+    `Get a token at ${DEFAULT_URL}${cfg.dashboard} (any tool — same token), then run:\n` +
+    `  npx --yes ${cfg.pkg}@latest install --token gt_…`;
+
+  function installStableCopy(root) {
+    console.log("Setting up the background copy (this can take a minute)…");
+    mkdirSync(APP_PREFIX, { recursive: true });
+    // From a git checkout (development), install the checkout itself; normal
+    // npx users get the published package.
+    const source = isCheckout(root) ? `"${root}"` : `${cfg.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>${cfg.macLabel}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${esc(process.execPath)}</string>
+        <string>${esc(INSTALLED_CLI)}</string>
+        <string>run</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>ThrottleInterval</key>
+    <integer>30</integer>
+    <key>StandardOutPath</key>
+    <string>${esc(LOG_FILE)}</string>
+    <key>StandardErrorPath</key>
+    <string>${esc(ERR_FILE)}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${esc(servicePath())}</string>
+    </dict>
+</dict>
+</plist>
+`;
+  }
+
+  function macInstall() {
+    mkdirSync(dirname(MAC_PLIST), { recursive: true });
+    writeFileSync(MAC_PLIST, macPlist());
+    const uid = process.getuid();
+    // Re-registering: tear down any previous copy first, then bootstrap.
+    quietSh(`launchctl bootout gui/${uid}/${cfg.macLabel}`);
+    if (!quietSh(`launchctl bootstrap gui/${uid} "${MAC_PLIST}"`)) {
+      // Older macOS fallback.
+      quietSh(`launchctl unload "${MAC_PLIST}"`);
+      execSync(`launchctl load -w "${MAC_PLIST}"`, { stdio: "ignore" });
+    }
+  }
+
+  function macUninstall() {
+    quietSh(`launchctl bootout gui/${process.getuid()}/${cfg.macLabel}`);
+    quietSh(`launchctl unload "${MAC_PLIST}"`);
+    rmSync(MAC_PLIST, { force: true });
+  }
+
+  // ── Windows (Scheduled Task at logon, hidden window) ───────────────────────
+
+  function winInstall() {
+    // wscript launches the worker with no console window.
+    const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${INSTALLED_CLI}"" run", 0, False\r\n`;
+    writeFileSync(WIN_VBS, vbs);
+    quietSh(`schtasks /End /TN "${cfg.winTask}"`);
+    quietSh(`schtasks /Delete /F /TN "${cfg.winTask}"`);
+    execSync(`schtasks /Create /F /SC ONLOGON /TN "${cfg.winTask}" /TR "wscript.exe \\"${WIN_VBS}\\""`, {
+      stdio: "ignore",
+      shell: true,
+    });
+    execSync(`schtasks /Run /TN "${cfg.winTask}"`, { stdio: "ignore", shell: true });
+  }
+
+  function winUninstall() {
+    quietSh(`schtasks /End /TN "${cfg.winTask}"`);
+    quietSh(`schtasks /Delete /F /TN "${cfg.winTask}"`);
+    rmSync(WIN_VBS, { force: true });
+  }
+
+  function registerService() {
+    if (process.platform === "darwin") macInstall();
+    else if (process.platform === "win32") winInstall();
+    else {
+      console.error(
+        "Automatic background setup isn't available on this OS yet.\n" +
+          `Run the worker directly instead:  ${cfg.pkg} run`,
+      );
+      process.exit(1);
+    }
+  }
+
+  function installedVersion() {
+    try {
+      const pkg = join(APP_PREFIX, "node_modules", cfg.pkg, "package.json");
+      return JSON.parse(readFileSync(pkg, "utf8")).version ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  function latestVersion() {
+    try {
+      return sh(`npm view ${cfg.pkg} version`, { shell: true, timeout: 15000 });
+    } catch {
+      return null; // offline, or npm unreachable — not an error worth failing on
+    }
+  }
+
+  // launchctl prints "<pid>\t<last exit>\t<label>"; a "-" pid means registered
+  // but not currently running.
+  function servicePid() {
+    try {
+      if (process.platform === "darwin") {
+        const line = sh(`launchctl list | grep ${cfg.macLabel}`, { shell: true });
+        const pid = line.split(/\s+/)[0];
+        return pid === "-" ? null : pid;
+      }
+      const out = sh(`schtasks /Query /TN "${cfg.winTask}" /FO LIST`, { shell: true });
+      return /Running/i.test(out) ? "running" : null;
+    } catch {
+      return null;
+    }
+  }
+
+  // ── Public commands ────────────────────────────────────────────────────────
+
+  function install({ url, token, root }) {
+    // Reuse the saved token and server when the caller didn't pass them — a
+    // computer already connected for another tool.
+    const saved = readEnvFile();
+    const effectiveToken = token ?? saved.WORKER_TOKEN;
+    const effectiveUrl = url ?? saved.GOOSETOOLS_URL ?? DEFAULT_URL;
+    if (!effectiveToken) {
+      console.error(`No worker token found. ${connectHint}`);
+      process.exit(1);
+    }
+    writeEnvFile({ url: effectiveUrl, token: effectiveToken });
+    installStableCopy(root);
+    registerService();
+    console.log(
+      `\n✓ All set! This computer now ${cfg.doing} in the background —\n` +
+        "  whenever it's on, even after a restart. You can close this window.\n\n" +
+        `  Logs:      ${LOG_FILE}\n` +
+        `  Turn off:  npx --yes ${cfg.pkg} uninstall\n`,
+    );
+    const extra = cfg.afterInstall?.();
+    if (extra) console.log(extra);
+  }
+
+  // Removes THIS worker, not the whole ~/.goosetools directory: the Overlay
+  // Factory keeps its puzzle library, learned looks and used-card record in
+  // ~/.goosetools/overlay, and nothing else has a copy of those. The shared
+  // token file stays too — the other workers are still using it.
+  function uninstall() {
+    if (process.platform === "darwin") macUninstall();
+    else if (process.platform === "win32") winUninstall();
+    rmSync(APP_PREFIX, { recursive: true, force: true });
+    rmSync(LOG_FILE, { force: true });
+    rmSync(ERR_FILE, { force: true });
+    console.log(`✓ ${cfg.name} removed. (Your other workers and connection are untouched.)`);
+  }
+
+  // The daemon runs the COPY under ~/.goosetools/<appDir>, not wherever you ran
+  // this from — so new code only reaches it by reinstalling that copy.
+  // Re-registering the service also restarts it, which is what actually loads
+  // the new code (Node reads every module once, at startup).
+  function update({ root }) {
+    const saved = readEnvFile();
+    if (!saved.WORKER_TOKEN) {
+      console.error(`No saved worker token — this computer hasn't been connected yet.\n${connectHint}`);
+      process.exit(1);
+    }
+    const before = installedVersion();
+    installStableCopy(root);
+    registerService();
+    const after = installedVersion();
+    console.log(
+      after && before && after !== before
+        ? `\n✓ Updated ${before} → ${after} and restarted. Nothing else to do.\n`
+        : `\n✓ ${cfg.name} reinstalled (version ${after ?? "unknown"}) and restarted.\n`,
+    );
+  }
+
+  function status() {
+    const ok = (b) => (b ? "✓" : "✗");
+    const env = readEnvFile();
+    const installed = installedVersion();
+    const latest = latestVersion();
+    const pid = servicePid();
+    const url = env.GOOSETOOLS_URL ?? DEFAULT_URL;
+
+    console.log(`\nGoose Tools ${cfg.name.toLowerCase()} — status\n`);
+    console.log(`  ${ok(installed)} Installed        ${installed ?? "not installed"}`);
+    const cmp = installed && latest ? compareVersions(installed, latest) : 0;
+    const stale = cmp < 0;
+    if (latest) {
+      // Ahead of npm means a local dev install — say so rather than telling
+      // the user to "update" to something older than what they're running.
+      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 (shared)" : "no — run install --token gt_…"}`,
+    );
+    for (const line of cfg.statusLines?.() ?? []) console.log(line);
+    console.log(`  · Server           ${url}`);
+    console.log(`  · Logs             ${LOG_FILE}`);
+
+    const errors = tail(ERR_FILE, 15);
+    if (errors) {
+      console.log(`\nErrors (last written ${lastWritten(ERR_FILE)}):\n${errors.replace(/^/gm, "  ")}`);
+    }
+    const log = tail(LOG_FILE, 15);
+    if (log) {
+      console.log(`\nActivity (last written ${lastWritten(LOG_FILE)}):\n${log.replace(/^/gm, "  ")}`);
+    }
+
+    if (stale) {
+      console.log(`\nTo update:  npx --yes ${cfg.pkg}@latest update\n`);
+    } else if (!pid && installed) {
+      console.log(`\nNot running. Restart it with:  npx --yes ${cfg.pkg}@latest update\n`);
+    } else {
+      console.log("");
+    }
+  }
+
+  return { install, uninstall, update, status };
+}
+
+// A checkout (development) rather than an npm install. Inside the goosetools
+// repo the worker's folder has no .git of its own, so look for the sync
+// script next to it — that file is never published.
+function isCheckout(root) {
+  return existsSync(join(root, ".git")) || existsSync(join(root, "..", "sync-shared.mjs"));
+}

package/worker/service.js

@@ -1,395 +1,40 @@
-// Background-service install/uninstall for the Goose Tools worker.
-// `install` makes the worker persistent: token saved to ~/.goosetools/env,
-// a stable copy of this package installed under ~/.goosetools/app, and a
-// login service registered (launchd LaunchAgent on macOS, a logon Scheduled
-// Task on Windows) so the worker runs whenever the computer is on — no
-// terminal window needed.
-//
-// `update` re-runs that install against the newest code, reusing the saved
-// token; `status` reports what's actually running, for debugging.
+// Background service for the carousel worker. The install/update/status logic
+// is shared (worker/service-core.js, synced from workers/shared/); this file is
+// only what's specific to carousels: the optional ffmpeg for video slides.
+// Labels and paths must never change — see service-core.js. (This was the
+// first worker, which is why its names are the generic "worker"/"app".)
 
-import { execSync } from "node:child_process";
-import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
 import { FFMPEG_INSTALL_CMD } from "../src/video.js";
+import { createService, quietSh } from "./service-core.js";
 
-export const GOOSE_DIR = join(homedir(), ".goosetools");
-const ENV_FILE = join(GOOSE_DIR, "env");
-const APP_PREFIX = join(GOOSE_DIR, "app");
-const INSTALLED_CLI = join(APP_PREFIX, "node_modules", "goosetools-worker", "worker", "cli.js");
-
-const MAC_LABEL = "com.goosetools.worker";
-const MAC_PLIST = join(homedir(), "Library", "LaunchAgents", `${MAC_LABEL}.plist`);
-const WIN_TASK = "GooseTools Worker";
-const WIN_VBS = join(GOOSE_DIR, "run-worker.vbs");
-
-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;
-  }
-}
-
-// Sync probe — the CLI's install/status paths are synchronous, and this is
-// only ever two cheap `-version` calls.
+// Only ever two cheap `-version` calls.
 function hasFfmpeg() {
   return quietSh("ffmpeg -version") && quietSh("ffprobe -version");
 }
 
-function npmGlobalBin() {
-  try {
-    const prefix = sh("npm prefix -g", { shell: true });
-    return process.platform === "win32" ? prefix : join(prefix, "bin");
-  } catch {
-    return "";
-  }
-}
-
-function servicePath() {
-  // Everything the daemon needs to find: node itself, the npm-global bin
-  // (where `claude` lives), plus the usual suspects.
-  const parts = [
-    dirname(process.execPath),
-    npmGlobalBin(),
-    ...(process.platform === "win32"
-      ? [process.env.PATH ?? ""]
-      : [
-          "/opt/homebrew/bin",
-          "/usr/local/bin",
-          `${process.env.HOME ?? ""}/.local/bin`,
-          "/usr/bin",
-          "/bin",
-          "/usr/sbin",
-          "/sbin",
-        ]),
-  ].filter(Boolean);
-  return [...new Set(parts)].join(process.platform === "win32" ? ";" : ":");
-}
-
-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 minute)…");
-  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}"` : "goosetools-worker@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>RunAtLoad</key>
-    <true/>
-    <key>KeepAlive</key>
-    <true/>
-    <key>ThrottleInterval</key>
-    <integer>30</integer>
-    <key>StandardOutPath</key>
-    <string>${esc(join(GOOSE_DIR, "worker.log"))}</string>
-    <key>StandardErrorPath</key>
-    <string>${esc(join(GOOSE_DIR, "worker.err.log"))}</string>
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key>
-        <string>${esc(servicePath())}</string>
-    </dict>
-</dict>
-</plist>
-`;
-}
-
-function macInstall() {
-  mkdirSync(dirname(MAC_PLIST), { recursive: true });
-  writeFileSync(MAC_PLIST, macPlist());
-  const uid = process.getuid();
-  // Re-registering: tear down any previous copy first, then bootstrap.
-  quietSh(`launchctl bootout gui/${uid}/${MAC_LABEL}`);
-  if (!quietSh(`launchctl bootstrap gui/${uid} "${MAC_PLIST}"`)) {
-    // Older macOS fallback.
-    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 });
-}
-
-// ── Windows (Scheduled Task at logon, hidden window) ─────────────────────────
-
-function winInstall() {
-  // wscript launches the worker with no console window.
-  const vbs = `CreateObject("WScript.Shell").Run """${process.execPath}"" ""${INSTALLED_CLI}"" run", 0, False\r\n`;
-  writeFileSync(WIN_VBS, vbs);
-  quietSh(`schtasks /End /TN "${WIN_TASK}"`);
-  quietSh(`schtasks /Delete /F /TN "${WIN_TASK}"`);
-  execSync(`schtasks /Create /F /SC ONLOGON /TN "${WIN_TASK}" /TR "wscript.exe \\"${WIN_VBS}\\""`, {
-    stdio: "ignore",
-    shell: true,
-  });
-  execSync(`schtasks /Run /TN "${WIN_TASK}"`, { stdio: "ignore", shell: true });
-}
-
-function winUninstall() {
-  quietSh(`schtasks /End /TN "${WIN_TASK}"`);
-  quietSh(`schtasks /Delete /F /TN "${WIN_TASK}"`);
-  rmSync(WIN_VBS, { force: true });
-}
-
-// ── Public commands ──────────────────────────────────────────────────────────
-
-export function install({ url, token, root }) {
-  if (!token) {
-    console.error("Missing worker token. Run: goosetools-worker install --url " + url + " --token gt_…");
-    process.exit(1);
-  }
-  writeEnvFile({ url, token });
-  installStableCopy(root);
-  if (process.platform === "darwin") macInstall();
-  else if (process.platform === "win32") winInstall();
-  else {
-    console.error(
-      "Automatic background setup isn't available on this OS yet.\n" +
-        "Run the worker directly instead:  goosetools-worker run",
-    );
-    process.exit(1);
-  }
-  console.log(
-    "\n✓ All set! Your computer now connects to Goose Tools by itself —\n" +
-      "  in the background, whenever it's on, even after a restart.\n" +
-      "  You can close this window.\n\n" +
-      `  Logs:      ${join(GOOSE_DIR, "worker.log")}\n` +
-      "  Turn off:  npx --yes goosetools-worker uninstall\n",
-  );
+export const { install, uninstall, update, status } = createService({
+  pkg: "goosetools-worker",
+  name: "Carousel worker",
+  appDir: "app",
+  macLabel: "com.goosetools.worker",
+  winTask: "GooseTools Worker",
+  winVbs: "run-worker.vbs",
+  logName: "worker",
+  dashboard: "/dashboard/carousel",
+  doing: "makes your carousels",
   // Optional, and only worth a mention once the required setup has succeeded:
   // photo carousels are already fully working at this point.
-  if (!hasFfmpeg()) {
-    console.log(
-      "  Optional — want video slides?\n" +
+  afterInstall: () =>
+    hasFfmpeg()
+      ? undefined
+      : "  Optional — want video slides?\n" +
         "  Carousels made from photos work right now. To also put video clips\n" +
         "  in a carousel, install ffmpeg (one time, a couple of minutes):\n\n" +
         `      ${FFMPEG_INSTALL_CMD}\n`,
-    );
-  }
-}
-
-// Removes THIS worker, not the whole ~/.goosetools directory. It used to take
-// the directory, which was harmless while everything in there was either this
-// worker's or re-derivable from the server — and stopped being harmless when
-// the Overlay Factory started keeping its puzzle library, learned looks and
-// used-card record in ~/.goosetools/overlay. Nothing else has a copy of those,
-// and `npx goosetools uninstall` runs this. The shared token file stays: the
-// other workers are still using it.
-export function uninstall() {
-  if (process.platform === "darwin") macUninstall();
-  else if (process.platform === "win32") winUninstall();
-  rmSync(APP_PREFIX, { recursive: true, force: true });
-  rmSync(join(GOOSE_DIR, "worker.log"), { force: true });
-  rmSync(join(GOOSE_DIR, "worker.err.log"), { force: true });
-  console.log("✓ Carousel worker removed. This computer no longer makes carousels.");
-}
-
-// ── update ───────────────────────────────────────────────────────────────────
-// The daemon runs the COPY under ~/.goosetools/app, not wherever you ran this
-// from — so new code only reaches it by reinstalling that copy. Re-registering
-// the service also restarts it, which is what actually loads the new code
-// (Node reads every module once, at startup).
-export function update({ root }) {
-  const saved = readEnvFile();
-  if (!saved.WORKER_TOKEN) {
-    console.error(
-      "No saved worker token — this computer hasn't been connected yet.\n" +
-        "Get a token at https://goosetools.com/dashboard/carousel and run:\n" +
-        "  npx --yes goosetools-worker@latest install --token gt_…",
-    );
-    process.exit(1);
-  }
-  const before = installedVersion();
-  installStableCopy(root);
-  if (process.platform === "darwin") macInstall();
-  else if (process.platform === "win32") winInstall();
-  else {
-    console.error("Automatic background setup isn't available on this OS yet.");
-    process.exit(1);
-  }
-  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 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()]),
-  );
-}
-
-function installedVersion() {
-  try {
-    const pkg = join(APP_PREFIX, "node_modules", "goosetools-worker", "package.json");
-    return JSON.parse(readFileSync(pkg, "utf8")).version ?? null;
-  } catch {
-    return null;
-  }
-}
-
-function latestVersion() {
-  try {
-    return sh("npm view goosetools-worker version", { shell: true, timeout: 15000 });
-  } catch {
-    return null; // offline, or npm unreachable — not an error worth failing on
-  }
-}
-
-// -1 / 0 / 1, comparing x.y.z numerically. Anything unparseable sorts equal so
-// an odd version string never nags the user to "update" in a loop.
-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 {
-    if (process.platform === "darwin") {
-      const line = sh(`launchctl list | grep ${MAC_LABEL}`, { shell: true });
-      const pid = line.split(/\s+/)[0];
-      return pid === "-" ? null : pid;
-    }
-    const out = sh(`schtasks /Query /TN "${WIN_TASK}" /FO LIST`, { shell: true });
-    return /Running/i.test(out) ? "running" : null;
-  } 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 ms = Date.now() - statSync(file).mtimeMs;
-    const mins = Math.round(ms / 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";
-
-  console.log("\nGoose Tools worker — status\n");
-  console.log(`  ${ok(installed)} Installed        ${installed ?? "not installed"}`);
-  // Ahead of npm means a local dev install — say so rather than telling the
-  // user to "update" to something older than what they're running.
-  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 — run install --token gt_…"}`);
   // Not an "✗": a worker without ffmpeg is healthy, it just can't do video.
-  console.log(
+  statusLines: () => [
     `  ${hasFfmpeg() ? "✓" : "·"} Video slides     ${
       hasFfmpeg() ? "yes (ffmpeg found)" : `photos only — for video: ${FFMPEG_INSTALL_CMD}`
     }`,
-  );
-  console.log(`  · Server           ${url}`);
-  console.log(`  · Logs             ${join(GOOSE_DIR, "worker.log")}`);
-
-  const errFile = join(GOOSE_DIR, "worker.err.log");
-  const errors = tail(errFile, 15);
-  if (errors) {
-    console.log(`\nErrors (last written ${lastWritten(errFile)}):\n${errors.replace(/^/gm, "  ")}`);
-  }
-  const logFile = join(GOOSE_DIR, "worker.log");
-  const log = tail(logFile, 15);
-  if (log) {
-    console.log(`\nActivity (last written ${lastWritten(logFile)}):\n${log.replace(/^/gm, "  ")}`);
-  }
-
-  if (stale) {
-    console.log("\nTo update:  npx --yes goosetools-worker@latest update\n");
-  } else if (!pid && installed) {
-    console.log("\nNot running. Restart it with:  npx --yes goosetools-worker@latest update\n");
-  } else {
-    console.log("");
-  }
-}
+  ],
+});

package/worker/style.js

@@ -15,7 +15,7 @@ import {
 } from "node:fs";
 import { extname, join } from "node:path";
 import yaml from "js-yaml";
-import { upload } from "@vercel/blob/client";
+import { upload } from "./upload.js";
 import { skillSection } from "./skill.js";
 
 const RESERVED_SLUGS = new Set(["graph-paper", "polka-dot"]);

package/worker/upload.js

@@ -0,0 +1,27 @@
+// Worker-side upload, same signature as `upload` from "@vercel/blob/client":
+//
+//   const blob = await upload(pathname, bytes, {
+//     handleUploadUrl, clientPayload, contentType,
+//   });
+//   blob.url
+//
+// Goose Tools moved file storage to Cloudflare R2. The upload route still
+// decides who may write where (worker token in clientPayload), but instead
+// of a Blob token it hands back a signed PUT URL; the bytes go straight to
+// the bucket.
+
+export async function upload(pathname, bytes, opts) {
+  const contentType = opts.contentType ?? "application/octet-stream";
+  const res = await fetch(opts.handleUploadUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ pathname, contentType, size: bytes.length ?? bytes.byteLength ?? 0, clientPayload: opts.clientPayload ?? null }),
+  });
+  const grant = await res.json().catch(() => ({}));
+  if (!res.ok || !grant.uploadUrl || !grant.url) {
+    throw new Error(grant.error ?? `upload not allowed (${res.status})`);
+  }
+  const put = await fetch(grant.uploadUrl, { method: "PUT", headers: { "content-type": contentType }, body: bytes });
+  if (!put.ok) throw new Error(`upload PUT failed (${put.status})`);
+  return { url: grant.url, pathname: grant.pathname ?? pathname, contentType };
+}