opencube 0.3.3 → 0.4.1

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.3",
+  "version": "0.4.1",
   "description": "A tiny Three.js desktop pet for opencode session activity.",
   "main": "src/main.js",
   "exports": {

package/src/main.js

@@ -17,6 +17,8 @@ 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
@@ -31,6 +33,7 @@ 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)
@@ -104,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,
@@ -121,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")
 }
@@ -548,7 +589,7 @@ function petHtml() {
     </style>
   </head>
   <body>
-    <div class="stage" title="opencode pet：拖拽移动，右键打开菜单">
+    <div class="stage">
       <div class="pet-art" aria-label="pixel opencode pet">${petBodySvg}</div>
       <div id="ball-layer"></div>
     </div>
@@ -732,7 +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 = PET_WINDOW_SIZE
+  const renderSize = getPetWindowSize()
   return `<!doctype html>
 <html>
   <head>
@@ -770,7 +811,7 @@ function petHtml3D() {
     </style>
   </head>
   <body>
-    <div class="stage" title="opencode pet：拖拽移动，右键打开菜单">
+    <div class="stage">
       <canvas id="scene" aria-label="3D opencode pet"></canvas>
       <div id="hit-layer" aria-label="OpenCube interaction layer"></div>
     </div>
@@ -1737,9 +1778,10 @@ function restorePosition(win) {
 
 function createPetWindow() {
   if (petWindow && !petWindow.isDestroyed()) return petWindow
+  const size = getPetWindowSize()
   petWindow = new BrowserWindow({
-    width: PET_WINDOW_SIZE,
-    height: PET_WINDOW_SIZE,
+    width: size,
+    height: size,
     show: false,
     frame: false,
     resizable: false,
@@ -1895,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,
@@ -1944,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 })
@@ -1968,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),