opencube 0.3.0 → 0.3.3

package/README.md

@@ -21,7 +21,7 @@ OpenCube is packaged as an opencode plugin plus an Electron desktop process.
 
 ## Install
 
-Install globally through opencode:
+Install the latest published version globally through opencode:
 
 ```sh
 opencode plugin opencube --global
@@ -41,6 +41,30 @@ You can also add it manually to `~/.config/opencode/opencode.json`:
 }
 ```
 
+## Update
+
+If you already installed OpenCube and want to upgrade, reinstall the target version with `--force`:
+
+```sh
+opencode plugin opencube@0.3.1 --global --force
+```
+
+Using an explicit version is recommended for upgrades because it avoids stale `latest` cache behavior. You can still install the npm latest tag if desired:
+
+```sh
+opencode plugin opencube@latest --global --force
+```
+
+Then fully restart opencode and run `/pet` again. OpenCube and opencode plugins are loaded at startup, so the running desktop pet is not hot-replaced in place.
+
+You can ask OpenCube to check npm for the latest published version:
+
+```text
+/pet_update
+```
+
+`/pet_update` does not hot-replace the running plugin. It reports whether a newer version exists and prints an explicit `opencode plugin opencube@<version> --global --force` command to run.
+
 ## Commands
 
 | Command | Description |
@@ -49,6 +73,8 @@ You can also add it manually to `~/.config/opencode/opencode.json`:
 | `/pet_stop` | Quit OpenCube. |
 | `/pet_say_hello` | Flash one currently free face three times with a random color. |
 | `/pet_fancy_say_hello` | Run a denser randomized light show across currently free faces. |
+| `/pet_update` | Check npm for a newer OpenCube release and show the upgrade command. |
+| `/pet_upgrade` | Alias for `/pet_update`. |
 
 These commands are handled by the plugin and do not get sent to the model.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencube",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "description": "A tiny Three.js desktop pet for opencode session activity.",
   "main": "src/main.js",
   "exports": {

package/src/main.js

@@ -16,6 +16,7 @@ const ICON_PATH = process.env.OPENCODE_PET_ICON || path.join(__dirname, "..", "a
 const MAX_EVENTS = 100
 const MAX_INTERACTION_EVENTS = 80
 const IDLE_TTL_MS = 5 * 60 * 1000
+const PET_WINDOW_SIZE = 120
 
 let petWindow = null
 let panelWindow = null
@@ -31,17 +32,68 @@ let pendingQuestionsByRequest = new Map()
 let cleanupTimer = null
 let dragState = null
 
+function normalizeDragPoint(point) {
+  const screenX = Number(point?.screenX)
+  const screenY = Number(point?.screenY)
+  if (!Number.isFinite(screenX) || !Number.isFinite(screenY)) return null
+  return { screenX, screenY }
+}
+
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value))
+}
+
+function getVirtualWorkArea() {
+  const displays = screen.getAllDisplays()
+  if (!displays.length) return screen.getPrimaryDisplay().workArea
+
+  return displays.reduce((area, display) => {
+    const next = display.workArea
+    const left = Math.min(area.x, next.x)
+    const top = Math.min(area.y, next.y)
+    const right = Math.max(area.x + area.width, next.x + next.width)
+    const bottom = Math.max(area.y + area.height, next.y + next.height)
+    return { x: left, y: top, width: right - left, height: bottom - top }
+  }, displays[0].workArea)
+}
+
+function normalizeWindowPosition(x, y, win) {
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !win || win.isDestroyed()) return null
+
+  const bounds = win.getBounds()
+  const area = getVirtualWorkArea()
+  const minX = area.x
+  const minY = area.y
+  const maxX = area.x + area.width - Math.max(1, bounds.width)
+  const maxY = area.y + area.height - Math.max(1, bounds.height)
+
+  return {
+    x: Math.round(clamp(x, Math.min(minX, maxX), Math.max(minX, maxX))),
+    y: Math.round(clamp(y, Math.min(minY, maxY), Math.max(minY, maxY))),
+  }
+}
+
 ipcMain.on("opencube-drag-start", (event, point) => {
   if (!petWindow || petWindow.isDestroyed()) return
+  const dragPoint = normalizeDragPoint(point)
+  if (!dragPoint) return
   const [x, y] = petWindow.getPosition()
-  dragState = { windowX: x, windowY: y, screenX: point.screenX, screenY: point.screenY }
+  dragState = { windowX: x, windowY: y, screenX: dragPoint.screenX, screenY: dragPoint.screenY }
 })
 
 ipcMain.on("opencube-drag-move", (event, point) => {
   if (!petWindow || petWindow.isDestroyed() || !dragState) return
-  const nextX = Math.round(dragState.windowX + point.screenX - dragState.screenX)
-  const nextY = Math.round(dragState.windowY + point.screenY - dragState.screenY)
-  petWindow.setPosition(nextX, nextY, false)
+  const dragPoint = normalizeDragPoint(point)
+  if (!dragPoint) return
+  const nextX = Math.round(dragState.windowX + dragPoint.screenX - dragState.screenX)
+  const nextY = Math.round(dragState.windowY + dragPoint.screenY - dragState.screenY)
+  const nextPosition = normalizeWindowPosition(nextX, nextY, petWindow)
+  if (!nextPosition) return
+  try {
+    petWindow.setPosition(nextPosition.x, nextPosition.y, false)
+  } catch {
+    dragState = null
+  }
 })
 
 ipcMain.on("opencube-drag-end", () => {
@@ -680,6 +732,7 @@ function petHtml3D() {
   const initialStateJson = JSON.stringify(getPetState()).replaceAll("<", "\\u003c")
   const iconUrl = createIconDataUrl()
   const threeCjsPath = JSON.stringify(path.join(path.dirname(require.resolve("three")), "three.cjs"))
+  const renderSize = PET_WINDOW_SIZE
   return `<!doctype html>
 <html>
   <head>
@@ -704,8 +757,8 @@ function petHtml3D() {
       #scene {
         position: absolute;
         inset: 0;
-        width: 100%;
-        height: 100%;
+        width: ${renderSize}px;
+        height: ${renderSize}px;
         pointer-events: none;
       }
       #hit-layer {
@@ -734,6 +787,7 @@ function petHtml3D() {
       const THREE = require(${threeCjsPath})
       const { ipcRenderer } = require("electron")
 
+      const PET_RENDER_SIZE = ${renderSize}
       window.__PET_STATE = ${initialStateJson}
       const stage = document.querySelector(".stage")
       const hitLayer = document.getElementById("hit-layer")
@@ -765,7 +819,7 @@ function petHtml3D() {
       camera.position.set(0, 0.04, 3.25)
       const renderer = new THREE.WebGLRenderer({ canvas, alpha: true, antialias: true })
       renderer.setClearColor(0x000000, 0)
-      renderer.setPixelRatio(Math.min((window.devicePixelRatio || 1) * 1.5, 3))
+      renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2))
       renderer.outputColorSpace = THREE.SRGBColorSpace
 
       const cubeGroup = new THREE.Group()
@@ -1093,10 +1147,8 @@ function petHtml3D() {
       }
 
       function resize() {
-        const width = Math.max(1, window.innerWidth)
-        const height = Math.max(1, window.innerHeight)
-        renderer.setSize(width, height, false)
-        camera.aspect = width / height
+        renderer.setSize(PET_RENDER_SIZE, PET_RENDER_SIZE, false)
+        camera.aspect = 1
         camera.updateProjectionMatrix()
       }
       window.addEventListener("resize", resize)
@@ -1631,6 +1683,16 @@ function petHtml3D() {
           busyFaces,
           helloFlashes,
           permissionGlows,
+          renderSize: {
+            fixed: PET_RENDER_SIZE,
+            innerWidth: window.innerWidth,
+            innerHeight: window.innerHeight,
+            devicePixelRatio: window.devicePixelRatio || 1,
+            canvasWidth: canvas.width,
+            canvasHeight: canvas.height,
+            canvasClientWidth: canvas.clientWidth,
+            canvasClientHeight: canvas.clientHeight,
+          },
         }
         requestAnimationFrame(tick)
       }
@@ -1658,7 +1720,7 @@ function restorePosition(win) {
   try {
     const raw = fs.readFileSync(STATE_FILE, "utf8")
     const state = JSON.parse(raw)
-    if (typeof state.x === "number" && typeof state.y === "number") {
+    if (Number.isFinite(state.x) && Number.isFinite(state.y)) {
       win.setPosition(state.x, state.y, false)
       return
     }
@@ -1676,8 +1738,8 @@ function restorePosition(win) {
 function createPetWindow() {
   if (petWindow && !petWindow.isDestroyed()) return petWindow
   petWindow = new BrowserWindow({
-    width: 120,
-    height: 120,
+    width: PET_WINDOW_SIZE,
+    height: PET_WINDOW_SIZE,
     show: false,
     frame: false,
     resizable: false,

package/src/plugin-server.cjs

@@ -1,7 +1,9 @@
 const { quitPet, sendEvent, showPet } = require("./plugin-shared.cjs")
+const pkg = require("../package.json")
 
 const COMMAND_HANDLED_SENTINEL = "__OPENCODE_PET_COMMAND_HANDLED__"
 const CUB_ICON = "◈"
+const UPDATE_CHECK_TIMEOUT_MS = 5000
 
 function handled() {
   throw new Error(COMMAND_HANDLED_SENTINEL)
@@ -27,6 +29,72 @@ function isFancySayHello(input) {
   return input.command === "pet_fancy_say_hello"
 }
 
+function isUpdateCheck(input) {
+  return input.command === "pet_update" || input.command === "pet_upgrade"
+}
+
+function compareVersions(a, b) {
+  const left = String(a || "").split(".").map((part) => Number.parseInt(part, 10) || 0)
+  const right = String(b || "").split(".").map((part) => Number.parseInt(part, 10) || 0)
+  const length = Math.max(left.length, right.length)
+  for (let index = 0; index < length; index += 1) {
+    const diff = (left[index] || 0) - (right[index] || 0)
+    if (diff !== 0) return diff > 0 ? 1 : -1
+  }
+  return 0
+}
+
+async function fetchLatestPackageVersion(name = pkg.name, timeoutMs = UPDATE_CHECK_TIMEOUT_MS) {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), timeoutMs)
+
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(name)}/latest`, {
+      headers: { accept: "application/json" },
+      signal: controller.signal,
+    })
+    if (!response.ok) throw new Error(`npm registry returned ${response.status}`)
+    const info = await response.json()
+    return {
+      name: info.name || name,
+      version: info.version,
+      tarball: info.dist?.tarball,
+    }
+  } catch (error) {
+    if (error?.name === "AbortError") throw new Error(`npm registry check timed out after ${timeoutMs}ms`)
+    throw error
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+function formatUpdateNotice(latest) {
+  const current = pkg.version
+  if (!latest?.version) return cubNotice(`Could not read the latest ${pkg.name} version from npm.`, "△")
+
+  const comparison = compareVersions(latest.version, current)
+  if (comparison < 0) {
+    return cubNotice(
+      [
+        `Welcome to the tiny time machine ✨`,
+        `This OpenCube is a dev build (${current}), ahead of npm (${latest.version}).`,
+        `Keep this cube away from paradoxes and production users.`,
+      ].join("\n"),
+      "✧",
+    )
+  }
+  if (comparison === 0) return cubNotice(`OpenCube is up to date (${current}).`, "✓")
+
+  return cubNotice(
+    [
+      `OpenCube ${latest.version} is available. Current version: ${current}.`,
+      `Upgrade with: opencode plugin ${pkg.name}@${latest.version} --global --force`,
+      `Then fully restart opencode and run /pet again.`,
+    ].join("\n"),
+    "↻",
+  )
+}
+
 async function injectNotice(client, sessionID, text) {
   if (!sessionID || !client?.session?.prompt) return
 
@@ -85,10 +153,18 @@ module.exports = {
           template: "/pet_fancy_say_hello",
           description: "Trigger a randomized light show on OpenCube's free faces.",
         }
+        cfg.command.pet_update = {
+          template: "/pet_update",
+          description: "Check npm for a newer OpenCube version and show the upgrade command.",
+        }
+        cfg.command.pet_upgrade = {
+          template: "/pet_upgrade",
+          description: "Alias for /pet_update.",
+        }
       },
 
       "command.execute.before": async (input, output) => {
-        if (!["pet", "pet_stop", "pet_say_hello", "pet_fancy_say_hello"].includes(input.command)) return
+        if (!["pet", "pet_stop", "pet_say_hello", "pet_fancy_say_hello", "pet_update", "pet_upgrade"].includes(input.command)) return
 
         // There is no official cancel primitive in command.execute.before yet.
         // Throwing this sentinel aborts the command flow before opencode sends
@@ -129,6 +205,39 @@ module.exports = {
               ? cubNotice("OpenCube is putting on a light show ✨", "✺")
               : cubNotice("OpenCube is sleeping... zzz  Start it with /pet before the light show.", "☾"),
           )
+        } else if (isUpdateCheck(input)) {
+          let latest
+          try {
+            latest = await fetchLatestPackageVersion()
+            const versionComparison = compareVersions(latest.version, pkg.version)
+            await sendEvent({
+              type: "update.check",
+              message: "OpenCube checked npm for updates",
+              package: pkg.name,
+              currentVersion: pkg.version,
+              latestVersion: latest.version,
+              updateAvailable: versionComparison > 0,
+              devVersion: versionComparison < 0,
+              tarball: latest.tarball,
+              timeoutMs: UPDATE_CHECK_TIMEOUT_MS,
+              sessionID: input.sessionID,
+              source: "opencube-plugin",
+            })
+          } catch (error) {
+            await sendEvent({
+              type: "update.check_failed",
+              message: "OpenCube could not check npm for updates",
+              package: pkg.name,
+              currentVersion: pkg.version,
+              error: error?.message || String(error),
+              sessionID: input.sessionID,
+              source: "opencube-plugin",
+            })
+            await injectNotice(client, input.sessionID, cubNotice(`Could not check npm for OpenCube updates: ${error?.message || error}`, "△"))
+            handled()
+          }
+
+          await injectNotice(client, input.sessionID, formatUpdateNotice(latest))
         } else {
           await showPet({
             onProgress: (message) => injectNotice(client, input.sessionID, message),