opencube 0.1.0

package/src/pixel-pet-reference.cjs

@@ -0,0 +1,134 @@
+// Pixel renderer for the clean pixel opencode pet concept.
+//
+// src/main.js uses this module for the Electron pet body, while docs/assets can
+// keep using it as a stable reference for proportions, palette, and session-ball
+// model.
+
+const DEFAULT_SESSION_COLORS = ["#ff5d73", "#ffb020", "#28c76f", "#2f8cff", "#8b5cf6", "#06b6d4", "#f97316"]
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;")
+}
+
+function rect({ x, y, w, h, fill, opacity, className, extra = "" }) {
+  const attrs = [
+    `x="${x}"`,
+    `y="${y}"`,
+    `width="${w}"`,
+    `height="${h}"`,
+    fill ? `fill="${fill}"` : undefined,
+    opacity == null ? undefined : `opacity="${opacity}"`,
+    className ? `class="${escapeHtml(className)}"` : undefined,
+    extra,
+  ]
+    .filter(Boolean)
+    .join(" ")
+  return `<rect ${attrs} />`
+}
+
+function sessionBall({ x, y, color, index }) {
+  return [
+    rect({ x, y, w: 14, h: 14, fill: color, className: "session-ball", extra: `data-index="${index}"` }),
+    rect({ x: x + 4, y: y + 2, w: 4, h: 4, fill: "rgba(255,255,255,.68)", className: "session-ball-highlight" }),
+  ].join("\n    ")
+}
+
+function pixelPetSvg(options = {}) {
+  const colors = options.sessionColors || DEFAULT_SESSION_COLORS
+  const showCaption = options.showCaption ?? false
+  const ballPositions = [
+    [56, 24],
+    [90, 16],
+    [124, 20],
+    [154, 38],
+    [178, 68],
+    [188, 104],
+    [178, 140],
+  ]
+  const count = Math.max(0, Math.min(options.sessionCount ?? 7, ballPositions.length))
+  const balls = ballPositions
+    .slice(0, count)
+    .map(([x, y], index) => sessionBall({ x, y, color: colors[index % colors.length], index }))
+    .join("\n    ")
+
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="256" height="256" viewBox="0 0 256 256" shape-rendering="crispEdges" role="img" aria-label="clean pixel opencode pet">
+  <g class="session-balls">${balls}</g>
+  <g class="pet-shadow" opacity="0.22">
+    ${rect({ x: 54, y: 206, w: 108, h: 10, fill: "#000000" })}
+    ${rect({ x: 70, y: 216, w: 76, h: 6, fill: "#000000" })}
+  </g>
+  <g class="pet-body">
+    ${rect({ x: 66, y: 184, w: 26, h: 22, fill: "#050505" })}
+    ${rect({ x: 124, y: 184, w: 26, h: 22, fill: "#050505" })}
+    ${rect({ x: 72, y: 184, w: 18, h: 8, fill: "#242424" })}
+    ${rect({ x: 130, y: 184, w: 18, h: 8, fill: "#242424" })}
+    ${rect({ x: 34, y: 110, w: 18, h: 42, fill: "#080808" })}
+    ${rect({ x: 44, y: 118, w: 12, h: 30, fill: "#242424" })}
+    ${rect({ x: 158, y: 110, w: 18, h: 42, fill: "#080808" })}
+    ${rect({ x: 158, y: 118, w: 12, h: 30, fill: "#242424" })}
+    ${rect({ x: 24, y: 148, w: 18, h: 16, fill: "#050505" })}
+    ${rect({ x: 30, y: 150, w: 14, h: 10, fill: "#242424" })}
+    ${rect({ x: 168, y: 148, w: 18, h: 16, fill: "#050505" })}
+    ${rect({ x: 166, y: 150, w: 14, h: 10, fill: "#242424" })}
+    ${rect({ x: 50, y: 62, w: 112, h: 120, fill: "#050505" })}
+    ${rect({ x: 42, y: 82, w: 128, h: 80, fill: "#050505" })}
+    ${rect({ x: 58, y: 54, w: 96, h: 16, fill: "#242424" })}
+    ${rect({ x: 58, y: 70, w: 96, h: 16, fill: "#1a1a1a" })}
+    ${rect({ x: 58, y: 162, w: 96, h: 16, fill: "#171717" })}
+    ${rect({ x: 58, y: 86, w: 10, h: 66, fill: "#2b2b2b", opacity: 0.9 })}
+    ${rect({ x: 142, y: 86, w: 10, h: 66, fill: "#000000", opacity: 0.9 })}
+    ${rect({ x: 72, y: 82, w: 74, h: 86, fill: "#2d2d2d" })}
+    ${rect({ x: 76, y: 86, w: 66, h: 78, fill: "#d8d5cc" })}
+    ${rect({ x: 82, y: 92, w: 54, h: 66, fill: "#f8f7f2" })}
+    ${rect({ x: 86, y: 96, w: 46, h: 58, fill: "#ffffff" })}
+    ${rect({ x: 98, y: 110, w: 24, h: 38, fill: "#050505" })}
+    ${rect({ x: 98, y: 110, w: 24, h: 10, fill: "#111111" })}
+    ${rect({ x: 26, y: 120, w: 28, h: 10, fill: "#050505" })}
+    ${rect({ x: 22, y: 114, w: 16, h: 16, fill: "#050505" })}
+    ${rect({ x: 28, y: 116, w: 10, h: 8, fill: "#2f2f2f" })}
+    ${rect({ x: 156, y: 120, w: 28, h: 10, fill: "#050505" })}
+    ${rect({ x: 176, y: 114, w: 16, h: 16, fill: "#050505" })}
+    ${rect({ x: 174, y: 116, w: 10, h: 8, fill: "#2f2f2f" })}
+  </g>
+  ${showCaption ? `<text x="24" y="238" fill="#111" font-family="ui-monospace, SFMono-Regular, Menlo, monospace" font-size="10">clean pixel opencode pet · ${count} session balls</text>` : ""}
+</svg>`
+}
+
+const pixelPetCss = `
+.pixel-opencode-pet {
+  width: 256px;
+  height: 256px;
+  image-rendering: pixelated;
+  shape-rendering: crispEdges;
+}
+
+.pixel-opencode-pet .session-ball {
+  transform-origin: center;
+  animation: pet-ball-bob 1.45s steps(4, end) infinite;
+}
+
+.pixel-opencode-pet .session-ball:nth-of-type(4n + 1) { animation-delay: -0.15s; }
+.pixel-opencode-pet .session-ball:nth-of-type(4n + 2) { animation-delay: -0.35s; }
+.pixel-opencode-pet .session-ball:nth-of-type(4n + 3) { animation-delay: -0.55s; }
+
+@keyframes pet-ball-bob {
+  0%, 100% { transform: translateY(0); }
+  50% { transform: translateY(-6px); }
+}
+`
+
+function pixelPetHtmlSnippet(options = {}) {
+  return `<style>${pixelPetCss}</style>\n<div class="pixel-opencode-pet">${pixelPetSvg(options)}</div>`
+}
+
+module.exports = {
+  DEFAULT_SESSION_COLORS,
+  pixelPetCss,
+  pixelPetHtmlSnippet,
+  pixelPetSvg,
+}

package/src/plugin-server.cjs

@@ -0,0 +1,169 @@
+const { quitPet, sendEvent, showPet } = require("./plugin-shared.cjs")
+
+const COMMAND_HANDLED_SENTINEL = "__OPENCODE_PET_COMMAND_HANDLED__"
+const CUB_ICON = "◈"
+
+function handled() {
+  throw new Error(COMMAND_HANDLED_SENTINEL)
+}
+
+function textOfArguments(args) {
+  if (typeof args === "string") return args.trim().toLowerCase()
+  if (Array.isArray(args)) return args.join(" ").trim().toLowerCase()
+  if (args == null) return ""
+  return String(args).trim().toLowerCase()
+}
+
+function shouldQuit(input) {
+  const args = textOfArguments(input.arguments)
+  return input.command === "pet_stop" || ["stop", "quit", "close", "off"].includes(args)
+}
+
+function isSayHello(input) {
+  return input.command === "pet_say_hello"
+}
+
+function isFancySayHello(input) {
+  return input.command === "pet_fancy_say_hello"
+}
+
+async function injectNotice(client, sessionID, text) {
+  if (!sessionID || !client?.session?.prompt) return
+
+  try {
+    await client.session.prompt({
+      path: { id: sessionID },
+      body: {
+        noReply: true,
+        parts: [{ type: "text", text, ignored: true }],
+      },
+    })
+  } catch {
+    // Best-effort only: launching/quitting the pet should still count as handled.
+  }
+}
+
+function cubNotice(text, icon = CUB_ICON) {
+  return `${icon} ${text}`
+}
+
+module.exports = {
+  id: "opencode-pet",
+  server: async ({ client }) => {
+    const sessionStatus = new Map()
+
+    return {
+      // Same trick as @slkiser/opencode-quota: register normal slash commands in
+      // config, then abort command.execute.before after doing the side effect.
+      // This makes /pet show up in opencode's slash list but avoids an LLM reply.
+      config: async (cfg) => {
+        cfg.command ??= {}
+        cfg.command.pet = {
+          template: "/pet",
+          description: "Show the desktop opencode pet without sending anything to the agent.",
+        }
+        cfg.command.pet_stop = {
+          template: "/pet_stop",
+          description: "Quit the desktop opencode pet without sending anything to the agent.",
+        }
+        cfg.command.pet_say_hello = {
+          template: "/pet_say_hello",
+          description: "Send a hello test event to OpenCub.",
+        }
+        cfg.command.pet_fancy_say_hello = {
+          template: "/pet_fancy_say_hello",
+          description: "Trigger a randomized light show on OpenCub's free faces.",
+        }
+      },
+
+      "command.execute.before": async (input, output) => {
+        if (!["pet", "pet_stop", "pet_say_hello", "pet_fancy_say_hello"].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
+        // the slash-command prompt to the model. Desktop may show it as an
+        // "Unexpected server error" toast, but this is currently the only path
+        // that reliably prevents empty prompts / model continuation.
+
+        if (shouldQuit(input)) {
+          await quitPet()
+          await injectNotice(client, input.sessionID, cubNotice("OpenCub is going to sleep 🐾", "◌"))
+        } else if (isSayHello(input)) {
+          const result = await sendEvent({
+            type: "hello",
+            message: "hello from opencode 🐾",
+            command: input.command,
+            arguments: input.arguments,
+            sessionID: input.sessionID,
+            source: "opencode-pet-plugin",
+          })
+          await injectNotice(
+            client,
+            input.sessionID,
+            result ? cubNotice("OpenCub got your hello 🐾", "✦") : cubNotice("OpenCub is sleeping... zzz  Use /pet to wake it.", "☾"),
+          )
+        } else if (isFancySayHello(input)) {
+          const result = await sendEvent({
+            type: "fancy_hello",
+            message: "fancy hello light show from opencode ✨",
+            command: input.command,
+            arguments: input.arguments,
+            sessionID: input.sessionID,
+            source: "opencode-pet-plugin",
+          })
+          await injectNotice(
+            client,
+            input.sessionID,
+            result
+              ? cubNotice("OpenCub is putting on a light show ✨", "✺")
+              : cubNotice("OpenCub is sleeping... zzz  Start it with /pet before the light show.", "☾"),
+          )
+        } else {
+          await showPet({
+            onProgress: (message) => injectNotice(client, input.sessionID, message),
+          })
+        }
+
+        handled()
+      },
+
+      event: async ({ event }) => {
+        if (event.type !== "session.status") return
+
+        const sessionID = event.properties?.sessionID
+        const status = event.properties?.status?.type
+        if (!sessionID || !status) return
+
+        const previous = sessionStatus.get(sessionID) || "idle"
+
+        if (status === "busy" || status === "retry") {
+          sessionStatus.set(sessionID, status)
+          if (previous === "busy" || previous === "retry") return
+
+          await sendEvent({
+            type: "session.busy",
+            message: "opencode session became busy",
+            sessionID,
+            status,
+            previousStatus: previous,
+            source: "opencode-pet-plugin",
+          })
+          return
+        }
+
+        if (status !== "idle") return
+        sessionStatus.set(sessionID, status)
+        if (previous !== "busy" && previous !== "retry") return
+
+        await sendEvent({
+          type: "session.idle",
+          message: "opencode session became idle",
+          sessionID,
+          status,
+          previousStatus: previous,
+          source: "opencode-pet-plugin",
+        })
+      },
+    }
+  },
+}

package/src/plugin-shared.cjs

@@ -0,0 +1,230 @@
+const { execFile, spawn } = require("node:child_process")
+const fs = require("node:fs")
+const os = require("node:os")
+const path = require("node:path")
+
+const PET_APP_DIR = path.resolve(__dirname, "..")
+const PET_HOST = "127.0.0.1"
+const PET_PORT = Number(process.env.OPENCODE_PET_PORT || 47832)
+const PET_BASE_URL = `http://${PET_HOST}:${PET_PORT}`
+
+function electronPlatformPath() {
+  const platform = process.env.npm_config_platform || os.platform()
+  switch (platform) {
+    case "mas":
+    case "darwin":
+      return "Electron.app/Contents/MacOS/Electron"
+    case "freebsd":
+    case "openbsd":
+    case "linux":
+      return "electron"
+    case "win32":
+      return "electron.exe"
+    default:
+      throw new Error(`Electron builds are not available on platform: ${platform}`)
+  }
+}
+
+async function emitProgress(onProgress, message) {
+  if (!onProgress) return
+  try {
+    await onProgress(message)
+  } catch {
+    // Progress is best-effort; never block OpenCub startup on UI notices.
+  }
+}
+
+function execFileAsync(file, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = execFile(file, args, options, (error, stdout, stderr) => {
+      if (error) {
+        error.stdout = stdout
+        error.stderr = stderr
+        reject(error)
+        return
+      }
+      resolve({ stdout, stderr })
+    })
+    child.on("error", reject)
+  })
+}
+
+async function extractElectronZip(zipPath, distPath) {
+  await fs.promises.rm(distPath, { recursive: true, force: true })
+  await fs.promises.mkdir(distPath, { recursive: true })
+
+  // extract-zip can hang under opencode desktop's Electron/Node service on
+  // macOS after partially writing Electron.app. Use the native archive tool
+  // there; keep extract-zip as the portable fallback for other platforms.
+  if ((process.env.npm_config_platform || process.platform) === "darwin") {
+    await execFileAsync("/usr/bin/ditto", ["-x", "-k", zipPath, distPath], { timeout: 120000 })
+    return
+  }
+
+  const extract = require("extract-zip")
+  await extract(zipPath, { dir: distPath })
+}
+
+async function installElectronBinary(electronDir, options = {}) {
+  const { downloadArtifact } = require("@electron/get")
+  const { version } = require(path.join(electronDir, "package.json"))
+  const checksums = require(path.join(electronDir, "checksums.json"))
+  const platform = process.env.npm_config_platform || process.platform
+  const arch = process.env.npm_config_arch || process.arch
+  const platformPath = electronPlatformPath()
+  const distPath = path.join(electronDir, "dist")
+  const executablePath = path.join(distPath, platformPath)
+
+  if (fs.existsSync(executablePath)) {
+    await emitProgress(options.onProgress, "OpenCub: Electron binary is ready ✅")
+    return executablePath
+  }
+
+  await emitProgress(options.onProgress, `OpenCub: downloading Electron ${version} for ${platform}/${arch}...`)
+  const zipPath = await downloadArtifact({
+    version,
+    artifactName: "electron",
+    cacheRoot: process.env.electron_config_cache,
+    checksums,
+    platform,
+    arch,
+  })
+  await emitProgress(options.onProgress, "OpenCub: extracting Electron binary...")
+  await extractElectronZip(zipPath, distPath)
+  await fs.promises.writeFile(path.join(electronDir, "path.txt"), platformPath)
+  await emitProgress(options.onProgress, "OpenCub: Electron binary installed ✅")
+  return executablePath
+}
+
+async function resolveElectronPath(options = {}) {
+  await emitProgress(options.onProgress, "OpenCub: checking Electron runtime...")
+  try {
+    const electronPath = require("electron")
+    if (typeof electronPath === "string") {
+      await emitProgress(options.onProgress, "OpenCub: Electron runtime is ready ✅")
+      return electronPath
+    }
+
+    // In opencode desktop, plugins may run inside an Electron process. In that
+    // environment require("electron") can resolve to Electron's built-in API
+    // object instead of the npm package's executable path string. Fall through
+    // to the npm package directory and resolve/repair the packaged binary.
+    await emitProgress(options.onProgress, "OpenCub: locating packaged Electron binary...")
+    const electronPackage = require.resolve("electron/package.json")
+    const electronDir = path.dirname(electronPackage)
+    return await installElectronBinary(electronDir, options)
+  } catch (error) {
+    await emitProgress(options.onProgress, "OpenCub: Electron runtime is incomplete; repairing...")
+    const electronPackage = require.resolve("electron/package.json")
+    const electronDir = path.dirname(electronPackage)
+    return await installElectronBinary(electronDir, options)
+  }
+}
+
+async function launchPet(args = [], options = {}) {
+  const electronPath = await resolveElectronPath(options)
+  await emitProgress(options.onProgress, "OpenCub: launching desktop pet...")
+  const child = spawn(electronPath, [PET_APP_DIR, ...args], {
+    cwd: PET_APP_DIR,
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      OPENCODE_PET_ICON: path.join(PET_APP_DIR, "assets", "opencode-icon.png"),
+    },
+  })
+  child.unref()
+  await emitProgress(options.onProgress, "OpenCub: launch request sent 🐾")
+}
+
+async function requestPet(pathname, options = {}) {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 800)
+  try {
+    const response = await fetch(`${PET_BASE_URL}${pathname}`, {
+      method: options.method || "GET",
+      headers: {
+        "content-type": "application/json",
+        ...(options.headers || {}),
+      },
+      body: options.body === undefined ? undefined : JSON.stringify(options.body),
+      signal: controller.signal,
+    })
+    if (!response.ok) return undefined
+    return await response.json().catch(() => ({}))
+  } catch {
+    return undefined
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+async function healthPet() {
+  const health = await requestPet("/health", { timeoutMs: 500 })
+  return health?.status === "good" ? health : undefined
+}
+
+async function waitForPet(timeoutMs = 3500, options = {}) {
+  await emitProgress(options.onProgress, "OpenCub: waiting for local server...")
+  const startedAt = Date.now()
+  while (Date.now() - startedAt < timeoutMs) {
+    const health = await healthPet()
+    if (health) {
+      await emitProgress(options.onProgress, "OpenCub: local server is ready ✅")
+      return health
+    }
+    await new Promise((resolve) => setTimeout(resolve, 150))
+  }
+  await emitProgress(options.onProgress, "OpenCub: local server did not answer yet")
+  return undefined
+}
+
+async function ensurePet(options = {}) {
+  await emitProgress(options.onProgress, "OpenCub: checking whether it is already running...")
+  const existing = await healthPet()
+  if (existing) {
+    await emitProgress(options.onProgress, "OpenCub: already running; showing window...")
+    return existing
+  }
+  await emitProgress(options.onProgress, "OpenCub: not running; starting now...")
+  await launchPet(["--show"], options)
+  return await waitForPet(3500, options)
+}
+
+async function showPet(options = {}) {
+  const health = await ensurePet(options)
+  await requestPet("/show", { method: "POST", timeoutMs: 800 })
+  await emitProgress(options.onProgress, health ? "OpenCub: shown ✨" : "OpenCub: start requested, still warming up...")
+  return health
+}
+
+async function quitPet() {
+  const health = await healthPet()
+  if (health) {
+    await requestPet("/quit", { method: "POST", timeoutMs: 800 })
+    return true
+  }
+  return false
+}
+
+async function sendEvent(event) {
+  // Only /pet is allowed to start OpenCub. Session lifecycle events and hello
+  // commands should talk to the desktop pet only if it is already running.
+  const health = await healthPet()
+  if (!health) return undefined
+  return await requestPet("/event", { method: "POST", body: event, timeoutMs: 1000 })
+}
+
+module.exports = {
+  PET_APP_DIR,
+  PET_BASE_URL,
+  PET_HOST,
+  PET_PORT,
+  ensurePet,
+  healthPet,
+  launchPet,
+  quitPet,
+  requestPet,
+  sendEvent,
+  showPet,
+}

package/src/plugin-tui.cjs

@@ -0,0 +1,7 @@
+module.exports = {
+  id: "opencode-pet",
+  // Slash commands are registered from the server plugin via cfg.command, using
+  // the same command.execute.before abort trick as @slkiser/opencode-quota.
+  // Keep a no-op TUI entry so opencode can load ./tui without duplicate /pet rows.
+  tui: async () => {},
+}