@nordbyte/nordrelay-auto-updater 0.1.0

package/src/npm-packages.js

@@ -0,0 +1,92 @@
+import { runCommand } from "./subprocess.js";
+
+export function collectNpmPackages(settings = {}) {
+  if (settings.enableNpmPackages === false) {
+    return { supported: false, packages: [], errors: [], globalRoot: "", disabled: true };
+  }
+  const timeoutMs = settings.commandTimeoutMs;
+  const registryArgs = settings.npmRegistry ? ["--registry", String(settings.npmRegistry)] : [];
+  const root = runCommand("npm", ["root", "-g"], { timeoutMs });
+  const listed = runCommand("npm", ["ls", "-g", "--depth=0", "--json", "--long", ...registryArgs], { timeoutMs, maxBuffer: 16 * 1024 * 1024 });
+  const outdated = runCommand("npm", ["outdated", "-g", "--json", "--long", ...registryArgs], { timeoutMs, maxBuffer: 16 * 1024 * 1024 });
+  const packages = mergeNpmPackageData(parseNpmList(listed.stdout), parseNpmOutdated(outdated.stdout));
+  const errors = [];
+  if (listed.missing) {
+    errors.push({ command: "npm", error: "npm not found" });
+  } else if (!listed.ok && !listed.stdout.trim()) {
+    errors.push({ command: "npm ls -g", error: listed.stderr || listed.error || `Exit ${listed.status}` });
+  }
+  if (!outdated.ok && ![0, 1].includes(Number(outdated.status)) && !outdated.stdout.trim()) {
+    errors.push({ command: "npm outdated -g", error: outdated.stderr || outdated.error || `Exit ${outdated.status}` });
+  }
+  return {
+    supported: !listed.missing,
+    globalRoot: root.stdout.trim(),
+    packages,
+    errors,
+    diagnostics: {
+      listDurationMs: listed.durationMs,
+      outdatedDurationMs: outdated.durationMs,
+      listStatus: listed.status,
+      outdatedStatus: outdated.status,
+    },
+  };
+}
+
+export function parseNpmList(stdout) {
+  try {
+    const parsed = JSON.parse(String(stdout || "{}"));
+    const dependencies = parsed.dependencies && typeof parsed.dependencies === "object" ? parsed.dependencies : {};
+    return Object.entries(dependencies).map(([name, item]) => ({
+      name,
+      current: String(item?.version || ""),
+      wanted: String(item?.version || ""),
+      latest: String(item?.version || ""),
+      location: String(item?.path || item?.location || ""),
+      type: String(item?.dev ? "dev" : item?.optional ? "optional" : "prod"),
+      homepage: String(item?.homepage || ""),
+      status: "latest",
+    }));
+  } catch {
+    return [];
+  }
+}
+
+export function parseNpmOutdated(stdout) {
+  try {
+    const parsed = JSON.parse(String(stdout || "{}"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
+    return Object.entries(parsed).map(([name, item]) => ({
+      name,
+      current: String(item?.current || ""),
+      wanted: String(item?.wanted || ""),
+      latest: String(item?.latest || ""),
+      location: String(item?.location || ""),
+      type: String(item?.type || ""),
+      homepage: String(item?.homepage || ""),
+      status: "outdated",
+    }));
+  } catch {
+    return [];
+  }
+}
+
+export function mergeNpmPackageData(installed, outdated) {
+  const map = new Map();
+  for (const item of installed) {
+    map.set(item.name, { ...item });
+  }
+  for (const item of outdated) {
+    const existing = map.get(item.name) || {};
+    map.set(item.name, {
+      ...existing,
+      ...item,
+      status: item.latest && item.current && item.latest !== item.current ? "outdated" : "latest",
+    });
+  }
+  return [...map.values()].sort((left, right) => {
+    const status = Number(right.status === "outdated") - Number(left.status === "outdated");
+    return status || String(left.name).localeCompare(String(right.name));
+  });
+}
+

package/src/os-updates.js

@@ -0,0 +1,19 @@
+import { managersForPlatform, runManager } from "./package-managers.js";
+
+export function collectOsUpdates(settings = {}) {
+  if (settings.enableOsUpdates === false) {
+    return { supported: false, managers: [], updates: [], errors: [], disabled: true };
+  }
+  const managers = managersForPlatform(process.platform, settings);
+  if (!managers.length) {
+    return { supported: false, managers: [], updates: [], errors: [], disabled: false };
+  }
+  const results = managers.map((name) => runManager(name, settings));
+  return {
+    supported: true,
+    managers: results,
+    updates: results.flatMap((result) => result.updates.map((update) => ({ ...update, manager: result.name }))),
+    errors: results.filter((result) => !result.ok && !result.missing).map((result) => ({ manager: result.name, error: result.error, status: result.status })),
+  };
+}
+

package/src/package-managers.js

@@ -0,0 +1,175 @@
+import { runCommand } from "./subprocess.js";
+
+export const OS_MANAGER_COMMANDS = {
+  apt: { command: "apt", args: ["list", "--upgradable"] },
+  dnf: { command: "dnf", args: ["check-update"] },
+  pacman: { command: "pacman", args: ["-Qu"] },
+  zypper: { command: "zypper", args: ["list-updates"] },
+  snap: { command: "snap", args: ["refresh", "--list"] },
+  flatpak: { command: "flatpak", args: ["remote-ls", "--updates"] },
+  softwareupdate: { command: "softwareupdate", args: ["-l"] },
+  brew: { command: "brew", args: ["outdated", "--json=v2"] },
+};
+
+export function managersForPlatform(platform = process.platform, settings = {}) {
+  if (settings.enableOsUpdates === false) return [];
+  const disabled = new Set(String(settings.disabledManagers || "").split(",").map((item) => item.trim()).filter(Boolean));
+  const enabled = [];
+  if (platform === "linux") {
+    enabled.push("apt", "dnf", "pacman", "zypper", "snap", "flatpak");
+  } else if (platform === "darwin") {
+    enabled.push("softwareupdate", "brew");
+  }
+  return enabled.filter((name) => !disabled.has(name));
+}
+
+export function runManager(name, settings = {}) {
+  const spec = OS_MANAGER_COMMANDS[name];
+  if (!spec) {
+    return { name, ok: false, updates: [], error: `Unknown package manager: ${name}`, durationMs: 0 };
+  }
+  const result = runCommand(spec.command, spec.args, { timeoutMs: settings.commandTimeoutMs });
+  const parser = MANAGER_PARSERS[name];
+  const updates = parser ? parser(result.stdout, result.stderr) : [];
+  const okStatus = result.ok || (name === "dnf" && result.status === 100);
+  return {
+    name,
+    command: [spec.command, ...spec.args].join(" "),
+    ok: okStatus && !result.timedOut && !result.missing,
+    missing: result.missing,
+    status: result.status,
+    durationMs: result.durationMs,
+    updates,
+    error: okStatus || result.missing ? "" : result.stderr || result.error || `Exit ${result.status}`,
+  };
+}
+
+export function parseAptList(stdout) {
+  return String(stdout || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !/^listing/i.test(line))
+    .map((line) => {
+      const match = /^([^/\s]+)\/([^\s]+)\s+([^\s]+)\s+([^\s]+)(?:\s+\[upgradable from:\s*([^\]]+)\])?/i.exec(line);
+      if (!match) return null;
+      return {
+        manager: "apt",
+        name: match[1],
+        source: match[2],
+        latest: match[3],
+        arch: match[4],
+        current: match[5] || "",
+      };
+    })
+    .filter(Boolean);
+}
+
+export function parseDnfCheckUpdate(stdout) {
+  return String(stdout || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !/^(last metadata|obsoleting|security:)/i.test(line))
+    .map((line) => {
+      const parts = line.split(/\s+/);
+      if (parts.length < 3 || !parts[0].includes(".")) return null;
+      return { manager: "dnf", name: parts[0], current: "", latest: parts[1], source: parts.slice(2).join(" ") };
+    })
+    .filter(Boolean);
+}
+
+export function parsePacmanQu(stdout) {
+  return String(stdout || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const match = /^(\S+)\s+(\S+)\s+->\s+(\S+)/.exec(line);
+      return match ? { manager: "pacman", name: match[1], current: match[2], latest: match[3], source: "" } : null;
+    })
+    .filter(Boolean);
+}
+
+export function parseZypperListUpdates(stdout) {
+  return String(stdout || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.includes("|") && !/^[-+|]+$/.test(line))
+    .map((line) => line.split("|").map((part) => part.trim()))
+    .filter((parts) => parts.length >= 5 && !/^repository$/i.test(parts[0]))
+    .map((parts) => ({ manager: "zypper", source: parts[0], name: parts[2], current: parts[3], latest: parts[4] }));
+}
+
+export function parseSnapRefreshList(stdout) {
+  return String(stdout || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !/^name\s+/i.test(line))
+    .map((line) => {
+      const parts = line.split(/\s+/);
+      return parts.length >= 4 ? { manager: "snap", name: parts[0], current: parts[1], latest: parts[2], source: parts.slice(3).join(" ") } : null;
+    })
+    .filter(Boolean);
+}
+
+export function parseFlatpakUpdates(stdout) {
+  return String(stdout || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const parts = line.split(/\t+/);
+      return { manager: "flatpak", name: parts[0] || line, current: "", latest: parts[1] || "", source: parts[2] || "" };
+    });
+}
+
+export function parseSoftwareUpdate(stdout) {
+  const updates = [];
+  const lines = String(stdout || "").split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index].trim();
+    const match = /^\*\s+Label:\s*(.+)$/i.exec(line);
+    if (!match) continue;
+    const title = String(lines[index + 1] || "").replace(/^Title:\s*/i, "").trim();
+    const version = /Version:\s*([^,]+)/i.exec(title)?.[1]?.trim() || "";
+    updates.push({ manager: "softwareupdate", name: match[1].trim(), current: "", latest: version, source: title });
+  }
+  return updates;
+}
+
+export function parseBrewOutdated(stdout) {
+  try {
+    const parsed = JSON.parse(String(stdout || "{}"));
+    const formulae = Array.isArray(parsed.formulae) ? parsed.formulae : [];
+    const casks = Array.isArray(parsed.casks) ? parsed.casks : [];
+    return [
+      ...formulae.map((item) => ({
+        manager: "brew",
+        name: item.name,
+        current: Array.isArray(item.installed_versions) ? item.installed_versions.join(", ") : "",
+        latest: item.current_version || "",
+        source: "formula",
+      })),
+      ...casks.map((item) => ({
+        manager: "brew",
+        name: item.name,
+        current: Array.isArray(item.installed_versions) ? item.installed_versions.join(", ") : "",
+        latest: item.current_version || "",
+        source: "cask",
+      })),
+    ].filter((item) => item.name);
+  } catch {
+    return [];
+  }
+}
+
+const MANAGER_PARSERS = {
+  apt: parseAptList,
+  dnf: parseDnfCheckUpdate,
+  pacman: parsePacmanQu,
+  zypper: parseZypperListUpdates,
+  snap: parseSnapRefreshList,
+  flatpak: parseFlatpakUpdates,
+  softwareupdate: parseSoftwareUpdate,
+  brew: parseBrewOutdated,
+};
+