toyon 0.1.0 → 0.3.0

package/dist/cli.js

@@ -3,75 +3,14 @@
 
 // src/cli.ts
 import { existsSync as existsSync10 } from "fs";
-import { join as join7, resolve } from "path";
-// package.json
-var package_default = {
-  name: "toyon",
-  version: "0.1.0",
-  description: "Checking an agent's work means running it. Toyon gives every chat its own copy of your web app, with a live preview.",
-  license: "MIT",
-  type: "module",
-  homepage: "https://toyon.dev",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/toyon-dev/toyon.git"
-  },
-  bugs: "https://github.com/toyon-dev/toyon/issues",
-  keywords: [
-    "ai",
-    "agents",
-    "claude-code",
-    "codex",
-    "opencode",
-    "git",
-    "worktree",
-    "preview",
-    "dev-server"
-  ],
-  bin: {
-    toyon: "bin/toyon.js"
-  },
-  files: [
-    "bin",
-    "dist",
-    "cloud"
-  ],
-  engines: {
-    node: ">=18"
-  },
-  os: [
-    "darwin",
-    "linux"
-  ],
-  scripts: {
-    prepublishOnly: "bun ../../scripts/pack.ts"
-  },
-  dependencies: {
-    bun: "1.4.2",
-    "bun-pty": "0.4.10"
-  },
-  devDependencies: {
-    "@toyon/shared": "workspace:*"
-  }
-};
-
-// src/app.ts
-import { spawn as spawn2, spawnSync } from "child_process";
-import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
-
-// src/daemon.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync2, mkdirSync, openSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join as join2 } from "path";
+import { join as join8, resolve } from "path";
 
 // ../shared/src/daemon.ts
 var DAEMON_FILES = {
   token: "token",
   pid: "daemon.pid",
   state: "state.json",
+  drafts: "drafts.json",
   log: "daemon.log",
   remote: "remote.json"
 };
@@ -153,6 +92,114 @@ function bwrapBlockedAdvice(error, restricted) {
 `);
 }
 
+// ../shared/src/update.ts
+function installMethod(packageJson) {
+  if (!packageJson)
+    return "none";
+  const p = packageJson.replaceAll("\\", "/");
+  if (p.includes("/_npx/"))
+    return "npx";
+  if (p.includes("/.bun/install/global/"))
+    return "bun";
+  if (p.includes("/node_modules/toyon/"))
+    return "npm";
+  return "none";
+}
+function installCommand(method, version) {
+  if (method === "npm")
+    return ["npm", "install", "-g", `toyon@${version}`];
+  if (method === "bun")
+    return ["bun", "add", "-g", `toyon@${version}`];
+  return null;
+}
+function newer(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb)
+    return false;
+  for (let i = 0;i < 3; i++) {
+    const x = pa.nums[i] ?? 0;
+    const y = pb.nums[i] ?? 0;
+    if (x !== y)
+      return x > y;
+  }
+  if (pa.pre === pb.pre)
+    return false;
+  if (pa.pre === null)
+    return true;
+  if (pb.pre === null)
+    return false;
+  return pa.pre > pb.pre;
+}
+function parseVersion(v) {
+  const m = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(v.trim());
+  if (!m)
+    return null;
+  return { nums: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] ?? null };
+}
+// package.json
+var package_default = {
+  name: "toyon",
+  version: "0.3.0",
+  description: "Toyon is where coding agents work on your web app while you check each change by using it. Every chat gets its own running copy with a live preview.",
+  license: "MIT",
+  type: "module",
+  homepage: "https://toyon.dev",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/toyon-dev/toyon.git"
+  },
+  bugs: "https://github.com/toyon-dev/toyon/issues",
+  keywords: [
+    "ai",
+    "agents",
+    "claude-code",
+    "codex",
+    "opencode",
+    "git",
+    "worktree",
+    "preview",
+    "dev-server"
+  ],
+  bin: {
+    toyon: "bin/toyon.js"
+  },
+  files: [
+    "bin",
+    "dist",
+    "cloud"
+  ],
+  engines: {
+    node: ">=18"
+  },
+  os: [
+    "darwin",
+    "linux"
+  ],
+  scripts: {
+    prepublishOnly: "bun ../../scripts/pack.ts"
+  },
+  dependencies: {
+    bun: "1.4.2",
+    "bun-pty": "0.4.10"
+  },
+  devDependencies: {
+    "@toyon/shared": "workspace:*"
+  }
+};
+
+// src/app.ts
+import { spawn as spawn2, spawnSync } from "child_process";
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+
+// src/daemon.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync2, mkdirSync, openSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+
 // src/layout.ts
 import { existsSync } from "fs";
 import { dirname, join } from "path";
@@ -404,7 +451,18 @@ exec /bin/bash "$(dirname "$0")/../Resources/launch.sh"
 }
 
 // src/args.ts
-var VERBS = new Set(["stop", "doctor", "logs", "version", "uninstall", "remote", "deploy", "help"]);
+var VERBS = new Set([
+  "stop",
+  "restart",
+  "update",
+  "doctor",
+  "logs",
+  "version",
+  "uninstall",
+  "remote",
+  "deploy",
+  "help"
+]);
 var DEFAULT_LOG_LINES = 100;
 function parseArgs(argv) {
   if (argv.includes("--help") || argv.includes("-h"))
@@ -415,6 +473,8 @@ function parseArgs(argv) {
   if (first !== undefined && VERBS.has(first)) {
     switch (first) {
       case "stop":
+      case "restart":
+      case "update":
       case "doctor":
       case "version":
       case "help":
@@ -543,6 +603,10 @@ usage
   toyon [path]            start the daemon if it is not running, register the repo at path
                           (default: the current directory) and open the shell
   toyon stop              stop the daemon and every dev server and agent it runs
+  toyon restart           stop the daemon and start it again from what is installed now; every
+                          shell reconnects on its own
+  toyon update            install the newest Toyon the way this one was installed, then restart
+                          the daemon onto it once no chat is mid-reply
   toyon doctor            check the daemon, the token, the shell build and the tools Toyon needs
   toyon logs [-f] [-n N]  print the daemon log; -f keeps following it, -n sets how many lines
   toyon version           print the CLI version, and the daemon's if one is running
@@ -571,6 +635,7 @@ options for toyon [path]
 environment
   TOYON_HOME              where state lives (default ~/.toyon)
   TOYON_PORT              the daemon's port (default 4141)
+  TOYON_UPDATES           off stops Toyon checking for and installing updates on this machine
 `;
 
 // src/deploy/fly.ts
@@ -974,7 +1039,12 @@ async function doctor() {
       lines.push(line(true, "running", `${running} of ${total} worktrees started; the rest start when opened`));
     }
     if (version !== package_default.version) {
-      lines.push(line(false, "version", `cli is ${package_default.version} and the daemon is ${version}; \`toyon stop\` then \`toyon\` restarts it`));
+      lines.push(line(false, "version", `cli is ${package_default.version} and the daemon is ${version}; \`toyon restart\` brings them level`));
+    }
+    if (h.updates?.managed) {
+      lines.push(line(true, "updates", "off for this machine (TOYON_UPDATES=off)"));
+    } else if (h.updates?.unreachable) {
+      lines.push(line(false, "updates", `npm could not get toyon from ${h.updates.unreachable}, so Toyon cannot update itself; if you may use the public registry, run npm install -g toyon --registry=https://registry.npmjs.org/`));
     }
   }
   const token = readToken();
@@ -1281,6 +1351,25 @@ async function stop() {
   return 0;
 }
 
+// src/restart.ts
+async function restart() {
+  const before = await health();
+  if (before) {
+    const code = await stop();
+    if (code !== 0)
+      return code;
+  } else {
+    console.log("Toyon was not running");
+  }
+  if (!await startDaemon()) {
+    console.error(`daemon failed to start; \`toyon logs\` shows why (${logFile})`);
+    return 1;
+  }
+  const after = await health();
+  console.log(`started Toyon${after?.pid !== undefined ? ` (pid ${after.pid})` : ""}`);
+  return 0;
+}
+
 // src/uninstall.ts
 import { existsSync as existsSync9, readFileSync as readFileSync7, rmSync as rmSync5 } from "fs";
 import { homedir as homedir3 } from "os";
@@ -1351,11 +1440,97 @@ async function uninstall(opts) {
   return 0;
 }
 
+// src/update.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { join as join7 } from "path";
+var WAIT_MS2 = 15000;
+async function update() {
+  if (process.env.TOYON_UPDATES === "off") {
+    console.error("updates are turned off for this machine (TOYON_UPDATES=off)");
+    return 1;
+  }
+  const method = installMethod(packaged ? join7(here, "..", "package.json") : null);
+  if (method === "none") {
+    console.error("toyon update works on a global npm or bun install, and this Toyon is not one; update it the way it was installed");
+    return 1;
+  }
+  const latest = latestVersion();
+  if (latest === null) {
+    console.error("could not ask npm for the newest Toyon; check that npm is on your PATH and its registry answers");
+    return 1;
+  }
+  const behind = newer(latest, package_default.version);
+  if (method === "npx") {
+    console.log(behind ? `toyon ${latest} is out; npx runs the version you name, so run npx toyon@${latest}` : `toyon ${package_default.version} is the newest`);
+    return 0;
+  }
+  if (behind) {
+    const command = installCommand(method, latest) ?? [];
+    const [cmd, ...args] = command;
+    if (!cmd)
+      return 1;
+    console.log(`installing toyon ${latest}: ${command.join(" ")}`);
+    const r = spawnSync2(cmd, args, { stdio: "inherit" });
+    if (r.status !== 0) {
+      console.error(`the install did not finish; run ${command.join(" ")} yourself to see why`);
+      return r.status ?? 1;
+    }
+  } else {
+    console.log(`toyon ${package_default.version} is the newest`);
+  }
+  return restartOnto(behind ? latest : package_default.version);
+}
+function latestVersion() {
+  const r = spawnSync2("npm", ["view", "toyon", "version", "--json"], { encoding: "utf8" });
+  if (r.status !== 0)
+    return null;
+  try {
+    const v = JSON.parse(r.stdout);
+    return typeof v === "string" ? v : null;
+  } catch {
+    return null;
+  }
+}
+async function restartOnto(version) {
+  const h = await health();
+  if (!h) {
+    console.log(`Toyon is not running; \`toyon\` starts ${version}`);
+    return 0;
+  }
+  if (h.version === version) {
+    console.log(`the daemon is already ${version}`);
+    return 0;
+  }
+  const token = readToken();
+  if (!token) {
+    console.error("the daemon token is missing, so the daemon cannot be asked to restart; `toyon restart` does it by hand");
+    return 1;
+  }
+  const res = await fetch(`${base}/restart?token=${token}`, { method: "POST" }).catch(() => null);
+  if (res && res.status === 409) {
+    console.error(await res.text());
+    return 1;
+  }
+  const deadline = Date.now() + WAIT_MS2;
+  while (Date.now() < deadline) {
+    await Bun.sleep(500);
+    if ((await health())?.version === version) {
+      console.log(`restarted Toyon on ${version}`);
+      return 0;
+    }
+  }
+  console.log(`Toyon restarts on ${version} once the chat replying now finishes`);
+  return 0;
+}
+
 // src/cli.ts
+function behind(daemonVersion) {
+  return daemonVersion === undefined || newer(package_default.version, daemonVersion);
+}
 async function open(cmd) {
   const explicit = cmd.path !== null;
   const target = resolve(cmd.path ?? process.cwd());
-  const register = explicit || existsSync10(join7(target, ".git"));
+  const register = explicit || existsSync10(join8(target, ".git"));
   if (process.platform === "linux") {
     const missing = missingSandboxTools();
     const blocked = missing.length === 0 ? bwrapStartError() : null;
@@ -1364,12 +1539,15 @@ async function open(cmd) {
     else if (blocked)
       console.log(bwrapBlockedAdvice(blocked, userNamespacesRestricted()));
   }
-  if (!await health()) {
+  const running = await health();
+  if (!running) {
     console.log("starting Toyon daemon\u2026");
     if (!await startDaemon()) {
       console.error(`daemon failed to start; \`toyon logs\` shows why (${logFile})`);
       return 1;
     }
+  } else if (behind(running.version)) {
+    console.log(`toyon: the running daemon is ${running.version ?? "older"}; \`toyon restart\` starts ${package_default.version}`);
   }
   const token = readToken();
   if (!token) {
@@ -1420,11 +1598,20 @@ async function run(cmd) {
       return 2;
     case "version": {
       const h = await health();
-      console.log(h ? `toyon ${package_default.version} (daemon ${h.version ?? "?"} running)` : `toyon ${package_default.version}`);
+      if (!h)
+        console.log(`toyon ${package_default.version}`);
+      else if (!behind(h.version))
+        console.log(`toyon ${package_default.version} (daemon ${h.version} running)`);
+      else
+        console.log(`toyon ${package_default.version} (daemon ${h.version ?? "?"} running; \`toyon restart\` to update)`);
       return 0;
     }
     case "stop":
       return stop();
+    case "restart":
+      return restart();
+    case "update":
+      return update();
     case "doctor":
       return doctor();
     case "logs":