diggylab 0.1.48 → 0.1.50

package/README.md

@@ -28,6 +28,19 @@ node apps/desktop-agent/dist-cli/cli/cli.js --help
 
 State lives in `~/.diggylab` (`--config <directory>` or `DIGGYLAB_AGENT_DIR` overrides it).
 
+## Update
+
+```bash
+diggylab update
+```
+
+It asks npm for the newest release and upgrades the global install in place; when you are already
+current it says so and changes nothing. `diggylab run` checks once a day in the background and
+prints `A newer version is available: ...` when there is one, and every other command repeats the
+last known notice for free — so an old worker does not go unnoticed. A systemd service needs no
+reinstall — the unit points at npm's symlink, so restart it to switch versions (`systemctl restart
+diggylab`).
+
 ## Publishing the npm package
 
 ```bash
@@ -176,7 +189,7 @@ journalctl -u diggylab -f     # follow the worker log
 
 The unit keeps the same state directory and API origin you are using, restarts the worker if it
 crashes, and starts it on boot. It points at npm's `diggylab` symlink, so upgrading the package is
-enough — no need to reinstall the service. Run it as root (or with `sudo`) to write the unit.
+enough — no need to reinstall the service (`diggylab update`, then `systemctl restart diggylab`). Run it as root (or with `sudo`) to write the unit.
 
 <details>
 <summary>Equivalent unit, if you prefer to write it yourself</summary>

package/cli.js

@@ -421,7 +421,7 @@ function parseFacebookGraphqlBody(body, groupUrl) {
 function toComment(node) {
   const typename = typeof node.__typename === "string" ? node.__typename : void 0;
   const text = firstString(node, commentTextPaths);
-  if (!text || typename && !/comment$/i.test(typename))
+  if (!text || !typename || !/comment$/i.test(typename))
     return void 0;
   const authorName = firstString(node, commentAuthorPaths);
   const authorAvatarUrl = firstString(node, commentAvatarPaths, false);
@@ -3218,6 +3218,7 @@ Usage:
   diggylab install-service                   (systemd: start "run" on boot)
   diggylab uninstall-service
   diggylab status
+  diggylab update                            (upgrades the installed npm package)
   diggylab install-browser
   diggylab unpair
 
@@ -3225,20 +3226,25 @@ Global options:
   --config <directory>   Agent state directory (default ~/.diggylab)
   --api <origin>         API origin (default $DIGGYLAB_API_URL or https://api.diggylab.com)`;
 var MISSING_BROWSER_HINT = "Chromium for Playwright is not installed yet. Run `diggylab install-browser` once.";
-function agentVersion() {
+function readAgentManifest() {
   let directory = fileURLToPath(new URL(".", import.meta.url));
   for (let depth = 0; depth < 4; depth += 1) {
     const manifest = join4(directory, "package.json");
     if (existsSync2(manifest)) {
       try {
-        const version = JSON.parse(readFileSync2(manifest, "utf8")).version;
-        if (typeof version === "string" && version) return version;
+        const parsed = JSON.parse(readFileSync2(manifest, "utf8"));
+        if (typeof parsed.version === "string" && parsed.version) {
+          return { name: typeof parsed.name === "string" ? parsed.name : "", version: parsed.version };
+        }
       } catch {
       }
     }
     directory = dirname3(directory);
   }
-  return "0.0.0";
+  return { name: "", version: "0.0.0" };
+}
+function agentVersion() {
+  return readAgentManifest().version;
 }
 function resolvePlatform() {
   if (process.platform === "darwin") return "MACOS";
@@ -3591,6 +3597,7 @@ async function commandRun(runtime, io) {
     io.error("This agent is not paired yet. Run `diggylab pair --code <code>` first.");
     return 2;
   }
+  startUpdateRefresh(runtime.directory, io);
   const recordActivity = (message, code, options = {}) => {
     void runtime.activity.append({
       category: options.category ?? "CONNECTION",
@@ -3748,6 +3755,119 @@ async function commandStatus(runtime, io) {
   io.log(`Facebook: ${hasUser ? "connected" : "missing \u2014 run `diggylab login`"}`);
   return 0;
 }
+function npmExecutable() {
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function runNpm(args, capture) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(npmExecutable(), args, {
+      shell: process.platform === "win32",
+      stdio: capture ? ["ignore", "pipe", "pipe"] : "inherit"
+    });
+    let stderr = "";
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.once("error", reject);
+    child.once("exit", (value) => resolve({ code: value ?? 1, stderr, stdout }));
+  });
+}
+function compareVersions(current, latest) {
+  const currentParts = current.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const latestParts = latest.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  for (let index = 0; index < 3; index += 1) {
+    const difference = (currentParts[index] ?? 0) - (latestParts[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+async function commandUpdate(options, io) {
+  const manifest = readAgentManifest();
+  if (manifest.name !== "diggylab") {
+    io.error("This is a development build; update the repository instead (git pull && pnpm install).");
+    return 1;
+  }
+  const directory = resolveConfigDirectory(options);
+  let latest = "";
+  try {
+    const check = await runNpm(["view", "diggylab", "version", "--json"], true);
+    if (check.code !== 0) {
+      io.error("Could not ask npm for the latest version. Check the network and the npm registry, then try again.");
+      if (check.stderr.trim()) io.error(check.stderr.trim());
+      return 1;
+    }
+    latest = check.stdout.trim().replace(/^"(.*)"$/, "$1");
+  } catch (error) {
+    io.error(`Could not run npm: ${error instanceof Error ? error.message : String(error)}`);
+    return 1;
+  }
+  if (!/^\d+\.\d+\.\d+/.test(latest)) {
+    io.error(`npm returned an unexpected version "${latest.slice(0, 40)}".`);
+    return 1;
+  }
+  writeUpdateCache(directory, latest);
+  if (compareVersions(manifest.version, latest) >= 0) {
+    io.log(`Already on the latest version (${manifest.version}).`);
+    return 0;
+  }
+  io.log(`Updating diggylab ${manifest.version} -> ${latest}...`);
+  try {
+    const install = await runNpm(["install", "-g", "diggylab@latest"], false);
+    if (install.code !== 0) {
+      io.error("The npm upgrade failed. If npm reported a permissions error, fix the global prefix or run the command with sudo.");
+      return 1;
+    }
+  } catch (error) {
+    io.error(`Could not run npm: ${error instanceof Error ? error.message : String(error)}`);
+    return 1;
+  }
+  io.log(`Updated to ${latest}. Start a new diggylab command to use it; a service picks it up on its next restart.`);
+  return 0;
+}
+var UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function readUpdateCache(directory) {
+  try {
+    const parsed = JSON.parse(readFileSync2(join4(directory, "update-check.json"), "utf8"));
+    if (typeof parsed.latest === "string" && /^\d+\.\d+\.\d+/.test(parsed.latest) && typeof parsed.checkedAt === "number") {
+      return { checkedAt: parsed.checkedAt, latest: parsed.latest };
+    }
+  } catch {
+  }
+  return void 0;
+}
+function writeUpdateCache(directory, latest) {
+  try {
+    writeFileSync2(join4(directory, "update-check.json"), `${JSON.stringify({ checkedAt: Date.now(), latest })}
+`);
+  } catch {
+  }
+}
+function logUpdateNotice(io, current, latest) {
+  io.log(`A newer version is available: ${current} -> ${latest} (run \`diggylab update\`).`);
+}
+function logCachedUpdateNotice(directory, io) {
+  const manifest = readAgentManifest();
+  if (manifest.name !== "diggylab") return;
+  const cache = readUpdateCache(directory);
+  if (cache && compareVersions(manifest.version, cache.latest) < 0) logUpdateNotice(io, manifest.version, cache.latest);
+}
+function startUpdateRefresh(directory, io) {
+  const manifest = readAgentManifest();
+  if (manifest.name !== "diggylab") return;
+  const cache = readUpdateCache(directory);
+  if (cache && Date.now() - cache.checkedAt < UPDATE_CHECK_INTERVAL_MS) return;
+  void runNpm(["view", "diggylab", "version", "--json"], true).then((check) => {
+    if (check.code !== 0) return;
+    const latest = check.stdout.trim().replace(/^"(.*)"$/, "$1");
+    if (!/^\d+\.\d+\.\d+/.test(latest)) return;
+    writeUpdateCache(directory, latest);
+    if (compareVersions(manifest.version, latest) < 0) logUpdateNotice(io, manifest.version, latest);
+  }).catch(() => void 0);
+}
 async function commandUnpair(runtime, io) {
   await runtime.manager.clear();
   await runtime.facebook.clear();
@@ -3836,12 +3956,14 @@ async function main(argv, io = console) {
     io.log(USAGE);
     return 0;
   }
-  if (!["install-browser", "install-service", "login", "logout", "pair", "rename", "run", "status", "uninstall-service", "unpair"].includes(command)) {
+  if (!["install-browser", "install-service", "login", "logout", "pair", "rename", "run", "status", "uninstall-service", "unpair", "update"].includes(command)) {
     io.error(`Unknown command "${command}".`);
     io.error(USAGE);
     return 2;
   }
   if (command === "install-browser") return commandInstallBrowser(io);
+  if (command === "update") return commandUpdate(parsed.options, io);
+  logCachedUpdateNotice(resolveConfigDirectory(parsed.options), io);
   const runtime = createRuntime(parsed.options);
   switch (command) {
     case "pair":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diggylab",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "description": "DiggyLab Desktop Agent collects posts and information from Facebook Groups on a paired computer. (headless CLI)",
   "type": "module",
   "bin": {