whoburnedmore 0.8.9 → 0.9.1

package/dist/index.js

@@ -21,12 +21,17 @@ function parseBoard(args) {
 function parseOrg(args) {
   return parseValueFlag(args, "--org");
 }
+function parsePass(args) {
+  return parseValueFlag(args, "--pass") ?? parseValueFlag(args, "--code");
+}
 function parseInstallToken(args) {
   return parseValueFlag(args, "--token");
 }
 function applyScope(payload, flags) {
   if (flags.board) payload.board = flags.board;
   if (flags.org) payload.org = flags.org;
+  if (flags.org && flags.orgCode)
+    payload.orgCode = flags.orgCode;
   return payload;
 }
 function parseValueFlag(args, name) {
@@ -46,7 +51,7 @@ function resolveCommand(args) {
   if (args.includes("--version") || args.includes("-v") || args.includes("version")) {
     return "version";
   }
-  const valueFlags = /* @__PURE__ */ new Set(["--board", "--org", "--token"]);
+  const valueFlags = /* @__PURE__ */ new Set(["--board", "--org", "--token", "--pass", "--code"]);
   for (let i = 0; i < args.length; i++) {
     const a = args[i];
     if (a.startsWith("-")) {
@@ -121,6 +126,11 @@ function claimUrl(dashboardUrl, anonKey) {
 function boardClaimUrl(boardUrl, slug, anonKey) {
   return `${boardUrl}#k=${encodeURIComponent(anonKey)}&u=${encodeURIComponent(slug)}`;
 }
+function resolveOpenTarget(result, anonKey) {
+  const baseUrl = result.orgBoardUrl ?? result.boardUrl ?? result.dashboardUrl;
+  const target = result.orgBoardUrl ? boardClaimUrl(result.orgBoardUrl, result.slug, anonKey) : result.boardUrl ? boardClaimUrl(result.boardUrl, result.slug, anonKey) : claimUrl(result.dashboardUrl, anonKey);
+  return { baseUrl, target };
+}
 async function anonVisibility(anonKey, listed) {
   const { status, body } = await post(
     "/v1/anon/visibility",
@@ -357,16 +367,13 @@ function installAutoSync() {
     return `launchd agent installed (${plistPath}), syncing every ${syncIntervalLabel()}`;
   }
   if (os === "linux") {
-    const line = expectedLinuxCronLine();
-    const current = spawnSync("crontab", ["-l"], { encoding: "utf8" });
-    const existing = current.status === 0 ? current.stdout : "";
-    const kept = existing.split("\n").filter((l) => !l.includes("whoburnedmore")).join("\n");
-    const next = `${kept.trimEnd()}
-${line}
-`.replace(/^\n+/, "");
-    const res = spawnSync("crontab", ["-"], { input: next });
-    if (res.status !== 0) throw new Error("could not install crontab entry");
-    return `cron entry installed, syncing every ${syncIntervalLabel()}`;
+    const viaCron = tryInstallCron();
+    if (viaCron) return viaCron;
+    const viaSystemd = tryInstallSystemd();
+    if (viaSystemd) return viaSystemd;
+    throw new Error(
+      "could not install background sync: no usable crontab or systemd user timer. Run `whoburnedmore daemon` under your process manager (systemd service, Docker CMD, pm2 or nohup) to keep syncing."
+    );
   }
   if (os === "win32") {
     const res = spawnSync("schtasks", [
@@ -393,6 +400,90 @@ function expectedLinuxCronLine(opts) {
   const command = syncCommandArgs(opts?.npmPath).map(shellQuote).join(" ");
   return `${cronSchedule()} ${command} >${shellQuote(opts?.logPath ?? syncLogPath())} 2>&1`;
 }
+var SYSTEMD_UNIT = "whoburnedmore-sync";
+function systemdUserDir() {
+  const base = process.env.XDG_CONFIG_HOME?.trim() || join2(homedir2(), ".config");
+  return join2(base, "systemd", "user");
+}
+function systemdServicePath() {
+  return join2(systemdUserDir(), `${SYSTEMD_UNIT}.service`);
+}
+function systemdTimerPath() {
+  return join2(systemdUserDir(), `${SYSTEMD_UNIT}.timer`);
+}
+function systemdQuote(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+function buildSystemdService(commandArgs = syncCommandArgs()) {
+  const execStart = commandArgs.map(systemdQuote).join(" ");
+  return `[Unit]
+Description=whoburnedmore background token-usage sync
+
+[Service]
+Type=oneshot
+ExecStart=${execStart}
+`;
+}
+function buildSystemdTimer(mins = SYNC_INTERVAL_MINUTES) {
+  return `[Unit]
+Description=whoburnedmore background token-usage sync timer
+
+[Timer]
+OnBootSec=1min
+OnUnitActiveSec=${mins}min
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+}
+function binaryExists(cmd, probeArgs = ["--version"]) {
+  const res = spawnSync(cmd, probeArgs, { stdio: "ignore" });
+  return !res.error;
+}
+function linuxSyncMechanism() {
+  const cron = spawnSync("crontab", ["-l"], { encoding: "utf8" });
+  if (!cron.error && cron.status === 0 && cron.stdout.includes("whoburnedmore")) {
+    return "cron";
+  }
+  if (existsSync2(systemdTimerPath())) return "systemd";
+  return "none";
+}
+function tryInstallCron() {
+  if (!binaryExists("crontab", ["-l"])) return null;
+  const line = expectedLinuxCronLine();
+  const current = spawnSync("crontab", ["-l"], { encoding: "utf8" });
+  const existing = current.status === 0 ? current.stdout : "";
+  const kept = existing.split("\n").filter((l) => !l.includes("whoburnedmore")).join("\n");
+  const next = `${kept.trimEnd()}
+${line}
+`.replace(/^\n+/, "");
+  const res = spawnSync("crontab", ["-"], { input: next });
+  if (res.status !== 0) return null;
+  return `cron entry installed, syncing every ${syncIntervalLabel()}`;
+}
+function tryInstallSystemd() {
+  if (!binaryExists("systemctl", ["--user", "--version"])) return null;
+  try {
+    mkdirSync2(systemdUserDir(), { recursive: true });
+    writeFileSync2(systemdServicePath(), buildSystemdService());
+    writeFileSync2(systemdTimerPath(), buildSystemdTimer());
+  } catch {
+    return null;
+  }
+  spawnSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+  const res = spawnSync(
+    "systemctl",
+    ["--user", "enable", "--now", `${SYSTEMD_UNIT}.timer`],
+    { stdio: "ignore" }
+  );
+  if (res.status !== 0) {
+    rmSync(systemdServicePath(), { force: true });
+    rmSync(systemdTimerPath(), { force: true });
+    return null;
+  }
+  return `systemd user timer installed, syncing every ${syncIntervalLabel()} (run \`loginctl enable-linger\` to keep syncing while logged out)`;
+}
 function uninstallAutoSync() {
   const os = platform();
   if (os === "darwin") {
@@ -404,12 +495,25 @@ function uninstallAutoSync() {
     return "launchd agent removed";
   }
   if (os === "linux") {
+    let removed = false;
     const current = spawnSync("crontab", ["-l"], { encoding: "utf8" });
-    if (current.status === 0 && current.stdout.includes("whoburnedmore")) {
+    if (!current.error && current.status === 0 && current.stdout.includes("whoburnedmore")) {
       const next = current.stdout.split("\n").filter((l) => !l.includes("whoburnedmore")).join("\n");
       spawnSync("crontab", ["-"], { input: next });
+      removed = true;
+    }
+    if (existsSync2(systemdTimerPath())) {
+      spawnSync(
+        "systemctl",
+        ["--user", "disable", "--now", `${SYSTEMD_UNIT}.timer`],
+        { stdio: "ignore" }
+      );
+      rmSync(systemdServicePath(), { force: true });
+      rmSync(systemdTimerPath(), { force: true });
+      spawnSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+      removed = true;
     }
-    return "cron entry removed";
+    return removed ? "background sync removed" : "nothing to remove";
   }
   if (os === "win32") {
     spawnSync("schtasks", ["/Delete", "/F", "/TN", "whoburnedmore-sync"]);
@@ -420,8 +524,7 @@ function uninstallAutoSync() {
 function autoSyncInstalled() {
   if (platform() === "darwin") return existsSync2(launchAgentPath());
   if (platform() === "linux") {
-    const current = spawnSync("crontab", ["-l"], { encoding: "utf8" });
-    return current.status === 0 && current.stdout.includes("whoburnedmore");
+    return linuxSyncMechanism() !== "none";
   }
   if (platform() === "win32") {
     const res = spawnSync("schtasks", ["/Query", "/TN", "whoburnedmore-sync"], {
@@ -431,22 +534,40 @@ function autoSyncInstalled() {
   }
   return false;
 }
+function readInstalledSystemd() {
+  try {
+    return `${readFileSync2(systemdServicePath(), "utf8")}
+${readFileSync2(systemdTimerPath(), "utf8")}`;
+  } catch {
+    return null;
+  }
+}
+function expectedSystemd() {
+  return `${buildSystemdService()}
+${buildSystemdTimer()}`;
+}
 function readInstalledAgent() {
   if (platform() === "darwin") {
     const p = launchAgentPath();
     return existsSync2(p) ? readFileSync2(p, "utf8") : null;
   }
   if (platform() === "linux") {
-    const current = spawnSync("crontab", ["-l"], { encoding: "utf8" });
-    if (current.status !== 0) return null;
-    const line = current.stdout.split("\n").find((l) => l.includes("whoburnedmore"));
-    return line ?? null;
+    const mech = linuxSyncMechanism();
+    if (mech === "cron") {
+      const current = spawnSync("crontab", ["-l"], { encoding: "utf8" });
+      if (current.error || current.status !== 0) return null;
+      return current.stdout.split("\n").find((l) => l.includes("whoburnedmore")) ?? null;
+    }
+    if (mech === "systemd") return readInstalledSystemd();
+    return null;
   }
   return null;
 }
 function expectedAgent() {
   if (platform() === "darwin") return expectedDarwinPlist();
-  if (platform() === "linux") return expectedLinuxCronLine();
+  if (platform() === "linux") {
+    return linuxSyncMechanism() === "systemd" ? expectedSystemd() : expectedLinuxCronLine();
+  }
   return null;
 }
 function autoSyncDrift() {
@@ -531,6 +652,24 @@ function printBanner() {
   console.log();
 }
 
+// src/daemon.ts
+async function daemonLoop(deps) {
+  let cycles = 0;
+  while (!deps.isStopped()) {
+    cycles++;
+    try {
+      await deps.runOnce();
+      deps.log("synced");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      deps.log(`sync failed: ${message} \u2014 retrying next cycle`);
+    }
+    if (deps.isStopped()) break;
+    await deps.wait(deps.intervalMs);
+  }
+  return cycles;
+}
+
 // src/collect.ts
 import { execFile } from "node:child_process";
 import { createRequire as createRequire3 } from "node:module";
@@ -5691,7 +5830,14 @@ var SubmitPayload = external_exports.object({
   /** Optional friends-board code (from `--board=<code>`): auto-join this board on submit. */
   board: external_exports.string().min(1).max(32).optional(),
   /** Optional organization slug (from `--org=<slug>`): auto-join this org on submit. */
-  org: external_exports.string().min(2).max(32).optional()
+  org: external_exports.string().min(2).max(32).optional(),
+  /**
+   * Optional org join password (from `--pass=<code>` / `--code=<code>`): required
+   * to attach a CLI run to an `org`. Back-compat: omittable — a run with no org
+   * never needs it, and a wrong/missing code only skips the org attach (the
+   * personal submit still succeeds).
+   */
+  orgCode: external_exports.string().min(1).max(64).optional()
 });
 var AnonSubmitPayload = SubmitPayload.extend({
   /** Client-generated secret (hex). The server stores only its hash. */
@@ -5740,13 +5886,15 @@ var RESERVED_SLUGS = /* @__PURE__ */ new Set([
 ]);
 var SLUG_RE = /^[a-z0-9](?:[a-z0-9-]{0,30}[a-z0-9])?$/;
 function isValidSlug(slug) {
-  return typeof slug === "string" && slug.length >= 2 && slug.length <= 32 && SLUG_RE.test(slug) && !RESERVED_SLUGS.has(slug);
+  return typeof slug === "string" && slug.length >= 2 && slug.length <= 32 && SLUG_RE.test(slug) && // Reject consecutive hyphens — the regex above permits "a--b", which makes
+  // for confusing subdomains and is never a deliberate slug.
+  !slug.includes("--") && !RESERVED_SLUGS.has(slug);
 }
 var OrgSlug = external_exports.string().min(2).max(32).refine(isValidSlug, "invalid or reserved slug");
 var OrgWindow = external_exports.object({
   startDate: DateString.nullable().optional(),
   endDate: DateString.nullable().optional()
-});
+}).refine((w) => !(w.startDate && w.endDate) || w.endDate >= w.startDate, { message: "endDate must be on or after startDate", path: ["endDate"] });
 var OrgJoinPolicy = external_exports.object({
   allowCodeJoin: external_exports.boolean().default(true),
   allowDomainJoin: external_exports.boolean().default(false),
@@ -6205,8 +6353,7 @@ async function run(flags) {
     }
   } catch {
   }
-  const baseUrl = result.boardUrl ?? result.dashboardUrl;
-  const target = result.boardUrl ? boardClaimUrl(result.boardUrl, result.slug, anonKey) : claimUrl(result.dashboardUrl, anonKey);
+  const { baseUrl, target } = resolveOpenTarget(result, anonKey);
   const trusted = isTrustedWebUrl(baseUrl);
   if (!flags.quiet) {
     console.log(
@@ -6274,6 +6421,53 @@ async function linkServerInstall(token) {
   }
   console.log(`  Profile: ${linked.profileUrl}`);
 }
+function waitOrAbort(ms, signal) {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function runDaemon() {
+  ensureAnonKey();
+  const controller = new AbortController();
+  const onSignal = () => controller.abort();
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  console.log(pc2.bold("  whoburnedmore daemon"));
+  console.log(
+    pc2.dim(
+      `  Syncing in the foreground every ${syncIntervalLabel()} \u2014 run this under systemd, a Docker CMD, pm2 or nohup to keep a server on the leaderboard. Ctrl-C to stop.`
+    )
+  );
+  if (!process.env.WHOBURNEDMORE_CONFIG_DIR) {
+    console.log(
+      pc2.dim(
+        "  Tip: set WHOBURNEDMORE_CONFIG_DIR to a persistent path so this machine's identity survives container/VM restarts."
+      )
+    );
+  }
+  console.log();
+  const cycles = await daemonLoop({
+    intervalMs: SYNC_INTERVAL_MINUTES * 6e4,
+    isStopped: () => controller.signal.aborted,
+    log: (line) => console.log(`  ${pc2.dim((/* @__PURE__ */ new Date()).toISOString())}  ${line}`),
+    wait: (ms) => waitOrAbort(ms, controller.signal),
+    runOnce: async () => {
+      rotateLogIfLarge();
+      await run({ dryRun: false, noSubmit: false, local: false, quiet: true });
+    }
+  });
+  console.log();
+  console.log(pc2.dim(`  Daemon stopped after ${cycles} sync cycle${cycles === 1 ? "" : "s"}.`));
+}
 async function main() {
   const major = Number(process.versions.node.split(".")[0]);
   if (major < 20) {
@@ -6282,14 +6476,16 @@ async function main() {
     return;
   }
   const args = process.argv.slice(2);
-  const command = resolveCommand(args);
+  const baseCommand = resolveCommand(args);
+  const command = args.includes("--watch") && (baseCommand === "run" || baseCommand === "sync") ? "daemon" : baseCommand;
   const flags = {
     dryRun: args.includes("--dry-run"),
     noSubmit: args.includes("--no-submit"),
     local: args.includes("--local"),
     quiet: command === "sync",
     board: parseBoard(args),
-    org: parseOrg(args)
+    org: parseOrg(args),
+    orgCode: parsePass(args)
   };
   switch (command) {
     case "run":
@@ -6304,6 +6500,9 @@ async function main() {
     case "link":
       await linkServerInstall(parseInstallToken(args));
       break;
+    case "daemon":
+      await runDaemon();
+      break;
     case "status":
     case "doctor": {
       for (const line of agentStatusReport()) console.log(line);
@@ -6361,7 +6560,8 @@ function printHelp() {
     npx whoburnedmore --local      build the dashboard on your machine and open it (offline)
     npx whoburnedmore --dry-run    print exactly what would be sent, send nothing
     npx whoburnedmore --no-submit  collect locally, send nothing (no dashboard)
-    npx whoburnedmore link --token=TOKEN  link this server to your signed-in account
+    npx whoburnedmore link --token=TOKEN  link this server/VM to your signed-in account
+    npx whoburnedmore daemon       keep syncing in the foreground (VMs/containers with no cron)
     npx whoburnedmore private      hide your dashboard from the leaderboard
     npx whoburnedmore public       put it back on the leaderboard
     npx whoburnedmore remove       delete your dashboard and its data
@@ -6376,6 +6576,14 @@ function printHelp() {
   daily aggregate numbers (date, tool, model, token counts, est. cost) ever leave
   your machine \u2014 never prompts, code, or file names. With --local, nothing leaves
   your machine at all.
+
+  ${pc2.bold("servers & VMs")}
+    Generate a one-time \`link\` command from your profile on whoburnedmore.com and
+    run it inside the VM to bind that machine to your account. On a persistent VM
+    background sync uses cron or a systemd user timer automatically; in a container
+    or any host without a scheduler, run \`whoburnedmore daemon\` under your process
+    manager instead. Set WHOBURNEDMORE_CONFIG_DIR to a persistent path so the
+    machine identity survives restarts. See docs/SERVER-VM-SETUP.md.
 `);
 }
 main().catch((err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whoburnedmore",
-  "version": "0.8.9",
+  "version": "0.9.1",
   "description": "Find out who burned more — submit your AI coding-agent token usage to the public leaderboard at whoburnedmore.com",
   "type": "module",
   "bin": {