symbio 0.6.0 → 0.7.0

package/CHANGELOG.md

@@ -5,6 +5,17 @@ versions follow [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.7.0]
+
+- Updates: `sym update` installs the latest version and restarts Symbio once the team is idle
+  (`--now` doesn't wait). Symbio also checks for new versions and, by default, updates itself while
+  no agent is working and remote access is off: it backs up first, keeps (or restores) the old
+  version if the install fails and doesn't retry it for a day, and tells you in Messages. Settings →
+  Updates: automatic, tell me, or off, and what's new; a badge in the top bar when a version is
+  available.
+- Docs brought up to date; the roadmap is now a priority list with collected ideas; `sym doctor`
+  prints Symbio's version.
+
 ## [0.6.0]
 
 - Azure DevOps connections: add an organization with a personal access token in Settings; agents

package/README.md

@@ -82,6 +82,11 @@ place. Here Symbio was restarted mid-task, and it told the helper to pick up whe
   see. Each connection can require your approval for every action.
 - **Resilient.** A supervisor restarts OpenCode if it crashes, a watchdog unsticks hung agents, and
   when a model fails (quota, outage) the agent switches to the next allowed model and carries on.
+- **Long-running teams stay healthy.** Agents can continue in a fresh session with a handoff note
+  (when you ask, after each finished task, or automatically when a conversation grows too large to
+  send). A daily check backs up Symbio's state and tells you and core about work that exists only
+  on this machine and build outputs filling the disk.
+- **Costs in view.** Tokens and estimated cost per agent and model, with prices you can set.
 - **Safety rails.** Agents can't kill processes by name (which would take down your terminals and
   editors), can't read your SSH keys or Symbio's secret store, and must ask before installing
   software. They look at images through scaled-down copies, so a few large pictures can't make a
@@ -123,6 +128,12 @@ on your computer, including the agents, from using Symbio's API behind your back
 | `sym doctor` | Check Node.js, git, OpenCode, the port and model providers. |
 | `sym run` | Run in the foreground, with the log in the terminal. |
 | `sym remote` | Open a temporary link and access code to use Symbio from another device (see below). `sym remote off` closes it. |
+| `sym update` | Install the latest version and restart Symbio, once no agent is working (`--now` doesn't wait). |
+
+**Updates.** Symbio checks for new versions and, by default, installs them by itself while the team
+is idle: never while an agent is working or waiting for you, or while remote access is on. It backs
+up first, restarts in a minute or two, and tells you in Messages. In Settings → Updates you can
+choose to be only told instead, or turn checking off, and see what's new.
 
 **From another device.** `sym remote` opens a temporary Cloudflare link to your Symbio and prints it
 with an access code. Open the link anywhere (phone, another computer), enter the code, and you're
@@ -171,8 +182,13 @@ itself. Whoever gets in controls your agents, so keep the link and code to yours
 | `~/.symbio/secrets.enc` | Connection secrets, encrypted with a key kept in your OS credential store |
 | `~/.symbio/worktrees/` | Helpers' working copies |
 | `~/.symbio/backups/` | Daily backups of Symbio's state (the last 7 days) |
+| `~/.symbio/approvals/` | Remote actions waiting for (or decided by) your approval |
+| `~/.symbio/prices.json` | Model prices used for cost estimates |
+| `~/.symbio/ui-token` | The key that unlocks the UI (it's in the link Symbio opens) |
+| `~/.symbio/logs/symbio.log` | Symbio's log when started in the background (`sym logs`); `update.log` next to it for updates |
+| `~/.symbio/updates.json` | Your update setting (automatic, tell me, off) |
 | `<project>/.symbio/` | Project state: agents, plan, message log, shared assets (git-ignored automatically) |
-| `<project>/AGENTS.md`, `<project>/docs/` | Project documentation for agents (unless you chose *private*) |
+| `<project>/AGENTS.md`, `<project>/docs/` | Project documentation for agents (unless you chose *private*), and `docs/rules.json` if the rules register is on |
 | OpenCode's database | The conversations themselves. Every agent is an OpenCode session, so you can also open one with `opencode -s <session-id>`. |
 
 Symbio never deletes your project files. Removing a project from Symbio only forgets it, and can
@@ -193,13 +209,17 @@ All optional, set as environment variables:
 | `SYMBIO_STUCK_MINUTES` | `10` | Silence before the watchdog interrupts a working agent |
 | `SYMBIO_RECYCLE_MB` | `1500` | Restart OpenCode above this memory use once every agent is idle |
 | `SYMBIO_RECYCLE_HARD_MB` | `3000` | Restart OpenCode above this memory use regardless (agents resume) |
+| `SYMBIO_MEMORY_CHECK_SECONDS` | `60` | How often OpenCode's memory use is checked |
+| `SYMBIO_BACKUP_DAYS` | `7` | How many daily backups of Symbio's state to keep |
+| `SYMBIO_BUILD_ALERT_GB` | `2` | Build outputs in a helper's folder above this size are reported by the daily check |
 
 ## Status
 
-Symbio is young (version 0.1) and changing quickly. The core workflow works end to end: projects,
-core and helpers, messaging, plan and kanban, shared assets, connections, providers, and recovery.
-Planned next: npm packaging with first-run checks, an agent graph, and screenshots for agents so
-they can see what they build. See [docs/roadmap.md](docs/roadmap.md).
+Symbio is young and changing quickly, shaped by people using it for real work. The core workflow
+works end to end: projects, core and helpers, messaging, plan and kanban, shared assets, docs and
+the rules register, connections (GitHub, Azure DevOps, servers), providers, costs and recovery.
+What's planned and what's open for help is in [docs/roadmap.md](docs/roadmap.md); what changed in
+each version is in [CHANGELOG.md](CHANGELOG.md).
 
 ## Documentation
 

package/bin/symbio.js

@@ -9,9 +9,10 @@
 //   sym doctor     check that everything Symbio needs is in place
 //   sym run        run in the foreground (for debugging)
 //   sym remote     open a temporary link to use Symbio from another device (sym remote off to close it)
+//   sym update     install the latest version (waits for an idle team; --now doesn't)
 
-import { execFileSync, exec, spawn } from "node:child_process";
-import { existsSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { execFileSync, exec, spawn, spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -33,8 +34,13 @@ const token = () => {
 };
 const link = () => `${BASE}/?token=${token()}`;
 
-async function api(method, p) {
-  const res = await fetch(BASE + p, { method, headers: { "x-symbio-token": token() }, signal: AbortSignal.timeout(3000) });
+async function api(method, p, body) {
+  const res = await fetch(BASE + p, {
+    method,
+    headers: { "x-symbio-token": token(), ...(body === undefined ? {} : { "content-type": "application/json" }) },
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal: AbortSignal.timeout(body === undefined ? 3000 : 30_000),
+  });
   return { status: res.status, body: await res.json().catch(() => null) };
 }
 
@@ -164,6 +170,7 @@ async function doctor() {
     console.log(`${pass ? "✔" : "✘"} ${label}${!pass && fix ? `\n    → ${fix}` : ""}`);
     if (!pass) ok = false;
   };
+  console.log(`Symbio ${pkg.version}`);
   const [major] = process.versions.node.split(".").map(Number);
   check(major >= 22, `Node.js ${process.versions.node}`, "Symbio needs Node.js 22 or newer: https://nodejs.org");
   let gitVersion = "";
@@ -189,6 +196,82 @@ async function doctor() {
   if (!ok) process.exitCode = 1;
 }
 
+/**
+ * Installs the latest version. Running: Symbio hands over to its updater and restarts (waiting
+ * for an idle team unless --now). Stopped: the updater runs here, and Symbio stays stopped.
+ */
+async function update() {
+  const now = process.argv.includes("--now");
+  const self = await import(pathToFileURL(path.join(root, "dist", "server", "self-update.js")).href);
+  const install = self.installInfo(root);
+  if (install.kind === "dev") {
+    console.log(`This Symbio runs from a development folder (${install.root}). Update it there: git pull, npm install, npm run build.`);
+    return;
+  }
+  let latest;
+  try {
+    latest = await self.latestVersion();
+  } catch (err) {
+    console.error(`Couldn't check for updates: ${err.message}`);
+    process.exit(1);
+  }
+  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}).`);
+  const resultFile = path.join(HOME, "update-result.json");
+  const before = existsSync(resultFile) ? readFileSync(resultFile, "utf8") : "";
+
+  if ((await state()) === "running") {
+    const st = (await api("GET", "/api/update")).body;
+    if (st?.busy && !now) {
+      console.log(`Not now: ${st.busy}.\nRun "sym update" again when the team is idle, or "sym update --now" (agents that are working are interrupted and continue after the restart).`);
+      process.exitCode = 1;
+      return;
+    }
+    const res = await api("POST", "/api/update/apply", { force: true });
+    if (res.status !== 200) {
+      console.error(res.body?.error ?? `Symbio answered ${res.status}`);
+      process.exit(1);
+    }
+    process.stdout.write("Updating: Symbio stops, installs the new version and starts again");
+    for (let i = 0; i < 300; i++) {
+      await sleep(1000);
+      const after = existsSync(resultFile) ? readFileSync(resultFile, "utf8") : "";
+      if (after && after !== before && (await state()) === "running") break;
+      if (i % 3 === 0) process.stdout.write(".");
+    }
+    console.log("");
+  } else {
+    // Not running: install right here, from a copy of the updater (npm replaces this folder).
+    const dir = mkdtempSync(path.join(os.tmpdir(), "symbio-update-"));
+    const runner = path.join(dir, "update-runner.mjs");
+    copyFileSync(path.join(root, "bin", "update-runner.mjs"), runner);
+    const job = path.join(dir, "job.json");
+    writeFileSync(
+      job,
+      JSON.stringify({
+        prefix: install.prefix,
+        spec: process.env.SYMBIO_UPDATE_SPEC ?? `symbio@${latest}`,
+        from: pkg.version,
+        to: latest,
+        root: install.root,
+        home: HOME,
+        port: PORT,
+        start: false,
+        resultFile,
+        logFile: path.join(HOME, "logs", "update.log"),
+      }),
+    );
+    console.log("Installing…");
+    spawnSync(process.execPath, [runner, job], { stdio: "inherit", windowsHide: true });
+  }
+  const result = existsSync(resultFile) ? JSON.parse(readFileSync(resultFile, "utf8")) : null;
+  if (result?.ok && result.to === latest) console.log(`Updated to ${latest}.${(await state()) === "running" ? ` Symbio is running: ${link()}` : ' Start it with "sym".'}`);
+  else {
+    console.error(`The update didn't complete${result?.error ? `: ${result.error}` : "."} Details: ${path.join(HOME, "logs", "update.log")}`);
+    process.exitCode = 1;
+  }
+}
+
 function help() {
   console.log(`Symbio ${pkg.version} — run a team of AI agents on your project, from your browser.
 
@@ -203,6 +286,7 @@ Usage: sym [command]
   run             run in the foreground (logs in this terminal)
   remote          open a temporary link + access code to use Symbio from another device
   remote off      close that link
+  update          install the latest version (when the team is idle; --now to not wait)
   --version       print the version
 
 Environment: SYMBIO_PORT (default 4310), SYMBIO_HOME (default ~/.symbio), SYMBIO_NO_OPEN=1.`);
@@ -230,6 +314,9 @@ switch (cmd) {
     if (process.argv[3] === "off") await remoteOff();
     else await remoteOn();
     break;
+  case "update":
+    await update();
+    break;
   case "logs":
     logs();
     break;

package/bin/update-runner.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+// Installs a Symbio update while Symbio is stopped, then starts it again. Runs as its own process,
+// from a copy outside the package folder (which npm replaces): Symbio hands over and exits, or
+// `sym update` runs it when Symbio isn't running. It can't install in place: on Windows, OpenCode
+// and the native modules keep their files locked while they run.
+//
+// Usage: node update-runner.mjs <job.json>
+//   job: { waitPid?, prefix, spec, from, to, root, home, port, start, resultFile, logFile }
+
+import { spawn, spawnSync } from "node:child_process";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+const job = JSON.parse(readFileSync(process.argv[2], "utf8"));
+mkdirSync(path.dirname(job.logFile), { recursive: true });
+const log = (line) => appendFileSync(job.logFile, `${new Date().toISOString()} ${line}\n`);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const alive = (pid) => {
+  try {
+    process.kill(pid, 0); // signal 0: only checks the process exists
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/** npm install -g <spec> into the prefix Symbio was installed in. */
+function install(spec) {
+  log(`npm install -g ${spec} (prefix ${job.prefix})`);
+  const res = spawnSync(process.platform === "win32" ? "npm.cmd" : "npm", ["install", "-g", spec, "--no-fund", "--no-audit"], {
+    encoding: "utf8",
+    shell: process.platform === "win32",
+    windowsHide: true,
+    timeout: 10 * 60_000,
+    env: { ...process.env, npm_config_prefix: job.prefix },
+  });
+  const output = `${res.stdout ?? ""}${res.stderr ?? ""}`.trim();
+  if (output) log(output.split("\n").slice(-30).join("\n"));
+  return { ok: res.status === 0, output: res.error ? res.error.message : output };
+}
+
+/** The installed package is the old version and can start. */
+function intact() {
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(job.root, "package.json"), "utf8"));
+    return pkg.version === job.from && existsSync(path.join(job.root, "bin", "symbio.js")) && existsSync(path.join(job.root, "dist", "server", "index.js"));
+  } catch {
+    return false;
+  }
+}
+
+const result = { from: job.from, to: job.to, ok: false, error: null, finishedAt: 0, seen: false };
+try {
+  log(`Updating Symbio ${job.from} → ${job.to}`);
+  if (job.waitPid) {
+    for (let i = 0; i < 180 && alive(job.waitPid); i++) await sleep(500);
+    if (alive(job.waitPid)) throw new Error("Symbio didn't stop within 90 seconds; nothing was changed.");
+  }
+  const done = install(job.spec);
+  if (done.ok) {
+    result.ok = true;
+    log("Installed.");
+  } else {
+    result.error = `npm couldn't install ${job.to}: ${done.output.split("\n").slice(-6).join(" ").slice(0, 600)}`;
+    log(result.error);
+    // npm often fails before touching anything (no network, a lock); only if the old version
+    // was damaged, put it back so Symbio still starts.
+    if (intact()) log(`${job.from} is still in place.`);
+    else {
+      const back = install(`symbio@${job.from}`);
+      log(back.ok ? `Reinstalled ${job.from}.` : `Couldn't reinstall ${job.from} either; run: npm install -g symbio`);
+      if (!back.ok) result.error += ` Reinstalling ${job.from} failed too; run "npm install -g symbio".`;
+    }
+  }
+} catch (err) {
+  result.error = err.message;
+  log(`Failed: ${err.message}`);
+}
+result.finishedAt = Date.now();
+writeFileSync(job.resultFile, JSON.stringify(result, null, 2));
+
+if (job.start) {
+  log("Starting Symbio.");
+  // `sym start` from the (possibly new) package, in the background like a normal start.
+  const child = spawn(process.execPath, [path.join(job.root, "bin", "symbio.js"), "start"], {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    env: { ...process.env, SYMBIO_NO_OPEN: "1", SYMBIO_HOME: job.home, SYMBIO_PORT: String(job.port) },
+  });
+  child.unref();
+}

package/dist/server/housekeeping.js

@@ -14,10 +14,18 @@ export const backupsDir = () => path.join(globalDir, "backups");
  * Returns the folder, or null when today's backup already exists.
  */
 export async function dailyBackup(projects, now = new Date()) {
-    const day = now.toISOString().slice(0, 10);
-    const dest = path.join(backupsDir(), day);
+    const dest = path.join(backupsDir(), now.toISOString().slice(0, 10));
     if (existsSync(dest))
         return null;
+    return writeBackup(projects, dest);
+}
+/** A backup on demand, e.g. right before an update ("2026-11-06-before-0.7.0"); pruned like the daily ones. */
+export async function labeledBackup(projects, label, now = new Date()) {
+    const dest = path.join(backupsDir(), `${now.toISOString().slice(0, 10)}-${label.replace(/[^\w.-]+/g, "-")}`);
+    await fs.rm(dest, { recursive: true, force: true });
+    return writeBackup(projects, dest);
+}
+async function writeBackup(projects, dest) {
     const tmp = `${dest}.partial`;
     await fs.rm(tmp, { recursive: true, force: true });
     for (const p of projects) {
@@ -32,9 +40,10 @@ export async function dailyBackup(projects, now = new Date()) {
     }
     await fs.mkdir(tmp, { recursive: true });
     await fs.rename(tmp, dest);
-    // Keep the newest days only.
-    const days = (await fs.readdir(backupsDir())).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort();
-    for (const old of days.slice(0, Math.max(0, days.length - BACKUP_KEEP))) {
+    // Keep the last BACKUP_KEEP days that have backups (daily and labeled alike).
+    const entries = (await fs.readdir(backupsDir())).filter((d) => /^\d{4}-\d{2}-\d{2}(-[\w.-]+)?$/.test(d));
+    const keepDays = [...new Set(entries.map((d) => d.slice(0, 10)))].sort().slice(-BACKUP_KEEP);
+    for (const old of entries.filter((d) => !keepDays.includes(d.slice(0, 10)))) {
         await fs.rm(path.join(backupsDir(), old), { recursive: true, force: true }).catch(() => { });
     }
     return dest;

package/dist/server/index.js

@@ -1,6 +1,6 @@
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
-import { promises as fs, existsSync } from "node:fs";
+import { promises as fs, existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { exec } from "node:child_process";
@@ -16,6 +16,8 @@ import { OpencodeRuntime } from "./opencode/runtime.js";
 import { Store, globalDir } from "./store.js";
 import { Team } from "./team.js";
 import { removeOrphanWorkspaces } from "./workspaces.js";
+import { packageRoot, QUIET_MS, SelfUpdate } from "./self-update.js";
+import { labeledBackup } from "./housekeeping.js";
 // Background work (timers, event handlers) must never take the whole app down: an error there
 // (e.g. OpenCode restarting mid-call) is logged and the next tick tries again.
 process.on("unhandledRejection", (err) => console.error("[unhandled]", err instanceof Error ? err.stack ?? err.message : err));
@@ -72,6 +74,23 @@ async function main() {
     team.markInterrupted("Symbio was stopped and has been restarted");
     const uiToken = loadUiToken(globalDir);
     const remote = new RemoteAccess(path.join(globalDir, "bin"));
+    // Updates: checked now and then; applied when allowed and the team is idle (see self-update.ts).
+    const version = JSON.parse(readFileSync(path.join(packageRoot, "package.json"), "utf8")).version;
+    const updates = new SelfUpdate({
+        version,
+        home: globalDir,
+        port: PORT,
+        busy: () => team.busyReason(QUIET_MS),
+        remoteActive: () => remote.active,
+        backup: async () => {
+            await labeledBackup(store.list(), `before-${updates.state().latest ?? "update"}`);
+        },
+        announce: (text) => team.announce(text),
+        shutdown: async () => {
+            await shutdown?.();
+        },
+    });
+    await updates.load();
     remote.onChange = () => bus.publish({ type: "remote.updated" });
     const remoteRequests = new WeakSet(); // requests that came through the tunnel
     const app = new Hono();
@@ -123,6 +142,25 @@ async function main() {
         setTimeout(() => void shutdown?.(), 200);
         return c.json({ ok: true });
     });
+    // Updates: state and settings for the UI; applying stops Symbio (never through remote access).
+    app.get("/api/update", (c) => c.json(updates.state()));
+    app.post("/api/update/check", async (c) => c.json(await updates.check()));
+    app.put("/api/update/settings", async (c) => {
+        const { mode } = await c.req.json();
+        if (mode !== "auto" && mode !== "notify" && mode !== "off")
+            return c.json({ error: "mode must be auto, notify or off" }, 400);
+        await updates.setMode(mode);
+        return c.json(updates.state());
+    });
+    app.post("/api/update/apply", async (c) => {
+        const { force } = await c.req.json().catch(() => ({ force: false }));
+        try {
+            return c.json({ message: await updates.apply(force !== false) });
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 400);
+        }
+    });
     // Remote access: status for everyone (the code only locally), start locally, stop from anywhere.
     app.get("/api/remote", (c) => c.json(remote.status(!remoteRequests.has(c.req.raw))));
     app.post("/api/remote/start", async (c) => {
@@ -164,10 +202,12 @@ async function main() {
         .then(() => console.log(`OpenCode ${runtime.version} ready`))
         .catch((err) => console.error("OpenCode failed to start:", err.message));
     team.startWatchdog();
+    updates.start();
     shutdown = async () => {
         remote.stop("Symbio stopped");
         team.shuttingDown = true;
         team.stopWatchdog();
+        updates.stop();
         await runtime.stop();
         process.exit(0);
     };

package/dist/server/remote-access.js

@@ -37,7 +37,7 @@ export function isTunnelRequest(headers, tunnelHost) {
 }
 // Never through the tunnel: the agents' tools, debugging, shutting Symbio down, starting a
 // tunnel, and the native folder dialog (it would open on this computer's screen).
-const NEVER_REMOTE = [/^\/mcp(\/|$)/, /^\/api\/debug(\/|$)/, /^\/api\/shutdown$/, /^\/api\/remote\/start$/, /^\/api\/pick-folder$/];
+const NEVER_REMOTE = [/^\/mcp(\/|$)/, /^\/api\/debug(\/|$)/, /^\/api\/shutdown$/, /^\/api\/remote\/start$/, /^\/api\/pick-folder$/, /^\/api\/update\/apply$/];
 /** What to do with a request that came through the tunnel. */
 export function remoteDecision(req) {
     if (!req.active)