opencube 0.2.0 → 0.3.0

package/package.json

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

package/src/main.js

@@ -26,6 +26,8 @@ let interactionEvents = []
 let petSignals = []
 let sessionMap = new Map()
 let activeToolsBySession = new Map()
+let pendingPermissionsByRequest = new Map()
+let pendingQuestionsByRequest = new Map()
 let cleanupTimer = null
 let dragState = null
 
@@ -131,6 +133,8 @@ function recordEvent(event) {
   }
   applySessionEvent(item)
   applyToolEvent(item)
+  applyPermissionEvent(item)
+  applyQuestionEvent(item)
   if (item.type === "hello" || item.type === "fancy_hello") {
     petSignals.push({
       id: item.id,
@@ -148,6 +152,63 @@ function recordEvent(event) {
   return item
 }
 
+function applyPermissionEvent(event) {
+  if (!event || typeof event.sessionID !== "string") return
+
+  if (event.type === "permission.ask") {
+    const requestID = typeof event.requestID === "string" ? event.requestID : event.id
+    if (!requestID) return
+    pendingPermissionsByRequest.set(requestID, {
+      requestID,
+      sessionID: event.sessionID,
+      permission: event.permission,
+      patterns: event.patterns,
+      metadata: event.metadata,
+      always: event.always,
+      tool: event.tool,
+      askedAt: event.receivedAt || Date.now(),
+    })
+    return
+  }
+
+  if (event.type === "permission.reply") {
+    if (typeof event.requestID === "string") pendingPermissionsByRequest.delete(event.requestID)
+  }
+}
+
+function clearPendingPermissionsForSession(sessionID) {
+  for (const [requestID, permission] of pendingPermissionsByRequest) {
+    if (permission?.sessionID === sessionID) pendingPermissionsByRequest.delete(requestID)
+  }
+}
+
+function applyQuestionEvent(event) {
+  if (!event || typeof event.sessionID !== "string") return
+
+  if (event.type === "question.ask") {
+    const requestID = typeof event.requestID === "string" ? event.requestID : event.id
+    if (!requestID) return
+    pendingQuestionsByRequest.set(requestID, {
+      requestID,
+      sessionID: event.sessionID,
+      questions: event.questions,
+      tool: event.tool,
+      askedAt: event.receivedAt || Date.now(),
+    })
+    return
+  }
+
+  if (event.type === "question.reply" || event.type === "question.reject") {
+    if (typeof event.requestID === "string") pendingQuestionsByRequest.delete(event.requestID)
+  }
+}
+
+function clearPendingQuestionsForSession(sessionID) {
+  for (const [requestID, question] of pendingQuestionsByRequest) {
+    if (question?.sessionID === sessionID) pendingQuestionsByRequest.delete(requestID)
+  }
+}
+
 function applyToolEvent(event) {
   if (!event || typeof event.sessionID !== "string" || typeof event.callID !== "string") return
   if (event.type !== "tool.start" && event.type !== "tool.finish") return
@@ -204,6 +265,8 @@ function applySessionEvent(event) {
 
   if (event.type === "session.idle") {
     activeToolsBySession.delete(event.sessionID)
+    clearPendingPermissionsForSession(event.sessionID)
+    clearPendingQuestionsForSession(event.sessionID)
     sessionMap.set(event.sessionID, {
       sessionID: event.sessionID,
       state: "idle",
@@ -225,6 +288,8 @@ function pruneIdleSessions(refresh = true) {
     if (session.state === "idle" && expiresFrom && now - expiresFrom > IDLE_TTL_MS) {
       sessionMap.delete(sessionID)
       activeToolsBySession.delete(sessionID)
+      clearPendingPermissionsForSession(sessionID)
+      clearPendingQuestionsForSession(sessionID)
       changed = true
     }
   }
@@ -259,6 +324,8 @@ function getPetState() {
       idleIndex: session.state === "idle" ? idleIndex++ : undefined,
       color: DEFAULT_SESSION_COLORS[index % DEFAULT_SESSION_COLORS.length],
     })),
+    permissions: Array.from(pendingPermissionsByRequest.values()),
+    questions: Array.from(pendingQuestionsByRequest.values()),
     signals: petSignals,
   }
 }
@@ -678,6 +745,7 @@ function petHtml3D() {
       const colorReleaseSpeed = 90
       const faceMeshes = new Map()
       const glowMeshes = new Map()
+      const permissionGlowMeshes = new Map()
       let snapshot = window.__PET_STATE || { sessions: [] }
       let lastFrame = performance.now()
       let rotation = { x: -14, y: -28, z: 0 }
@@ -723,6 +791,7 @@ function petHtml3D() {
       const dragParticleTexture = createDragParticleTexture()
       const faceGeometry = new THREE.PlaneGeometry(0.60, 0.60)
       const glowGeometry = new THREE.PlaneGeometry(1.18, 1.18)
+      const permissionGlowGeometry = new THREE.PlaneGeometry(1.62, 1.62)
       const rad = THREE.MathUtils.degToRad
 
       function createGlowTexture() {
@@ -763,6 +832,8 @@ function petHtml3D() {
       const dragParticles = []
       const toolParticles = []
       const toolEmitAccumulators = new Map()
+      const toolEmissionStates = new Map()
+      const toolEmissionHoldMs = 2000
       const faceVectors = {
         front: { position: new THREE.Vector3(0, 0, 0.34), normal: new THREE.Vector3(0, 0, 1) },
         back: { position: new THREE.Vector3(0, 0, -0.34), normal: new THREE.Vector3(0, 0, -1) },
@@ -855,25 +926,61 @@ function petHtml3D() {
         return true
       }
 
-      function updateToolParticles(sessions, dt) {
-        const activeToolSessions = sessions.filter((session) => session.state === "busy" && session.activeTools?.length > 0)
-        const activeIDs = new Set(activeToolSessions.map((session) => session.sessionID))
+      function updateToolParticles(sessions, dt, now) {
+        const activeIDs = new Set()
+        const emitters = []
+        const busyIDs = new Set(
+          sessions
+            .filter((session) => session?.state === "busy" && typeof session.sessionID === "string")
+            .map((session) => session.sessionID),
+        )
+
+        for (const session of sessions) {
+          if (session?.state !== "busy" || typeof session.sessionID !== "string" || !session.activeTools?.length) continue
+          const currentState = toolEmissionStates.get(session.sessionID)
+          const faceName = sessionFaceMap.get(session.sessionID) || currentState?.faceName
+          if (!faceName) continue
+          const color = sessionColorMap.get(session.sessionID) || currentState?.color || randomSessionGlowColor()
+
+          activeIDs.add(session.sessionID)
+          toolEmissionStates.set(session.sessionID, {
+            faceName,
+            color,
+            holdUntil: now + toolEmissionHoldMs,
+          })
+          emitters.push({ sessionID: session.sessionID, faceName, color, held: false, holdRemainingMs: toolEmissionHoldMs })
+        }
+
+        for (const [sessionID, state] of Array.from(toolEmissionStates.entries())) {
+          if (activeIDs.has(sessionID)) continue
+          if (!busyIDs.has(sessionID) || !state?.faceName || state.holdUntil <= now) {
+            toolEmissionStates.delete(sessionID)
+            toolEmitAccumulators.delete(sessionID)
+            continue
+          }
+          emitters.push({
+            sessionID,
+            faceName: state.faceName,
+            color: state.color || randomSessionGlowColor(),
+            held: true,
+            holdRemainingMs: state.holdUntil - now,
+          })
+        }
+
+        const emittingIDs = new Set(emitters.map((emitter) => emitter.sessionID))
         for (const sessionID of Array.from(toolEmitAccumulators.keys())) {
-          if (!activeIDs.has(sessionID)) toolEmitAccumulators.delete(sessionID)
+          if (!emittingIDs.has(sessionID)) toolEmitAccumulators.delete(sessionID)
         }
 
-        for (const session of activeToolSessions) {
-          const faceName = sessionFaceMap.get(session.sessionID)
-          if (!faceName) continue
-          const color = sessionColorMap.get(session.sessionID) || randomSessionGlowColor()
+        for (const emitter of emitters) {
           const jitterRate = randomBetween(7.5, 11.5)
-          const next = (toolEmitAccumulators.get(session.sessionID) || 0) + dt * jitterRate
+          const next = (toolEmitAccumulators.get(emitter.sessionID) || 0) + dt * jitterRate
           let accumulator = next
           while (accumulator >= 1) {
-            if (!emitToolParticle(faceName, color)) break
+            if (!emitToolParticle(emitter.faceName, emitter.color)) break
             accumulator -= 1
           }
-          toolEmitAccumulators.set(session.sessionID, accumulator)
+          toolEmitAccumulators.set(emitter.sessionID, accumulator)
         }
 
         let activeCount = 0
@@ -895,8 +1002,9 @@ function petHtml3D() {
           particle.scale.setScalar(data.size * (1.02 + age * 0.42))
           particle.material.opacity = Math.min(1, 0.24 + Math.sin(age * Math.PI) * 1.18)
         }
-        toolParticleGroup.visible = activeCount > 0 || activeToolSessions.length > 0
-        return { activeSessions: activeToolSessions.length, activeCount }
+        const heldSessions = emitters.filter((emitter) => emitter.held).length
+        toolParticleGroup.visible = activeCount > 0 || emitters.length > 0
+        return { activeSessions: activeIDs.size, emittingSessions: emitters.length, heldSessions, activeCount }
       }
 
       function activeDragColors() {
@@ -1198,6 +1306,23 @@ function petHtml3D() {
         glow.rotation.set(...rotation)
         cubeGroup.add(glow)
         glowMeshes.set(name, glow)
+
+        const permissionGlow = new THREE.Mesh(
+          permissionGlowGeometry,
+          new THREE.MeshBasicMaterial({
+            map: glowTexture,
+            color: 0xffffff,
+            transparent: true,
+            opacity: 0,
+            blending: THREE.AdditiveBlending,
+            depthWrite: false,
+            side: THREE.DoubleSide,
+          }),
+        )
+        permissionGlow.position.set(...glowPosition.map((value) => value === 0 ? 0 : value * 1.072))
+        permissionGlow.rotation.set(...rotation)
+        cubeGroup.add(permissionGlow)
+        permissionGlowMeshes.set(name, permissionGlow)
       }
 
       function magnitude(vector) {
@@ -1384,6 +1509,37 @@ function petHtml3D() {
         return active
       }
 
+      function applyPermissionGlowFaces(permissions, now) {
+        const pendingSessionIDs = new Set(
+          (permissions || [])
+            .map((permission) => permission?.sessionID)
+            .filter((sessionID) => typeof sessionID === "string"),
+        )
+        const active = {}
+        const wave = (Math.sin(now * 0.0095) + 1) / 2
+        const pulse = Math.pow(wave, 1.85)
+
+        for (const faceName of faceOrder) {
+          const permissionGlow = permissionGlowMeshes.get(faceName)
+          if (!permissionGlow) continue
+
+          const sessionID = Array.from(pendingSessionIDs).find((id) => sessionFaceMap.get(id) === faceName)
+          if (!sessionID) {
+            permissionGlow.material.opacity = 0
+            permissionGlow.scale.setScalar(1)
+            continue
+          }
+
+          const color = sessionColorMap.get(sessionID) || randomSessionGlowColor()
+          permissionGlow.material.color.setRGB(color.r / 255, color.g / 255, color.b / 255)
+          permissionGlow.material.opacity = 0.14 + pulse * 0.60
+          permissionGlow.scale.setScalar(1.06 + pulse * 0.42)
+          active[faceName] = { sessionID, pulse, pending: true, color: color.name, rgb: [color.r, color.g, color.b] }
+        }
+
+        return active
+      }
+
       window.__setPetState = setSnapshot
       window.__getPetDebug = () => latestDebug
 
@@ -1440,9 +1596,11 @@ function petHtml3D() {
         const glowB = Math.round(232 + (210 - 232) * glow)
         const dragParticles = updateDragParticles(now, frictionHoldLevel, speed, dt)
         const busyFaces = syncBusyFaces(sessions, speed)
-        const toolParticles = updateToolParticles(sessions, dt)
+        const toolParticles = updateToolParticles(sessions, dt, now)
         processSignals(snapshot.signals || [], now)
         const helloFlashes = applyFlashFaces(now)
+        const pendingAttention = [...(snapshot.permissions || []), ...(snapshot.questions || [])]
+        const permissionGlows = applyPermissionGlowFaces(pendingAttention, now)
         renderCube()
         latestDebug = {
           now: Date.now(),
@@ -1472,6 +1630,7 @@ function petHtml3D() {
           faceRotations,
           busyFaces,
           helloFlashes,
+          permissionGlows,
         }
         requestAnimationFrame(tick)
       }

package/src/plugin-server.cjs

@@ -139,6 +139,75 @@ module.exports = {
       },
 
       event: async ({ event }) => {
+        if (event.type === "permission.asked") {
+          const permission = event.properties || {}
+          await sendEvent({
+            type: "permission.ask",
+            message: "opencode is waiting for permission",
+            sessionID: permission.sessionID,
+            requestID: permission.id,
+            permission: permission.permission,
+            patterns: permission.patterns,
+            metadata: permission.metadata,
+            always: permission.always,
+            tool: permission.tool,
+            source: "opencube-plugin",
+          })
+          return
+        }
+
+        if (event.type === "permission.replied") {
+          const permission = event.properties || {}
+          await sendEvent({
+            type: "permission.reply",
+            message: "opencode permission was answered",
+            sessionID: permission.sessionID,
+            requestID: permission.requestID,
+            reply: permission.reply,
+            source: "opencube-plugin",
+          })
+          return
+        }
+
+        if (event.type === "question.asked") {
+          const question = event.properties || {}
+          await sendEvent({
+            type: "question.ask",
+            message: "opencode is waiting for a question answer",
+            sessionID: question.sessionID,
+            requestID: question.id,
+            questions: question.questions,
+            tool: question.tool,
+            source: "opencube-plugin",
+          })
+          return
+        }
+
+        if (event.type === "question.replied") {
+          const question = event.properties || {}
+          await sendEvent({
+            type: "question.reply",
+            message: "opencode question was answered",
+            sessionID: question.sessionID,
+            requestID: question.requestID,
+            answers: question.answers,
+            source: "opencube-plugin",
+          })
+          return
+        }
+
+        if (event.type === "question.rejected") {
+          const question = event.properties || {}
+          await sendEvent({
+            type: "question.reject",
+            message: "opencode question was rejected",
+            sessionID: question.sessionID,
+            requestID: question.requestID,
+            source: "opencube-plugin",
+          })
+          return
+        }
+
         if (event.type !== "session.status") return
 
         const sessionID = event.properties?.sessionID