opencube 0.3.1 → 0.4.0

package/README.md

@@ -4,152 +4,64 @@
 
 # OpenCube
 
-OpenCube is a tiny desktop pet for [opencode](https://opencode.ai/).
+A tiny desktop cube pet for [opencode](https://opencode.ai/).
 
-It watches opencode session activity and renders a small Three.js cube on your desktop:
-
-- busy sessions light up cube faces
-- active tool calls emit bright face-colored sparks from the corresponding cube face
-- right-click drag applies extra rotational friction with small braking particles
-- idle sessions keep a subtle torque-breathing motion and release face glow after the cube slows down
-- a macOS-style tray/menu bar control can show, hide, quit, or open the Inbox
-- the Inbox shows raw opencode hook events plus local mouse/keyboard diagnostics
-- `/pet_say_hello` flashes one free face
-- `/pet_fancy_say_hello` plays a randomized light show on free faces
-
-OpenCube is packaged as an opencode plugin plus an Electron desktop process.
+It lights up for busy sessions, tool calls, permissions, and questions.
 
 ## Install
 
-Install the latest published version globally through opencode:
-
 ```sh
 opencode plugin opencube --global
 ```
 
-Then restart opencode and run:
+Restart opencode, then run:
 
 ```text
 /pet
 ```
 
-You can also add it manually to `~/.config/opencode/opencode.json`:
-
-```json
-{
-  "plugin": ["opencube"]
-}
-```
-
 ## 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
+opencode plugin opencube@0.4.0 --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:
+Then restart opencode and run `/pet` again.
 
-```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:
+You can also ask OpenCube 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 |
-| --- | --- |
-| `/pet` | Show or start OpenCube. |
-| `/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.
-
-## What you can see
-
-OpenCube turns opencode lifecycle events into small desktop signals:
-
-| opencode activity | OpenCube signal |
-| --- | --- |
-| Session becomes busy | One cube face lights up with a stable session color. |
-| Session becomes idle | The face glow is released once the cube slows down. |
-| A tool call starts | The session's face emits fast, bright sparks in that face's current outward direction. |
-| A tool call finishes | Spark emission stops; existing sparks fade out naturally. |
-| Right mouse hold on the cube | Friction increases and braking particles appear. |
-| Tray menu → Show Inbox | Opens a two-column event/debug panel. |
-
-Multiple busy sessions can light multiple faces. If more than six sessions are busy, OpenCube shows the latest six.
-
-## How it works
-
-OpenCube has two parts in one npm package:
-
-1. `src/plugin-server.cjs` — the opencode plugin entrypoint.
-2. `src/main.js` — the Electron desktop pet.
-
-The plugin registers slash commands, listens for opencode `session.status` events and `tool.execute.*` hooks, and sends events to the desktop pet over a local HTTP API:
-
 ```text
-opencode plugin -> http://127.0.0.1:47832 -> Electron OpenCube
+/pet                 start or show OpenCube
+/pet_stop            quit OpenCube
+/pet-size            show size usage
+/pet-size 0.7        set cube size, range 0.3–3
+/pet_update          check npm for updates
+/pet_say_hello       flash a free face
+/pet_fancy_say_hello run a small light show
 ```
 
-The Electron process owns the window, tray menu, Three.js renderer, cube rotation, face glow state, particle effects, and inbox/debug endpoints.
-
-## Local API
-
-OpenCube exposes a local-only HTTP API while it is running:
-
-| Endpoint | Purpose |
-| --- | --- |
-| `GET /health` | Check whether OpenCube is running. |
-| `GET /debug-render` | Inspect renderer state, busy faces, active tools, and particle counters. |
-| `POST /event` | Receive opencode lifecycle/tool/hello events. |
-| `POST /interaction` | Receive local renderer mouse/keyboard diagnostics. |
-| `POST /show` | Show the cube window. |
-| `POST /quit` | Quit OpenCube. |
-
-The API binds to `127.0.0.1` only.
-
-## Requirements
-
-- opencode
-- macOS, Windows, or Linux capable of running Electron
-- network access to install npm dependencies during first plugin install
-
-Users do not need to run `npm install` manually when installing via `opencode plugin`. opencode installs npm plugins and dependencies automatically.
-
 ## Notes
 
-- The first install may take a while because Electron is downloaded as a runtime dependency.
-- If Electron's platform binary is missing after installation, OpenCube attempts a first-run self-repair download.
-- If commands do not appear after installation, restart opencode.
-- OpenCube uses a local-only HTTP server on `127.0.0.1:47832`.
-- If that port is already in use, set `OPENCODE_PET_PORT` before starting opencode.
-- In opencode desktop, OpenCube currently uses a command-abort sentinel to keep local slash commands out of the model flow; depending on opencode version, the desktop UI may show an error toast even though the command was handled.
+- OpenCube runs a local Electron process.
+- Local API: `http://127.0.0.1:47832`.
+- If commands do not appear, restart opencode.
+- First install can take a bit because Electron is downloaded.
 
-## Local development
-
-From this repository:
+## Development
 
 ```sh
 npm install
-npm run start
+npm start
+npm pack --dry-run
 ```
 
-For local opencode plugin testing, point your opencode config at the package directory:
+For local plugin testing:
 
 ```json
 {
@@ -157,10 +69,4 @@ For local opencode plugin testing, point your opencode config at the package dir
 }
 ```
 
-After changing plugin files or opencode config, restart opencode.
-
-To inspect the package contents before publishing:
-
-```sh
-npm pack --dry-run
-```
+Restart opencode after changing plugin code or config.

package/package.json

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

package/src/main.js

@@ -16,6 +16,9 @@ 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
+const MIN_PET_SIZE_SCALE = 0.3
+const MAX_PET_SIZE_SCALE = 3
 
 let petWindow = null
 let panelWindow = null
@@ -30,18 +33,70 @@ let pendingPermissionsByRequest = new Map()
 let pendingQuestionsByRequest = new Map()
 let cleanupTimer = null
 let dragState = null
+let petSizeScale = 1
+
+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", () => {
@@ -52,12 +107,22 @@ function ensureDataDir() {
   fs.mkdirSync(DATA_DIR, { recursive: true })
 }
 
+function readState() {
+  try {
+    return JSON.parse(fs.readFileSync(STATE_FILE, "utf8"))
+  } catch {
+    return {}
+  }
+}
+
 function writeState(extra = {}) {
   ensureDataDir()
+  const previous = readState()
   fs.writeFileSync(
     STATE_FILE,
     JSON.stringify(
       {
+        ...previous,
         pid: process.pid,
         startedAt: Date.now(),
         iconPath: ICON_PATH,
@@ -69,6 +134,34 @@ function writeState(extra = {}) {
   )
 }
 
+function normalizePetSizeScale(value) {
+  const scale = Number(value)
+  if (!Number.isFinite(scale)) return undefined
+  return Math.max(MIN_PET_SIZE_SCALE, Math.min(MAX_PET_SIZE_SCALE, scale))
+}
+
+function getPetWindowSize() {
+  return Math.round(PET_WINDOW_SIZE * petSizeScale)
+}
+
+function loadPetSizeScale() {
+  petSizeScale = normalizePetSizeScale(readState().sizeScale) ?? 1
+  return petSizeScale
+}
+
+function applyPetSizeScale(scale) {
+  const nextScale = normalizePetSizeScale(scale)
+  if (nextScale === undefined) throw new Error(`sizeScale must be a number between ${MIN_PET_SIZE_SCALE} and ${MAX_PET_SIZE_SCALE}`)
+  petSizeScale = nextScale
+  const size = getPetWindowSize()
+  writeState({ sizeScale: petSizeScale, size: { width: size, height: size } })
+  if (petWindow && !petWindow.isDestroyed()) {
+    petWindow.setSize(size, size, false)
+    petWindow.loadFile(writePetHtmlFile())
+  }
+  return { scale: petSizeScale, width: size, height: size }
+}
+
 function shouldQuit(argv = process.argv) {
   return argv.includes("--quit") || argv.includes("--stop") || argv.includes("stop") || argv.includes("quit")
 }
@@ -680,6 +773,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 = getPetWindowSize()
   return `<!doctype html>
 <html>
   <head>
@@ -704,8 +798,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 +828,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 +860,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 +1188,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 +1724,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 +1761,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
     }
@@ -1675,9 +1778,10 @@ function restorePosition(win) {
 
 function createPetWindow() {
   if (petWindow && !petWindow.isDestroyed()) return petWindow
+  const size = getPetWindowSize()
   petWindow = new BrowserWindow({
-    width: 120,
-    height: 120,
+    width: size,
+    height: size,
     show: false,
     frame: false,
     resizable: false,
@@ -1833,6 +1937,7 @@ function startServer() {
           port: PORT,
           events: events.length,
           pet: "opencube",
+          size: { scale: petSizeScale, width: getPetWindowSize(), height: getPetWindowSize() },
           sessions: getPetState().sessions.map(({ sessionID, state, busyIndex, idleIndex, color }) => ({
             sessionID,
             state,
@@ -1882,6 +1987,12 @@ function startServer() {
         return json(res, 200, { ok: true })
       }
 
+      if (req.method === "POST" && url.pathname === "/size") {
+        const body = await readRequestJson(req)
+        const size = applyPetSizeScale(body?.scale)
+        return json(res, 200, { ok: true, size })
+      }
+
       if (req.method === "POST" && url.pathname === "/toggle-panel") {
         togglePanel()
         return json(res, 200, { ok: true, visible: panelWindow?.isVisible() === true })
@@ -1906,6 +2017,7 @@ function startServer() {
 
 function start() {
   app.dock?.hide()
+  loadPetSizeScale()
   writeState({ visible: false, mode: "floating" })
   createTray()
   startServer()

package/src/plugin-server.cjs

@@ -1,9 +1,11 @@
-const { quitPet, sendEvent, showPet } = require("./plugin-shared.cjs")
+const { quitPet, requestPet, 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
+const MIN_PET_SIZE_SCALE = 0.3
+const MAX_PET_SIZE_SCALE = 3
 
 function handled() {
   throw new Error(COMMAND_HANDLED_SENTINEL)
@@ -33,6 +35,31 @@ function isUpdateCheck(input) {
   return input.command === "pet_update" || input.command === "pet_upgrade"
 }
 
+function isPetSize(input) {
+  return input.command === "pet-size" || input.command === "pet_size"
+}
+
+function petSizeUsage() {
+  return cubNotice(
+    [
+      "Set OpenCube size with: /pet-size 0.7",
+      `Allowed scale: ${MIN_PET_SIZE_SCALE} to ${MAX_PET_SIZE_SCALE}.`,
+      "Run /pet first if OpenCube is sleeping.",
+    ].join("\n"),
+    "↔",
+  )
+}
+
+function parsePetSizeScale(args) {
+  const text = textOfArguments(args)
+  if (!text) return undefined
+  const first = text.split(/\s+/)[0]
+  const scale = Number(first)
+  if (!Number.isFinite(scale)) return undefined
+  if (scale < MIN_PET_SIZE_SCALE || scale > MAX_PET_SIZE_SCALE) return undefined
+  return scale
+}
+
 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)
@@ -161,10 +188,18 @@ module.exports = {
           template: "/pet_upgrade",
           description: "Alias for /pet_update.",
         }
+        cfg.command["pet-size"] = {
+          template: "/pet-size",
+          description: "Show or set OpenCube size, for example /pet-size 0.7.",
+        }
+        cfg.command.pet_size = {
+          template: "/pet_size",
+          description: "Alias for /pet-size.",
+        }
       },
 
       "command.execute.before": async (input, output) => {
-        if (!["pet", "pet_stop", "pet_say_hello", "pet_fancy_say_hello", "pet_update", "pet_upgrade"].includes(input.command)) return
+        if (!["pet", "pet_stop", "pet_say_hello", "pet_fancy_say_hello", "pet_update", "pet_upgrade", "pet-size", "pet_size"].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
@@ -238,6 +273,22 @@ module.exports = {
           }
 
           await injectNotice(client, input.sessionID, formatUpdateNotice(latest))
+        } else if (isPetSize(input)) {
+          const scale = parsePetSizeScale(input.arguments)
+          if (scale === undefined) {
+            await injectNotice(client, input.sessionID, petSizeUsage())
+          } else {
+            const result = await requestPet("/size", { method: "POST", body: { scale }, timeoutMs: 1000 })
+            if (result?.ok && result.size) {
+              await injectNotice(
+                client,
+                input.sessionID,
+                cubNotice(`OpenCube size set to ${result.size.scale} (${result.size.width}×${result.size.height}).`, "↔"),
+              )
+            } else {
+              await injectNotice(client, input.sessionID, cubNotice("OpenCube is sleeping... zzz  Run /pet first, then try /pet-size 0.7.", "☾"))
+            }
+          }
         } else {
           await showPet({
             onProgress: (message) => injectNotice(client, input.sessionID, message),