hacklab 26.921.4 → 26.922.7

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import { parseArgs } from "node:util";
 // package.json
-var version = "26.921.4";
+var version = "26.922.7";
 
 // src/auth.ts
 import { spawn } from "node:child_process";
@@ -123,19 +123,71 @@ Waiting for you to connect your account…`);
   throw new Error("CLI sign-in expired. Run the command again to retry.");
 }
 
-// src/origin.ts
-function cliOrigin() {
-  return "https://beta.hacklab.so";
-}
+// src/daemon.ts
+import { spawn as spawn3 } from "node:child_process";
+import { once as once2 } from "node:events";
+import { realpathSync } from "node:fs";
+import { mkdir as mkdir3, readFile as readFile3, rm as rm3, stat, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+import { text as text2 } from "node:stream/consumers";
 
 // src/sync.ts
 import { spawn as spawn2 } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
 import { once } from "node:events";
 import { createRequire } from "node:module";
 import { text } from "node:stream/consumers";
-async function collectUsage() {
+
+// src/origin.ts
+function cliOrigin() {
+  return "https://beta.hacklab.so";
+}
+
+// src/state.ts
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir2, readFile as readFile2, rename as rename2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+var stateDirectory = join2(homedir2(), ".config", "hacklab", "state");
+function statePath(origin, directory) {
+  return join2(directory, `${createHash2("sha256").update(origin).digest("hex")}.json`);
+}
+async function readState(origin, directory = stateDirectory) {
+  try {
+    const value = JSON.parse(await readFile2(statePath(origin, directory), "utf8"));
+    return value && typeof value === "object" ? value : {};
+  } catch {
+    return {};
+  }
+}
+async function writeState(origin, state, directory = stateDirectory) {
+  await mkdir2(directory, { recursive: true, mode: 448 });
+  const path = statePath(origin, directory);
+  const temporary = `${path}.${randomUUID2()}.tmp`;
+  try {
+    await writeFile2(temporary, JSON.stringify(state), { mode: 384, flag: "wx" });
+    await rename2(temporary, path);
+  } finally {
+    await rm2(temporary, { force: true });
+  }
+}
+
+// src/sync.ts
+var dayMs = 24 * 60 * 60 * 1000;
+var sinceWindowDays = 2;
+var defaultIntervalSeconds = 15 * 60;
+function sinceDate(from) {
+  const date = new Date(from - sinceWindowDays * dayMs);
+  const local = new Date(date.getTime() - date.getTimezoneOffset() * 60000);
+  return local.toISOString().slice(0, 10);
+}
+async function collectUsage(since) {
   const require2 = createRequire(import.meta.url);
-  const child = spawn2(process.execPath, [require2.resolve("ccusage/src/cli.js"), "session", "--json"], { stdio: ["ignore", "pipe", "inherit"] });
+  const args = [require2.resolve("ccusage/src/cli.js"), "session", "--json"];
+  if (since)
+    args.push("--since", since);
+  const child = spawn2(process.execPath, args, { stdio: ["ignore", "pipe", "inherit"] });
   const [body, [exitCode]] = await Promise.all([text(child.stdout), once(child, "close")]);
   if (exitCode !== 0)
     throw new Error(`ccusage failed (exit ${exitCode}). Nothing synced.`);
@@ -152,7 +204,24 @@ async function collectUsage() {
     throw new Error("Usage report exceeds 20 MB. Nothing synced.");
   return body;
 }
-async function uploadUsage(origin, token, body) {
+var plural = (count, noun) => `${count} ${noun}${count === 1 ? "" : "s"}`;
+function describeIssues(result) {
+  const parts = [
+    result.error,
+    ...(result.issues ?? []).map((i) => `session ${i.index} — ${i.reason}`)
+  ];
+  const detail = parts.filter(Boolean).join(" ");
+  return detail && !detail.endsWith(".") ? `${detail}.` : detail;
+}
+async function readResult(response) {
+  try {
+    const result = await response.json();
+    return result && typeof result === "object" ? result : {};
+  } catch {
+    return {};
+  }
+}
+async function uploadUsage(origin, token, body, quiet = false) {
   const response = await fetch(`${origin}/api/token-usage`, {
     method: "POST",
     headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
@@ -160,60 +229,320 @@ async function uploadUsage(origin, token, body) {
     redirect: "error",
     signal: AbortSignal.timeout(60000)
   });
-  if (!response.ok)
-    throw new Error(`Hacklab rejected the usage report (HTTP ${response.status}). Run hacklab sync to retry.`);
-  const result = await response.json();
+  const result = await readResult(response);
+  if (!response.ok) {
+    const detail = describeIssues(result);
+    throw new Error(`Hacklab rejected the usage report (HTTP ${response.status}).${detail ? ` ${detail}` : ""} Run hacklab sync to retry.`);
+  }
   if (result.ok !== true)
     throw new Error("Hacklab did not confirm the sync. Run hacklab sync to retry.");
-  console.log(`Synced ${result.sessions} usage sessions to Hacklab.`);
-  if (result.sessions === 0)
-    console.log("No usage found. Use your coding agent, then run hacklab sync again.");
+  if (!quiet) {
+    console.log(`Synced ${plural(result.sessions ?? 0, "usage session")} to Hacklab.`);
+    if (result.duplicates)
+      console.log(`Merged ${plural(result.duplicates, "repeated session")}.`);
+    if (result.skipped)
+      console.log(`Skipped ${plural(result.skipped, "unreadable session")}. ${describeIssues(result)}`.trim());
+    if (result.sessions === 0)
+      console.log("No usage found. Use your coding agent, then run hacklab sync again.");
+  }
+  return result;
+}
+var fingerprint = (body) => createHash3("sha256").update(body).digest("hex");
+function nextInterval(result, current) {
+  const proposed = result.nextSyncSeconds;
+  return typeof proposed === "number" && Number.isFinite(proposed) && proposed >= 60 ? Math.min(Math.trunc(proposed), 24 * 60 * 60) : current;
 }
 async function sync() {
   const origin = cliOrigin();
   const token = await authenticate(origin);
   console.log("Collecting ccusage session data…");
   const body = await collectUsage();
-  await uploadUsage(origin, token, body);
+  const result = await uploadUsage(origin, token, body);
+  const state = await readState(origin);
+  const now = new Date().toISOString();
+  await writeState(origin, {
+    ...state,
+    fingerprint: fingerprint(body),
+    fingerprintSince: "",
+    lastSyncedAt: now,
+    lastFullSyncAt: now,
+    intervalSeconds: nextInterval(result, state.intervalSeconds)
+  });
+}
+async function backgroundSync() {
+  const origin = cliOrigin();
+  const token = await readCredential(origin);
+  if (!token)
+    throw new Error("No saved Hacklab authorization. Run hacklab login to reconnect this machine.");
+  const state = await readState(origin);
+  const now = Date.now();
+  const lastSyncedAt = state.lastSyncedAt ? Date.parse(state.lastSyncedAt) : Number.NaN;
+  const interval = (state.intervalSeconds ?? defaultIntervalSeconds) * 1000;
+  if (Number.isFinite(lastSyncedAt) && now - lastSyncedAt < interval)
+    return "too-soon";
+  const lastFullSyncAt = state.lastFullSyncAt ? Date.parse(state.lastFullSyncAt) : Number.NaN;
+  const full = !Number.isFinite(lastFullSyncAt) || now - lastFullSyncAt >= dayMs;
+  const since = full ? "" : sinceDate(Number.isFinite(lastSyncedAt) ? lastSyncedAt : now);
+  const body = await collectUsage(since || undefined);
+  const current = fingerprint(body);
+  if (!full && since === state.fingerprintSince && current === state.fingerprint) {
+    await writeState(origin, { ...state, lastSyncedAt: new Date(now).toISOString() });
+    return "unchanged";
+  }
+  const result = await uploadUsage(origin, token, body, true);
+  const timestamp = new Date().toISOString();
+  await writeState(origin, {
+    ...state,
+    fingerprint: current,
+    fingerprintSince: since,
+    lastSyncedAt: timestamp,
+    lastFullSyncAt: full ? timestamp : state.lastFullSyncAt,
+    intervalSeconds: nextInterval(result, state.intervalSeconds)
+  });
+  return "synced";
+}
+
+// src/daemon.ts
+var label = "so.hacklab.sync";
+var logPath = join3(homedir3(), ".config", "hacklab", "daemon.log");
+var plistPath = join3(homedir3(), "Library", "LaunchAgents", `${label}.plist`);
+var systemdDirectory = join3(homedir3(), ".config", "systemd", "user");
+var servicePath = join3(systemdDirectory, "hacklab-sync.service");
+var timerPath = join3(systemdDirectory, "hacklab-sync.timer");
+var maxLogBytes = 1024 * 1024;
+var daemonSupported = process.platform === "darwin" || process.platform === "linux";
+
+class DaemonError extends Error {
+}
+async function run(command, args) {
+  const child = spawn3(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+  const [out, err, [code]] = await Promise.all([
+    text2(child.stdout),
+    text2(child.stderr),
+    once2(child, "close").catch(() => [1])
+  ]);
+  return { code: code ?? 1, output: `${out}${err}`.trim() };
+}
+function command() {
+  const entry = process.argv[1];
+  if (!entry)
+    throw new DaemonError("Could not locate the Hacklab CLI on this machine.");
+  return [process.execPath, realpathSync(entry), "sync", "--daemon"];
+}
+var escapeXml = (value) => value.replace(/[<>&'"]/g, (character) => ({ "<": "&lt;", ">": "&gt;", "&": "&amp;", "'": "&apos;", '"': "&quot;" })[character]);
+function plist(seconds) {
+  const args = command().map((value) => `    <string>${escapeXml(value)}</string>`).join(`
+`);
+  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>${escapeXml(label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>StartInterval</key><integer>${seconds}</integer>
+  <key>RunAtLoad</key><false/>
+  <key>ProcessType</key><string>Background</string>
+  <key>LowPriorityIO</key><true/>
+  <key>Nice</key><integer>5</integer>
+  <key>StandardOutPath</key><string>${escapeXml(logPath)}</string>
+  <key>StandardErrorPath</key><string>${escapeXml(logPath)}</string>
+</dict>
+</plist>
+`;
+}
+var units = (seconds) => ({
+  service: `[Unit]
+Description=Hacklab usage sync
+
+[Service]
+Type=oneshot
+Nice=5
+ExecStart=${command().map((value) => JSON.stringify(value)).join(" ")}
+`,
+  timer: `[Unit]
+Description=Hacklab usage sync every ${Math.round(seconds / 60)} minutes
+
+[Timer]
+OnBootSec=2min
+OnUnitActiveSec=${seconds}s
+AccuracySec=1min
+RandomizedDelaySec=60
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`
+});
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installLaunchd(seconds) {
+  await mkdir3(join3(homedir3(), "Library", "LaunchAgents"), { recursive: true });
+  await mkdir3(join3(homedir3(), ".config", "hacklab"), { recursive: true, mode: 448 });
+  await writeFile3(plistPath, plist(seconds), { mode: 420 });
+  const target = `gui/${process.getuid?.() ?? ""}`;
+  await run("launchctl", ["bootout", `${target}/${label}`]);
+  const bootstrap = await run("launchctl", ["bootstrap", target, plistPath]);
+  if (bootstrap.code === 0)
+    return plistPath;
+  const legacy = await run("launchctl", ["load", "-w", plistPath]);
+  if (legacy.code === 0)
+    return plistPath;
+  await rm3(plistPath, { force: true });
+  throw new DaemonError(`launchctl refused the Hacklab launch agent.${bootstrap.output ? ` ${bootstrap.output}` : ""}`);
+}
+async function installSystemd(seconds) {
+  const probe = await run("systemctl", ["--user", "--version"]);
+  if (probe.code !== 0)
+    throw new DaemonError("systemd user services are unavailable on this machine.");
+  await mkdir3(systemdDirectory, { recursive: true });
+  const { service, timer } = units(seconds);
+  await writeFile3(servicePath, service, { mode: 420 });
+  await writeFile3(timerPath, timer, { mode: 420 });
+  await run("systemctl", ["--user", "daemon-reload"]);
+  const enable = await run("systemctl", ["--user", "enable", "--now", "hacklab-sync.timer"]);
+  if (enable.code !== 0) {
+    await rm3(servicePath, { force: true });
+    await rm3(timerPath, { force: true });
+    throw new DaemonError(`systemd refused the Hacklab timer.${enable.output ? ` ${enable.output}` : ""}`);
+  }
+  return timerPath;
+}
+async function installDaemon(seconds = defaultIntervalSeconds) {
+  if (!daemonSupported)
+    throw new DaemonError("Background sync is only available on macOS and Linux.");
+  return process.platform === "darwin" ? installLaunchd(seconds) : installSystemd(seconds);
+}
+async function uninstallDaemon() {
+  if (process.platform === "darwin") {
+    if (!await exists(plistPath))
+      return false;
+    await run("launchctl", ["bootout", `gui/${process.getuid?.() ?? ""}/${label}`]);
+    await run("launchctl", ["unload", "-w", plistPath]);
+    await rm3(plistPath, { force: true });
+    return true;
+  }
+  if (process.platform === "linux") {
+    if (!await exists(timerPath))
+      return false;
+    await run("systemctl", ["--user", "disable", "--now", "hacklab-sync.timer"]);
+    await rm3(timerPath, { force: true });
+    await rm3(servicePath, { force: true });
+    await run("systemctl", ["--user", "daemon-reload"]);
+    return true;
+  }
+  return false;
+}
+var daemonInstalled = () => exists(process.platform === "darwin" ? plistPath : timerPath);
+var daemonPath = () => process.platform === "darwin" ? plistPath : timerPath;
+async function trimLog() {
+  try {
+    const { size } = await stat(logPath);
+    if (size <= maxLogBytes)
+      return;
+    const body = await readFile3(logPath, "utf8");
+    await writeFile3(logPath, body.slice(-maxLogBytes / 2), { mode: 384 });
+  } catch {}
 }
 
 // src/index.ts
 var help = `Hacklab CLI
 
 Usage:
-  hacklab sync       Sign in and upload usage
-  hacklab login      Sign in without uploading
-  hacklab logout     Clear saved authorization
-  hacklab --help     Show help
-  hacklab --version  Show version`;
+  hacklab sync               Sign in, upload usage, and keep this machine in sync
+  hacklab login              Sign in without uploading
+  hacklab logout             Clear saved authorization
+  hacklab daemon status      Show whether background sync is installed
+  hacklab daemon uninstall   Stop syncing in the background
+  hacklab daemon install     Start syncing in the background
+  hacklab --help             Show help
+  hacklab --version          Show version
+`;
+var commands = ["sync", "login", "logout", "daemon"];
+var daemonActions = ["install", "uninstall", "status"];
+async function offerDaemon() {
+  if (process.env.HACKLAB_NO_DAEMON === "1" || !daemonSupported)
+    return;
+  if (await daemonInstalled())
+    return;
+  try {
+    await installDaemon();
+  } catch (error) {
+    console.error(`
+Could not install background sync: ${error instanceof Error ? error.message : "unknown error"}
+Your usage was uploaded. Run hacklab sync again whenever you want to update it.`);
+  }
+}
+async function runDaemonCommand(action) {
+  if (action === "status") {
+    const installed = await daemonInstalled();
+    console.log(installed ? `Background sync is installed at ${daemonPath()}.
+Log: ${logPath}` : "Background sync is not installed. Run hacklab daemon install to start it.");
+    return;
+  }
+  if (action === "uninstall") {
+    console.log(await uninstallDaemon() ? "Background sync removed. Run hacklab sync to upload manually." : "Background sync was not installed.");
+    return;
+  }
+  await installDaemon();
+  console.log(`Background sync installed at ${daemonPath()}. Hacklab updates every 15 minutes.`);
+}
 try {
   const { values, positionals } = parseArgs({
     args: process.argv.slice(2),
     options: {
       help: { type: "boolean", short: "h" },
-      version: { type: "boolean", short: "v" }
+      version: { type: "boolean", short: "v" },
+      daemon: { type: "boolean" }
     },
     allowPositionals: true
   });
-  if (positionals.length > 1 || positionals[0] && !["sync", "login", "logout"].includes(positionals[0])) {
+  const [command, action] = positionals;
+  if (positionals.length > 2 || command && !commands.includes(command)) {
+    throw new Error("Unknown command. Run hacklab --help for usage.");
+  }
+  if (command === "daemon" ? !daemonActions.includes(action ?? "") : positionals.length > 1) {
     throw new Error("Unknown command. Run hacklab --help for usage.");
   }
   if (values.help) {
     console.log(help);
   } else if (values.version) {
     console.log(version);
-  } else if (positionals[0] === "login") {
+  } else if (command === "login") {
     await authenticate(cliOrigin());
     console.log("Signed in to Hacklab. Run hacklab sync to upload usage.");
-  } else if (positionals[0] === "logout") {
+  } else if (command === "logout") {
+    await uninstallDaemon();
     await removeCredential(cliOrigin());
     console.log("Saved CLI authorization cleared. Run hacklab sync to sign in again.");
-  } else if (positionals[0] === "sync") {
+  } else if (command === "daemon") {
+    await runDaemonCommand(action);
+  } else if (command === "sync" && values.daemon) {
+    await trimLog();
+    const outcome = await backgroundSync();
+    if (outcome === "synced")
+      console.log(`${new Date().toISOString()} synced`);
+  } else if (command === "sync") {
     await sync();
+    await offerDaemon();
   } else {
     console.log(help);
   }
 } catch (error) {
-  console.error(error instanceof Error ? error.message : "Could not run Hacklab CLI.");
+  const message = error instanceof Error ? error.message : "Could not run Hacklab CLI.";
+  if (error instanceof DaemonError) {
+    console.error(`${message}
+Run hacklab sync to upload manually.`);
+  } else {
+    console.error(process.argv.includes("--daemon") ? `${new Date().toISOString()} ${message}` : message);
+  }
   process.exitCode = 1;
 }

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "hacklab",
-  "version": "26.921.4",
+  "version": "26.922.7",
   "description": "CLI for syncing coding agent usage to Hacklab",
   "bin": {
-    "hacklab": "./dist/index.js"
+    "hacklab": "dist/index.js"
   },
   "files": [
     "dist"