symbio 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -5,6 +5,15 @@ versions follow [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.7.1]
+
+- On a Node.js older than 22, `sym` says what to install instead of Symbio crashing at start
+  (npm installs it anyway and only warns).
+- Automatic updates and `sym update` don't install a version that needs a newer Node.js than the
+  machine has.
+- The image library loads when an agent first views an image, so a problem with it affects only
+  `view_image`, not Symbio's start.
+
 ## [0.7.0]
 
 - Updates: `sym update` installs the latest version and restarts Symbio once the team is idle

package/bin/symbio.js

@@ -19,6 +19,18 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const pkg = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
+
+// npm only warns when Node is older than package.json's "engines"; without this, Symbio would
+// crash on start with a syntax error from a dependency (seen with Node 18).
+const MIN_NODE = Number(/\d+/.exec(pkg.engines?.node ?? "22")?.[0] ?? 22);
+if (Number(process.versions.node.split(".")[0]) < MIN_NODE && !["-v", "--version", "version", "-h", "--help", "help"].includes(process.argv[2])) {
+  console.error(
+    `Symbio ${pkg.version} needs Node.js ${MIN_NODE} or newer, and this is Node.js ${process.versions.node}.\n` +
+      `Install the current LTS (https://nodejs.org, or on Windows: winget install OpenJS.NodeJS.LTS), open a new terminal,\n` +
+      `then reinstall Symbio on it: npm install -g symbio`,
+  );
+  process.exit(1);
+}
 const PORT = Number(process.env.SYMBIO_PORT ?? 4310);
 const HOME = process.env.SYMBIO_HOME ?? path.join(os.homedir(), ".symbio");
 const LOG = path.join(HOME, "logs", "symbio.log");
@@ -208,15 +220,20 @@ async function update() {
     console.log(`This Symbio runs from a development folder (${install.root}). Update it there: git pull, npm install, npm run build.`);
     return;
   }
-  let latest;
+  let release;
   try {
-    latest = await self.latestVersion();
+    release = await self.latestRelease();
   } catch (err) {
     console.error(`Couldn't check for updates: ${err.message}`);
     process.exit(1);
   }
+  const latest = release.version;
   if (self.compareVersions(latest, pkg.version) <= 0) return console.log(`Symbio ${pkg.version} is up to date.`);
   console.log(`Symbio ${latest} is available (you have ${pkg.version}).`);
+  if (!self.nodeSatisfies(release.node)) {
+    console.error(`It needs Node.js ${release.node}, and this is Node.js ${process.versions.node}. Update Node.js first (https://nodejs.org), then run "sym update".`);
+    process.exit(1);
+  }
   const resultFile = path.join(HOME, "update-result.json");
   const before = existsSync(resultFile) ? readFileSync(resultFile, "utf8") : "";
 

package/dist/server/images.js

@@ -3,11 +3,22 @@
 // big to send at all. A crop shows one region at full resolution when details matter.
 import { existsSync, promises as fs } from "node:fs";
 import path from "node:path";
-import sharp from "sharp";
 import { IMAGE_EXTENSIONS, isSecretPath } from "./guard.js";
 export const DEFAULT_IMAGE_SIZE = 1024;
 const MAX_IMAGE_SIZE = 2048;
 const MAX_BYTES = 1_500_000; // what we send back, after scaling
+/**
+ * The image library is native and loaded on first use, so a problem with it (a platform without
+ * prebuilt binaries, an old Node) costs only view_image, not Symbio's startup.
+ */
+async function loadSharp() {
+    try {
+        return (await import("sharp")).default;
+    }
+    catch (err) {
+        throw new Error(`Images can't be viewed on this machine: the image library didn't load (${err.message.split("\n")[0]}).`);
+    }
+}
 export async function viewImage(folder, input) {
     const given = String(input.path ?? "").trim();
     if (!given)
@@ -21,6 +32,7 @@ export async function viewImage(folder, input) {
     if (!existsSync(file))
         throw new Error(`No such file: ${file}`);
     const size = Math.min(MAX_IMAGE_SIZE, Math.max(64, Math.round(Number(input.max_size) || DEFAULT_IMAGE_SIZE)));
+    const sharp = await loadSharp();
     let image = sharp(await fs.readFile(file), { animated: false }).rotate(); // apply EXIF orientation
     const meta = await image.metadata();
     const width = meta.autoOrient?.width ?? meta.width ?? 0;

package/dist/server/self-update.js

@@ -45,15 +45,26 @@ export function compareVersions(a, b) {
 }
 // Overridable for tests (a local registry and package file); never set in normal use.
 const REGISTRY = (process.env.SYMBIO_UPDATE_REGISTRY ?? "https://registry.npmjs.org").replace(/\/+$/, "");
-/** The version npm installs as `symbio@latest`. */
-export async function latestVersion() {
+/** The version npm installs as `symbio@latest`, and the Node.js it needs. */
+export async function latestRelease() {
     const res = await fetch(`${REGISTRY}/symbio/latest`, { signal: AbortSignal.timeout(15_000), headers: { accept: "application/json" } });
     if (!res.ok)
         throw new Error(`npm registry answered ${res.status}`);
     const data = (await res.json());
     if (!data.version)
         throw new Error("npm registry gave no version");
-    return data.version;
+    return { version: data.version, node: data.engines?.node ?? null };
+}
+export async function latestVersion() {
+    return (await latestRelease()).version;
+}
+/**
+ * Whether this Node.js meets a release's requirement (">=22", ">=20.9.0"; anything fancier is
+ * assumed met). npm only warns about it, and the new version would then fail to start.
+ */
+export function nodeSatisfies(range, version = process.versions.node) {
+    const m = range && /^\s*>=\s*v?(\d+(?:\.\d+){0,2})\s*$/.exec(range);
+    return !m || compareVersions(version, m[1].split(".").concat(["0", "0"]).slice(0, 3).join(".")) >= 0;
 }
 /** Changelog entries newer than `current`, from the latest version's CHANGELOG.md (best effort). */
 export async function changesSince(current, latest) {
@@ -88,6 +99,8 @@ const FAILED_PAUSE_MS = 24 * 60 * 60_000; // after a failed update, don't retry
 export class SelfUpdate {
     host;
     latest = null;
+    /** The Node.js the latest version needs (its package.json "engines"). */
+    latestNode = null;
     checkedAt = null;
     error = null;
     notes = [];
@@ -158,7 +171,9 @@ export class SelfUpdate {
         if (this.mode === "off" && this.checkedAt)
             return this.state();
         try {
-            this.latest = await latestVersion();
+            const release = await latestRelease();
+            this.latest = release.version;
+            this.latestNode = release.node;
             this.error = null;
             this.notes = compareVersions(this.latest, this.host.version) > 0 ? await changesSince(this.host.version, this.latest) : [];
         }
@@ -172,6 +187,9 @@ export class SelfUpdate {
     blocker(forced) {
         if (this.install.kind === "dev")
             return "This Symbio runs from a development folder; update it with git pull, npm install and npm run build.";
+        if (!nodeSatisfies(this.latestNode)) {
+            return `Symbio ${this.latest} needs Node.js ${this.latestNode}, and this machine has ${process.versions.node}: update Node.js first (https://nodejs.org), then update Symbio.`;
+        }
         if (this.applying)
             return "Already updating.";
         if (!forced && this.mode === "notify")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "symbio",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Run a team of OpenCode agents on a project from your browser",
   "license": "MIT",
   "author": "LinKzy",