@hayasaka7/haya-pet 0.1.0

package/apps/companion/src/main/index.js

@@ -0,0 +1,349 @@
+import { app, BrowserWindow, ipcMain, Menu, nativeImage, screen, Tray } from "electron";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { createDaemonRuntime } from "../../../../packages/daemon-core/src/daemon-runtime.js";
+import { createIpcServer } from "../../../../packages/daemon-core/src/ipc-server.js";
+import { getDefaultPaths } from "../../../../packages/platform-core/src/paths.js";
+import { getPlatformCapabilities } from "../../../../packages/platform-core/src/capabilities.js";
+import { buildBubbleViews } from "../../../../packages/session-core/src/bubble-view.js";
+import { buildPetWindowOptions, PET_SIZE } from "./window-options.js";
+import { resolveSavedPosition } from "./display-manager.js";
+import { setSelectedPet, updateGlobalPetPosition } from "./position-store.js";
+import { buildTrayMenu } from "./tray-menu.js";
+import { createStateFile } from "./state-file.js";
+import { discoverPets } from "./pet-loader.js";
+
+const STALE_SWEEP_INTERVAL_MS = 10_000;
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Fallback tray icon (16×16 blue dot) used when no tray.png asset is present, so
+// the tray — and therefore the Quit menu — always appears. Without it, a missing
+// icon left users with no way to exit.
+const TRAY_ICON_DATA_URL =
+  "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAANElEQVR4nGNgoAXIW/HvPzZMtkaiDCJWM05DKDKAVM0YhowaQAUDBj4dUCUpE2MQQY3kAACyf/g8DHVl5wAAAABJRU5ErkJggg==";
+
+const paths = getDefaultPaths();
+const capabilities = getPlatformCapabilities();
+const stateFile = createStateFile({ statePath: paths.statePath });
+
+let petWindow;
+let tray;
+let ipcServer;
+let positionState;
+let pets = [];
+let runtime;
+// The overlay window spans this work area; the pet is positioned *inside* it at
+// `petLocal` (work-area-relative coords) and moved via CSS rather than by moving
+// the window, so the bubble panel can always be placed on-screen beside it.
+let currentWorkArea;
+let currentDisplayId;
+let petLocal = { x: 0, y: 0 };
+
+// Electron singleton: a second launch forwards to the running instance.
+if (!app.requestSingleInstanceLock()) {
+  app.quit();
+} else {
+  app.on("second-instance", () => focusPet());
+  app.whenReady().then(bootstrap).catch((error) => {
+    console.error("haya-pet companion failed to start:", error);
+    app.quit();
+  });
+}
+
+async function bootstrap() {
+  positionState = await stateFile.load();
+  pets = await discoverPets(paths.petSearchPaths);
+
+  runtime = createDaemonRuntime({
+    onSessionChanged: () => pushSessions()
+  });
+
+  ipcServer = await createIpcServer({
+    endpoint: paths.ipcEndpoint,
+    onMessage: (message) => {
+      // `haya-pet stop` asks the daemon to exit; everything else is a session event.
+      if (message?.type === "shutdown") {
+        app.quit();
+        return;
+      }
+      return runtime.handleMessage(message);
+    },
+    onProtocolError: (error) => console.error("protocol error:", error.message)
+  });
+
+  createPetWindow();
+  createTray();
+  registerRendererHandlers();
+
+  const sweep = setInterval(() => {
+    runtime.markStaleSessions(Date.now());
+    // Refresh the renderer so dropped (dead/finished) sessions disappear and the
+    // pet settles to idle even when no new session event fires.
+    pushSessions();
+  }, STALE_SWEEP_INTERVAL_MS);
+  sweep.unref?.();
+
+  app.on("before-quit", async () => {
+    clearInterval(sweep);
+    await ipcServer?.close();
+  });
+}
+
+function createPetWindow() {
+  const displays = listDisplays();
+  // Resolve the pet's saved on-screen position (pet-sized), which also tells us
+  // which display it belongs on. The window then spans that display's work area.
+  const saved = resolveSavedPosition(positionState.globalPet, displays);
+  const display = displays.find((d) => d.id === saved.displayId)
+    ?? displays.find((d) => d.primary)
+    ?? displays[0];
+  currentWorkArea = display.workArea ?? display.bounds;
+  currentDisplayId = display.id;
+  petLocal = clampPetLocal({ x: saved.x - currentWorkArea.x, y: saved.y - currentWorkArea.y });
+
+  const { browserWindow } = buildPetWindowOptions({ capabilities, bounds: currentWorkArea });
+
+  petWindow = new BrowserWindow({
+    ...browserWindow,
+    webPreferences: {
+      preload: join(__dirname, "preload.cjs"),
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: false
+    }
+  });
+
+  petWindow.setVisibleOnAllWorkspaces?.(true, { visibleOnFullScreen: true });
+  // The whole work area is covered, so empty area MUST pass clicks through to the
+  // desktop; the renderer re-enables interaction (via haya-pet:set-mouse-ignore)
+  // only over the pet + bubbles.
+  petWindow.setIgnoreMouseEvents(true, { forward: true });
+  petWindow.loadFile(join(__dirname, "..", "renderer", "index.html"));
+  petWindow.webContents.on("did-finish-load", () => {
+    sendPetConfig();
+    pushSessions();
+  });
+}
+
+function clampPetLocal(local) {
+  const maxX = Math.max(0, (currentWorkArea?.width ?? PET_SIZE.width) - PET_SIZE.width);
+  const maxY = Math.max(0, (currentWorkArea?.height ?? PET_SIZE.height) - PET_SIZE.height);
+  return {
+    x: Math.min(Math.max(local.x ?? 0, 0), maxX),
+    y: Math.min(Math.max(local.y ?? 0, 0), maxY)
+  };
+}
+
+function createTray() {
+  try {
+    tray = new Tray(loadTrayIcon());
+    tray.setToolTip("Haya Pet — right-click to Quit");
+  } catch (error) {
+    // A failed tray must not take the whole app down; log and continue.
+    console.error("tray unavailable:", error.message);
+    return;
+  }
+  refreshTrayMenu();
+}
+
+function loadTrayIcon() {
+  const fileIcon = nativeImage.createFromPath(join(__dirname, "..", "renderer", "assets", "tray.png"));
+  // createFromPath returns an empty image (no throw) when the file is missing.
+  return fileIcon.isEmpty() ? nativeImage.createFromDataURL(TRAY_ICON_DATA_URL) : fileIcon;
+}
+
+function refreshTrayMenu() {
+  if (!tray) {
+    return;
+  }
+
+  const sessions = (runtime?.listSessions() ?? []).map((session) => ({
+    sessionId: session.sessionId,
+    label: `${session.clientDisplayName} · ${session.projectName}`
+  }));
+
+  const template = buildTrayMenu({
+    petVisible: petWindow?.isVisible() ?? true,
+    displayMode: positionState.settings.displayMode,
+    attachBubblesToTerminals: positionState.settings.attachBubblesToTerminals,
+    selectedPetId: positionState.globalPet.selectedPetId,
+    sessions,
+    pets: pets.map((pet) => ({ id: pet.manifest.id, name: pet.manifest.name }))
+  }).map(toElectronMenuItem);
+
+  tray.setContextMenu(Menu.buildFromTemplate(template));
+}
+
+function toElectronMenuItem(item) {
+  if (item.type === "separator") {
+    return { type: "separator" };
+  }
+
+  const electronItem = {
+    label: item.label,
+    type: item.type === "checkbox" || item.type === "radio" ? item.type : undefined,
+    checked: item.checked,
+    enabled: item.enabled !== false
+  };
+
+  if (item.submenu) {
+    electronItem.submenu = item.submenu.map(toElectronMenuItem);
+  } else {
+    electronItem.click = () => handleTrayClick(item);
+  }
+
+  return electronItem;
+}
+
+function handleTrayClick(item) {
+  switch (item.id) {
+    case "toggle_pet":
+      togglePet();
+      break;
+    case "reset_position":
+      resetPosition();
+      break;
+    case "quit":
+      app.quit();
+      break;
+    default:
+      if (item.id?.startsWith("display_mode:")) {
+        setDisplayMode(item.value);
+      } else if (item.id === "attach_bubbles") {
+        toggleAttachBubbles();
+      } else if (item.petId) {
+        selectPet(item.petId);
+      }
+  }
+}
+
+function registerRendererHandlers() {
+  ipcMain.handle("haya-pet:list-sessions", () => buildSessionPayload());
+
+  // Fired on every cursor move while hovering the overlay, so use the
+  // fire-and-forget channel (no round-trip) to toggle click-through.
+  ipcMain.on("haya-pet:set-mouse-ignore", (_event, ignore) => {
+    if (petWindow && !petWindow.isDestroyed()) {
+      petWindow.setIgnoreMouseEvents(Boolean(ignore), { forward: true });
+    }
+  });
+
+  // The pet moves within the overlay (CSS), so the renderer reports its new
+  // work-area-relative position instead of moving the window.
+  ipcMain.handle("haya-pet:save-pet-position", async (_event, local) => {
+    petLocal = clampPetLocal(local ?? petLocal);
+    persistPetPosition();
+    return petLocal;
+  });
+}
+
+function buildSessionPayload() {
+  const sessions = runtime?.listSessions() ?? [];
+  const priority = runtime?.getPrioritySession({ pinnedSessionId: positionState.globalPet.selectedSessionId });
+
+  return {
+    bubbles: buildBubbleViews(sessions, Date.now(), {
+      selectedSessionId: priority?.sessionId
+    }),
+    prioritySessionId: priority?.sessionId
+  };
+}
+
+function pushSessions() {
+  refreshTrayMenu();
+  if (petWindow && !petWindow.isDestroyed()) {
+    petWindow.webContents.send("haya-pet:sessions", buildSessionPayload());
+  }
+}
+
+function sendPetConfig() {
+  const selected = pets.find((pet) => pet.manifest.id === positionState.globalPet.selectedPetId) ?? pets[0];
+  petWindow.webContents.send("haya-pet:config", {
+    pet: selected
+      ? { manifest: selected.manifest, spritesheetUrl: selected.spritesheetUrl }
+      : undefined,
+    overlayMode: capabilities.transparentOverlay === "required" ? "transparent-overlay" : "fallback-window",
+    petPosition: petLocal
+  });
+}
+
+function sendPetPosition() {
+  petWindow?.webContents.send("haya-pet:pet-position", petLocal);
+}
+
+let persistTimer;
+function persistPetPosition() {
+  if (!currentWorkArea) {
+    return;
+  }
+
+  // Store the pet's absolute on-screen top-left so it can be restored on the
+  // right display, mapping the in-window position back to screen coordinates.
+  positionState = updateGlobalPetPosition(positionState, {
+    x: currentWorkArea.x + petLocal.x,
+    y: currentWorkArea.y + petLocal.y,
+    width: PET_SIZE.width,
+    height: PET_SIZE.height,
+    displayId: currentDisplayId
+  });
+
+  // Debounce disk writes during drag (positionSaveDebounce, plan section 27).
+  clearTimeout(persistTimer);
+  persistTimer = setTimeout(() => {
+    stateFile.save(positionState).catch((error) => console.error("save failed:", error.message));
+  }, 200);
+}
+
+function togglePet() {
+  if (!petWindow) {
+    return;
+  }
+  petWindow.isVisible() ? petWindow.hide() : petWindow.show();
+  refreshTrayMenu();
+}
+
+function focusPet() {
+  petWindow?.show();
+}
+
+function resetPosition() {
+  // Drop the pet back to the bottom-right corner of its work area.
+  const margin = 24;
+  petLocal = clampPetLocal({
+    x: (currentWorkArea?.width ?? PET_SIZE.width) - PET_SIZE.width - margin,
+    y: (currentWorkArea?.height ?? PET_SIZE.height) - PET_SIZE.height - margin
+  });
+  sendPetPosition();
+  persistPetPosition();
+}
+
+function setDisplayMode(displayMode) {
+  positionState = { ...positionState, settings: { ...positionState.settings, displayMode } };
+  stateFile.save(positionState).catch(() => {});
+  petWindow?.webContents.send("haya-pet:display-mode", displayMode);
+  refreshTrayMenu();
+}
+
+function toggleAttachBubbles() {
+  const attachBubblesToTerminals = !positionState.settings.attachBubblesToTerminals;
+  positionState = { ...positionState, settings: { ...positionState.settings, attachBubblesToTerminals } };
+  stateFile.save(positionState).catch(() => {});
+  refreshTrayMenu();
+}
+
+function selectPet(petId) {
+  positionState = setSelectedPet(positionState, petId);
+  stateFile.save(positionState).catch(() => {});
+  sendPetConfig();
+  refreshTrayMenu();
+}
+
+function listDisplays() {
+  return screen.getAllDisplays().map((display) => ({
+    id: String(display.id),
+    primary: display.id === screen.getPrimaryDisplay().id,
+    bounds: display.bounds,
+    workArea: display.workArea,
+    scaleFactor: display.scaleFactor
+  }));
+}

package/apps/companion/src/main/lock-file.js

@@ -0,0 +1,52 @@
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import {
+  parseLock,
+  resolveSingletonAction,
+  serializeLock
+} from "../../../../packages/daemon-core/src/singleton.js";
+
+// IPC-socket / PID-file singleton fallback (product plan section 39). Electron's
+// app.requestSingleInstanceLock() is the primary guard; this lock lets wrappers
+// and non-Electron callers detect and reclaim a stale daemon.
+export async function acquireDaemonLock({ lockPath, pid = process.pid, endpoint, now = Date.now, isAlive = defaultIsAlive }) {
+  const existing = await readLock(lockPath);
+  const action = resolveSingletonAction({ lock: existing, isAlive });
+
+  if (action === "forward") {
+    return { acquired: false, action, lock: existing };
+  }
+
+  const lock = { pid, startedAt: now(), endpoint };
+  await mkdir(dirname(lockPath), { recursive: true });
+  await writeFile(lockPath, serializeLock(lock));
+
+  return { acquired: true, action, lock };
+}
+
+export async function releaseDaemonLock(lockPath) {
+  try {
+    await unlink(lockPath);
+  } catch (error) {
+    if (error && error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+
+async function readLock(lockPath) {
+  try {
+    return parseLock(await readFile(lockPath, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+function defaultIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}

package/apps/companion/src/main/panel-placement.js

@@ -0,0 +1,45 @@
+// Decides where a panel (task talk window / bubble cluster) should sit relative
+// to the pet so it sits *beside* the pet — never on top of it — and stays fully
+// inside the visible work area. Picks the side with the most room: right, then
+// left, then below, then above, clamping the cross-axis to the work area.
+const DEFAULT_GAP = 8;
+
+export function resolvePanelPlacement({ pet, panel, workArea, gap = DEFAULT_GAP } = {}) {
+  const right = pet.x + pet.width + gap;
+  const left = pet.x - gap - panel.width;
+  const below = pet.y + pet.height + gap;
+  const above = pet.y - gap - panel.height;
+
+  const areaRight = workArea.x + workArea.width;
+  const areaBottom = workArea.y + workArea.height;
+
+  if (right + panel.width <= areaRight) {
+    return { side: "right", x: right, y: clampAxis(pet.y, panel.height, workArea.y, areaBottom) };
+  }
+
+  if (left >= workArea.x) {
+    return { side: "left", x: left, y: clampAxis(pet.y, panel.height, workArea.y, areaBottom) };
+  }
+
+  if (below + panel.height <= areaBottom) {
+    return { side: "below", x: clampAxis(pet.x, panel.width, workArea.x, areaRight), y: below };
+  }
+
+  if (above >= workArea.y) {
+    return { side: "above", x: clampAxis(pet.x, panel.width, workArea.x, areaRight), y: above };
+  }
+
+  // No clear room on any side (tiny screen): overlap as a last resort, clamped.
+  return {
+    side: "overlap",
+    x: clampAxis(pet.x, panel.width, workArea.x, areaRight),
+    y: clampAxis(pet.y, panel.height, workArea.y, areaBottom)
+  };
+}
+
+function clampAxis(start, size, min, max) {
+  if (start + size > max) {
+    return Math.max(min, max - size);
+  }
+  return Math.max(min, start);
+}

package/apps/companion/src/main/pet-loader.js

@@ -0,0 +1,2 @@
+// Re-exported from pet-core so the companion and CLI share one discovery path.
+export { discoverPets, loadPetFromDir } from "../../../../packages/pet-core/src/discovery.js";

package/apps/companion/src/main/position-store.js

@@ -0,0 +1,3 @@
+// Re-exported from the shared app-state package so the companion and the CLI
+// operate on the same state shape and selection helpers.
+export * from "../../../../packages/app-state/src/state.js";

package/apps/companion/src/main/preload.cjs

@@ -0,0 +1,13 @@
+const { contextBridge, ipcRenderer } = require("electron");
+
+// Minimal, safe bridge between the sandboxed renderer and the main process.
+// No Node APIs are exposed to the renderer directly.
+contextBridge.exposeInMainWorld("aiPet", {
+  listSessions: () => ipcRenderer.invoke("haya-pet:list-sessions"),
+  savePetPosition: (local) => ipcRenderer.invoke("haya-pet:save-pet-position", local),
+  setMouseIgnore: (ignore) => ipcRenderer.send("haya-pet:set-mouse-ignore", ignore),
+  onConfig: (handler) => ipcRenderer.on("haya-pet:config", (_event, config) => handler(config)),
+  onSessions: (handler) => ipcRenderer.on("haya-pet:sessions", (_event, payload) => handler(payload)),
+  onPetPosition: (handler) => ipcRenderer.on("haya-pet:pet-position", (_event, pos) => handler(pos)),
+  onDisplayMode: (handler) => ipcRenderer.on("haya-pet:display-mode", (_event, mode) => handler(mode))
+});

package/apps/companion/src/main/state-file.js

@@ -0,0 +1,2 @@
+// Re-exported from the shared app-state package (see ./position-store.js).
+export * from "../../../../packages/app-state/src/state-file.js";

package/apps/companion/src/main/terminal-helper-client.js

@@ -0,0 +1,79 @@
+// Node-side client for the native terminal-window helper. Spawns the helper
+// process and speaks the line-delimited JSON protocol from native/README.md,
+// correlating responses to requests by id. `spawn` is injectable for tests.
+export function createHelperClient({ spawn, command, args = [] } = {}) {
+  if (typeof spawn !== "function") {
+    throw new TypeError("spawn must be a function");
+  }
+  if (typeof command !== "string" || command.trim() === "") {
+    throw new Error("command is required");
+  }
+
+  const child = spawn(command, args, { stdio: ["pipe", "pipe", "inherit"] });
+  const pending = new Map();
+  let counter = 0;
+  let buffer = "";
+
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk.toString("utf8");
+    let newlineIndex = buffer.indexOf("\n");
+    while (newlineIndex !== -1) {
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      handleLine(line);
+      newlineIndex = buffer.indexOf("\n");
+    }
+  });
+
+  child.on?.("error", (error) => rejectAll(error));
+  child.on?.("close", () => rejectAll(new Error("helper process closed")));
+
+  function handleLine(line) {
+    if (line.trim() === "") {
+      return;
+    }
+
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return; // ignore non-protocol noise
+    }
+
+    const entry = pending.get(message.id);
+    if (entry) {
+      pending.delete(message.id);
+      entry.resolve(message);
+    }
+  }
+
+  function rejectAll(error) {
+    for (const entry of pending.values()) {
+      entry.reject(error);
+    }
+    pending.clear();
+  }
+
+  function request(op, params = {}) {
+    const id = `req_${counter++}`;
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      child.stdin.write(`${JSON.stringify({ id, op, ...params })}\n`);
+    });
+  }
+
+  return {
+    capabilities() {
+      return request("capabilities");
+    },
+
+    locate(pid, terminalPid) {
+      return request("locate", terminalPid === undefined ? { pid } : { pid, terminalPid });
+    },
+
+    async close() {
+      child.stdin.end?.();
+      child.kill?.();
+    }
+  };
+}

package/apps/companion/src/main/terminal-locator.js

@@ -0,0 +1,44 @@
+import { normalizePlatform } from "../../../../packages/platform-core/src/platform.js";
+
+export function getTerminalAttachmentStrategy(options = {}) {
+  const platform = normalizePlatform(options.platform);
+  const env = options.env ?? process.env;
+
+  if (platform === "windows") {
+    return {
+      supported: "best-effort",
+      strategy: "win32-window-helper",
+      reason: "Windows terminal windows require process tree and HWND lookup."
+    };
+  }
+
+  if (platform === "macos") {
+    return {
+      supported: "best-effort",
+      strategy: "macos-accessibility-helper",
+      reason: "macOS terminal attachment requires Accessibility or window-list permissions."
+    };
+  }
+
+  if (platform === "linux" && env.WAYLAND_DISPLAY) {
+    return {
+      supported: "fallback",
+      strategy: "manual-fallback",
+      reason: "Wayland commonly blocks global window positioning and terminal lookup."
+    };
+  }
+
+  if (platform === "linux") {
+    return {
+      supported: "best-effort",
+      strategy: "x11-window-helper",
+      reason: "X11 allows best-effort terminal window discovery."
+    };
+  }
+
+  return {
+    supported: "fallback",
+    strategy: "manual-fallback",
+    reason: "Unsupported platforms use manual bubble positioning."
+  };
+}

package/apps/companion/src/main/tray-menu.js

@@ -0,0 +1,79 @@
+// Pure tray menu model (product plan section 40). The Electron main process
+// converts these descriptors into a native Menu; keeping it pure makes the
+// recovery controls testable.
+
+const DISPLAY_MODES = Object.freeze([
+  { value: "global", label: "Global" },
+  { value: "cluster", label: "Cluster" },
+  { value: "per-terminal", label: "Per Terminal" },
+  { value: "hybrid", label: "Hybrid" }
+]);
+
+export function buildTrayMenu(state = {}) {
+  const sessions = Array.isArray(state.sessions) ? state.sessions : [];
+  const pets = Array.isArray(state.pets) ? state.pets : [];
+
+  return [
+    {
+      id: "toggle_pet",
+      label: state.petVisible ? "Hide Pet" : "Show Pet"
+    },
+    {
+      id: "display_mode",
+      label: "Display Mode",
+      submenu: DISPLAY_MODES.map((mode) => ({
+        id: `display_mode:${mode.value}`,
+        label: mode.label,
+        value: mode.value,
+        type: "radio",
+        checked: state.displayMode === mode.value
+      }))
+    },
+    {
+      id: "sessions",
+      label: "Active Sessions",
+      submenu: buildSessionItems(sessions)
+    },
+    {
+      id: "pets",
+      label: "Installed Pets",
+      submenu: buildPetItems(pets, state.selectedPetId)
+    },
+    {
+      id: "attach_bubbles",
+      label: "Attach Bubbles to Terminals",
+      type: "checkbox",
+      checked: Boolean(state.attachBubblesToTerminals)
+    },
+    { id: "reset_position", label: "Reset Position" },
+    { id: "settings", label: "Open Settings" },
+    { id: "separator", type: "separator" },
+    { id: "quit", label: "Quit" }
+  ];
+}
+
+function buildSessionItems(sessions) {
+  if (sessions.length === 0) {
+    return [{ id: "sessions:empty", label: "No active sessions", enabled: false }];
+  }
+
+  return sessions.map((session) => ({
+    id: `session:${session.sessionId}`,
+    label: session.label,
+    sessionId: session.sessionId
+  }));
+}
+
+function buildPetItems(pets, selectedPetId) {
+  if (pets.length === 0) {
+    return [{ id: "pets:empty", label: "No pets found", enabled: false }];
+  }
+
+  return pets.map((pet) => ({
+    id: `pet:${pet.id}`,
+    label: pet.name,
+    petId: pet.id,
+    type: "radio",
+    checked: pet.id === selectedPetId
+  }));
+}