@hayasaka7/haya-pet 0.2.6 → 0.2.8

package/CHANGELOG.md

@@ -7,6 +7,54 @@ All notable changes to HAYA Pet are documented here. This project adheres to
 > 0.2.0 npm publish; they are listed under 0.2.1, which is the first version that
 > ships them.
 
+## [0.2.8]
+
+### Fixed
+- **Scrolling the session panel no longer fights you.** With four or more
+  sessions the bubble panel scrolls (introduced in 0.2.7), but two bugs made it
+  unusable: the scroll position snapped back to the top on every status update,
+  and a wheel scroll or scrollbar drag would "disconnect" mid-gesture and need
+  restarting. Both came from the panel rebuilding its entire DOM on each refresh
+  (every session push plus a 2 s linger tick). The panel now renders
+  incrementally — the list and each session's bubble persist across updates and
+  are mutated in place — so the scroll position holds and a gesture stays
+  attached to its element. The status spinner also no longer restarts on every
+  refresh.
+
+## [0.2.7]
+
+### Fixed
+- **Codex `/quit` no longer hangs after its goodbye.** The `haya-pet state`
+  hook reporter could hang forever on a never-settling IPC await (pipe connect,
+  write drain, or close) — and Codex awaits each hook child with a default
+  **600 s** timeout, so a hung turn-end `state idle` reporter both froze the
+  pet on "working" and made `/quit` sit on its token-usage goodbye for up to
+  10 minutes (Ctrl+C worked because it kills Codex without the wait, orphaning
+  the reporter — observed live). The reporter now races its whole IPC
+  interaction against a 2 s deadline and always exits; the wrapper's own
+  companion connection gets the same guard (5 s) so a wedged companion can
+  never hold the terminal after the wrapped CLI exits.
+
+### Added
+- **Update notice.** HAYA Pet now checks npm (at most once a day, cached in
+  `state.json`, shared between the CLI and the overlay) for a newer published
+  version. The CLI prints a one-line notice after a wrapped command exits (and
+  after `haya-pet start`), and the tray gains an **Update Available (x.y.z)**
+  item that opens the package page — the app never runs npm itself. The check
+  is best-effort (3 s timeout, silent on any failure, never blocks a run),
+  skipped when stdout isn't a terminal, and can be disabled with
+  `HAYA_PET_NO_UPDATE_CHECK=1`.
+
+### Changed
+- **The bubble panel shows at most three sessions at once.** Beyond the existing
+  height budget (the room between the folder button and the screen edge), the
+  list now also caps its viewport at the bottom of the third bubble — more
+  sessions are reached by scrolling, so a busy machine no longer grows a
+  screen-tall stack. The list surface itself (gaps between bubbles and the
+  scrollbar) is now pointer-active so wheel scrolling and scrollbar dragging
+  work anywhere on the open panel, and the scrollbar is a slim dark-theme thumb
+  instead of the stock bar.
+
 ## [0.2.6]
 
 ### Fixed

package/README.md

@@ -248,6 +248,21 @@ exit code. Disable auto-start with `HAYA_PET_NO_AUTOSTART=1`.
 | Electron | Installed as a runtime dependency. |
 | node-pty | Optional; used only for `--observe`. |
 
+## Updates
+
+HAYA Pet checks npm for a newer published version at most once a day (cached in
+`state.json`). When one exists, the CLI prints a one-line notice after your
+wrapped command exits, and the tray shows **Update Available (x.y.z)** — clicking
+it opens the package page. Updating is always your action:
+
+```bash
+npm install -g @hayasaka7/haya-pet
+```
+
+The check is best-effort (3s timeout, silent on failure, never blocks a run),
+skipped when output is piped, and fully disabled with
+`HAYA_PET_NO_UPDATE_CHECK=1`.
+
 ## Troubleshooting
 
 | Symptom | Fix |
@@ -265,7 +280,10 @@ repairing a broken Electron install.
 
 HAYA Pet is local-only by default. It does not upload prompts, files,
 screenshots, or session logs. The overlay stores only local state needed for
-pet selection, position, size, and short derived status summaries.
+pet selection, position, size, and short derived status summaries. The single
+outbound request it ever makes is the daily npm version check (a standard
+HTTPS request to `registry.npmjs.org` that sends no session data); disable it
+with `HAYA_PET_NO_UPDATE_CHECK=1`.
 
 ## Documentation
 

package/apps/cli/src/haya-pet.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
-import { realpathSync, appendFileSync } from "node:fs";
+import { realpathSync, appendFileSync, readFileSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { runGenericCommand as defaultRunGenericCommand } from "../../../packages/cli-core/src/run-command.js";
 import { parseStateArgs, runStateCommand } from "../../../packages/cli-core/src/run-state.js";
@@ -16,6 +17,11 @@ import { getDefaultPaths } from "../../../packages/platform-core/src/paths.js";
 import { discoverPets as defaultDiscoverPets } from "../../../packages/pet-core/src/discovery.js";
 import { createStateFile as defaultCreateStateFile } from "../../../packages/app-state/src/state-file.js";
 import { getSelectedPetId, setSelectedPet, getHooksEnabled, setHooksEnabled } from "../../../packages/app-state/src/state.js";
+import { checkForUpdate, UPDATE_COMMAND } from "../../../packages/app-state/src/update-check.js";
+import { raceDeadline } from "../../../packages/cli-core/src/deadline.js";
+
+// Ceiling for wrapper→companion IPC awaits (see createMessageSender).
+const SENDER_DEADLINE_MS = 5000;
 import { getAdapterInfo } from "../../../packages/adapters/src/adapter-info.js";
 
 const CLIENT_DISPLAY_NAMES = Object.freeze({
@@ -105,6 +111,13 @@ export async function runStopCommand(_parsed, dependencies = {}) {
 // Explicitly start the companion overlay (so users never need `npm start`).
 export async function runStartCommand(_parsed, dependencies = {}) {
   const print = dependencies.print ?? defaultPrint;
+  const updateCheck = startUpdateCheck(dependencies);
+  const result = await startCompanionAndReport(dependencies, print);
+  await reportUpdateNotice(updateCheck, print);
+  return result;
+}
+
+async function startCompanionAndReport(dependencies, print) {
   const { client, started, error, timedOut } = await connectCompanion(dependencies, true);
 
   if (client) {
@@ -123,6 +136,51 @@ export async function runStartCommand(_parsed, dependencies = {}) {
   return { command: "start", ok: false, started: false };
 }
 
+// Kick off the (cached, best-effort) npm update check without blocking the
+// actual work; callers await the promise only when they are about to print.
+// Nothing here may ever break the run — even resolving the state path can
+// throw (no HOME/USERPROFILE), which simply means "no check".
+function startUpdateCheck(dependencies) {
+  try {
+    const check = dependencies.checkForUpdate ?? defaultCheckForUpdate;
+    return check({
+      currentVersion: dependencies.currentVersion ?? readOwnVersion(),
+      stateFile: createConfigStateFile(dependencies),
+      env: dependencies.env ?? process.env,
+      now: dependencies.now ?? Date.now
+    });
+  } catch {
+    return Promise.resolve(undefined);
+  }
+}
+
+// Default update check runs only on an interactive terminal: piped/CI output
+// should not be nagged (and nothing non-interactive should touch the network).
+function defaultCheckForUpdate(options) {
+  if (!process.stdout.isTTY) {
+    return Promise.resolve(undefined);
+  }
+  return checkForUpdate(options);
+}
+
+async function reportUpdateNotice(updateCheck, print) {
+  const update = await updateCheck;
+  if (update) {
+    print(
+      `haya-pet: update available — ${update.currentVersion} → ${update.latestVersion}. Run: ${UPDATE_COMMAND}`
+    );
+  }
+}
+
+function readOwnVersion() {
+  try {
+    const packagePath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "package.json");
+    return JSON.parse(readFileSync(packagePath, "utf8")).version;
+  } catch {
+    return undefined;
+  }
+}
+
 async function runRunCommand(parsed, dependencies) {
   const runGenericCommand = dependencies.runGenericCommand ?? defaultRunGenericCommand;
   const injectClaudeHooks = dependencies.injectClaudeHooks ?? defaultInjectClaudeHooks;
@@ -136,6 +194,9 @@ async function runRunCommand(parsed, dependencies) {
   const now = dependencies.now ?? Date.now;
   const cwd = dependencies.cwd ?? process.cwd();
   const messageSender = await createMessageSender(dependencies);
+  // Concurrent with the wrapped command; the result is printed after it exits
+  // (interactive TUIs clear the screen, so a pre-launch notice would be lost).
+  const updateCheck = startUpdateCheck(dependencies);
 
   const sessionId = dependencies.sessionId ?? `sess_${randomUUID()}`;
   let childArgs = parsed.childArgs;
@@ -302,7 +363,7 @@ async function runRunCommand(parsed, dependencies) {
   }
 
   try {
-    return await runGenericCommand({
+    const result = await runGenericCommand({
       command: parsed.childCommand,
       args: childArgs,
       cwd,
@@ -316,6 +377,8 @@ async function runRunCommand(parsed, dependencies) {
       stdio: dependencies.stdio,
       send: messageSender.send
     });
+    await reportUpdateNotice(updateCheck, print);
+    return result;
   } finally {
     stopWatcher();
     cleanup();
@@ -609,9 +672,14 @@ async function createMessageSender(dependencies) {
     process.stderr.write("haya-pet: started the companion overlay.\n");
   }
 
+  // Deadline every IPC await: if the companion wedges, a hanging send/close
+  // would keep THIS process alive after the wrapped CLI exits — leaving the
+  // user's terminal without a prompt. Losing a status message to the deadline
+  // is fine (the registry stales-out dead sessions); losing the terminal isn't.
+  const deadlineMs = dependencies.senderDeadlineMs ?? SENDER_DEADLINE_MS;
   return {
-    send: (message) => client.send(message),
-    close: () => client.close()
+    send: (message) => raceDeadline(client.send(message), deadlineMs),
+    close: () => raceDeadline(client.close(), deadlineMs)
   };
 }
 

package/apps/cli/test/haya-pet.test.mjs

@@ -275,6 +275,74 @@ test("HAYA_PET_NO_AUTOSTART disables auto-starting the companion", async () => {
   assert.equal(launched, 0);
 });
 
+test("run prints an update notice only after the wrapped command exits", async () => {
+  const order = [];
+
+  await runAiPet(["run", "--client", "generic", "--", "node", "-v"], {
+    env: { USERPROFILE: "C:\\Users\\A" },
+    heartbeatIntervalMs: 10,
+    send: async () => {},
+    print: (line) => order.push(line),
+    checkForUpdate: async () => ({ currentVersion: "0.2.7", latestVersion: "9.9.9" }),
+    runGenericCommand: async (options) => {
+      order.push("child-finished");
+      return { sessionId: options.sessionId, pid: 1, exitCode: 0 };
+    }
+  });
+
+  const noticeIndex = order.findIndex((entry) => entry.includes("update available"));
+  assert.ok(noticeIndex !== -1, "notice printed");
+  assert.ok(order[noticeIndex].includes("0.2.7 → 9.9.9"), "notice names both versions");
+  assert.ok(order[noticeIndex].includes("npm install -g @hayasaka7/haya-pet"), "notice gives the command");
+  assert.ok(noticeIndex > order.indexOf("child-finished"), "notice comes after the child exits");
+});
+
+test("run prints no update notice when the check finds nothing", async () => {
+  const lines = [];
+
+  await runAiPet(["run", "--client", "generic", "--", "node", "-v"], {
+    env: { USERPROFILE: "C:\\Users\\A" },
+    heartbeatIntervalMs: 10,
+    send: async () => {},
+    print: (line) => lines.push(line),
+    checkForUpdate: async () => undefined,
+    runGenericCommand: async (options) => ({ sessionId: options.sessionId, pid: 1, exitCode: 0 })
+  });
+
+  assert.ok(!lines.some((line) => line.includes("update available")));
+});
+
+test("start prints an update notice after its status line", async () => {
+  const lines = [];
+
+  await runAiPet(["start"], {
+    env: { USERPROFILE: "C:\\Users\\A" },
+    createIpcClient: async () => ({ send: async () => {}, close: async () => {} }),
+    launchCompanion: async () => {},
+    print: (line) => lines.push(line),
+    checkForUpdate: async () => ({ currentVersion: "0.2.7", latestVersion: "9.9.9" })
+  });
+
+  const noticeIndex = lines.findIndex((line) => line.includes("update available"));
+  assert.ok(noticeIndex !== -1, "notice printed");
+  assert.ok(noticeIndex > lines.findIndex((line) => line.includes("already running")));
+});
+
+test("run returns even when the companion connection hangs on close", async () => {
+  const result = await runAiPet(["run", "--client", "generic", "--", "node", "-v"], {
+    env: { USERPROFILE: "C:\\Users\\A" },
+    heartbeatIntervalMs: 10,
+    senderDeadlineMs: 20,
+    createIpcClient: async () => ({
+      send: async () => {},
+      close: () => new Promise(() => {})
+    }),
+    runGenericCommand: async (options) => ({ sessionId: options.sessionId, pid: 1, exitCode: 0 })
+  });
+
+  assert.equal(result.exitCode, 0);
+});
+
 test("parses the start command and reports when already running", async () => {
   assert.deepEqual(parseAiPetArgs(["start"]), { command: "start" });
 

package/apps/companion/src/main/bubble-list-viewport.js

@@ -0,0 +1,26 @@
+// Caps the bubble list's visible height. Two budgets apply, and the tighter one
+// wins: the HEIGHT budget (the pixel room between the folder button and the
+// screen edge on the side the list opens toward) and a COUNT budget — at most
+// MAX_VISIBLE_BUBBLES bubbles are visible at once, so a long session list stays
+// a compact panel and the rest is reached by scrolling (.bubble-list has
+// overflow-y: auto). The floor keeps the list usable even when the button sits
+// against a screen edge.
+const DEFAULT_MAX_VISIBLE_BUBBLES = 3;
+const DEFAULT_MIN_HEIGHT = 96;
+
+// `bubbleBottoms` are the layout bottoms (offsetTop + offsetHeight) of each
+// bubble in list order; the count cap is the bottom of the last bubble allowed
+// to be visible, so exactly that many show before scrolling.
+export function resolveBubbleListMaxHeight({
+  room,
+  bubbleBottoms = [],
+  maxVisible = DEFAULT_MAX_VISIBLE_BUBBLES,
+  minHeight = DEFAULT_MIN_HEIGHT
+} = {}) {
+  const heightBudget = Number.isFinite(room) ? Math.round(room) : 0;
+
+  const capBottom = bubbleBottoms.length > maxVisible ? bubbleBottoms[maxVisible - 1] : undefined;
+  const countBudget = Number.isFinite(capBottom) ? Math.round(capBottom) : Infinity;
+
+  return Math.max(minHeight, Math.min(heightBudget, countBudget));
+}

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

@@ -1,5 +1,6 @@
-import { app, BrowserWindow, ipcMain, Menu, nativeImage, screen, Tray } from "electron";
+import { app, BrowserWindow, ipcMain, Menu, nativeImage, screen, shell, Tray } from "electron";
 import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
 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";
@@ -18,6 +19,7 @@ import { getPetScale, setPetScale, setSelectedPet, updateGlobalPetPosition } fro
 import { buildTrayMenu, buildTrayTooltip } from "./tray-menu.js";
 import { createStateFile } from "./state-file.js";
 import { discoverPets } from "./pet-loader.js";
+import { checkForUpdate, UPDATE_PAGE_URL } from "../../../../packages/app-state/src/update-check.js";
 
 const STALE_SWEEP_INTERVAL_MS = 10_000;
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -47,6 +49,9 @@ let petLocal = { x: 0, y: 0 };
 // User-chosen pet scale (resize grip); the pet occupies PET_SIZE × petScale.
 let petScale = 1;
 let approvalWatch;
+// Set once the daily npm update check finds a newer version; surfaces as a
+// tray item (see tray-menu.js).
+let updateAvailable;
 
 // Electron singleton: a second launch forwards to the running instance.
 if (!app.requestSingleInstanceLock()) {
@@ -116,6 +121,9 @@ async function bootstrap() {
   createPetWindow();
   createTray();
   registerRendererHandlers();
+  // Best-effort and cached in state.json (shared with the CLI's check, so at
+  // most one registry request per day between them); never blocks startup.
+  void detectUpdate();
 
   const sweep = setInterval(() => {
     runtime.markStaleSessions(Date.now());
@@ -219,7 +227,8 @@ function refreshTrayMenu() {
     attachBubblesToTerminals: positionState.settings.attachBubblesToTerminals,
     selectedPetId: positionState.globalPet.selectedPetId,
     sessions,
-    pets: pets.map((pet) => ({ id: pet.manifest.id, name: pet.manifest.name }))
+    pets: pets.map((pet) => ({ id: pet.manifest.id, name: pet.manifest.name })),
+    updateAvailable
   }).map(toElectronMenuItem);
 
   tray.setContextMenu(Menu.buildFromTemplate(template));
@@ -246,6 +255,42 @@ function toElectronMenuItem(item) {
   return electronItem;
 }
 
+// Daily npm update check (shared cache with the CLI in state.json). On a hit,
+// the tray gains an "Update Available (x.y.z)" item; checkForUpdate itself
+// never throws, so this can run unawaited from bootstrap.
+async function detectUpdate() {
+  const update = await checkForUpdate({
+    currentVersion: readPackageVersion(),
+    // Every companion write flows through the in-memory positionState (load →
+    // mutate → save). Mirror that here: read the live copy, and on save merge
+    // only the cache key into whatever positionState is by then — a direct
+    // stateFile.save of the load-time snapshot could clobber a pet move made
+    // while the registry fetch was in flight.
+    stateFile: {
+      load: async () => positionState,
+      save: async (next) => {
+        positionState = { ...positionState, updateCheck: next.updateCheck };
+        return stateFile.save(positionState);
+      }
+    }
+  });
+  if (update) {
+    updateAvailable = update;
+    refreshTrayMenu();
+  }
+}
+
+// The published version lives in the ROOT package.json (the companion workspace
+// has its own, unpublished version number).
+function readPackageVersion() {
+  try {
+    const packagePath = join(__dirname, "..", "..", "..", "..", "package.json");
+    return JSON.parse(readFileSync(packagePath, "utf8")).version;
+  } catch {
+    return undefined;
+  }
+}
+
 function handleTrayClick(item) {
   switch (item.id) {
     case "toggle_pet":
@@ -257,6 +302,11 @@ function handleTrayClick(item) {
     case "quit":
       app.quit();
       break;
+    case "update":
+      // Open the package page rather than running npm ourselves — installing
+      // is the user's call (and may need their node manager / sudo setup).
+      shell.openExternal(UPDATE_PAGE_URL);
+      break;
     default:
       if (item.id?.startsWith("display_mode:")) {
         setDisplayMode(item.value);

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

@@ -55,6 +55,11 @@ export function buildTrayMenu(state = {}) {
     // item would be a dead button. Re-enable once settings outgrow the tray
     // (e.g. bubble text size, linger duration) and a handler is wired up.
     // { id: "settings", label: "Open Settings" },
+    // Only present when the daily npm update check found a newer version;
+    // clicking it opens the package page (the app never runs npm itself).
+    ...(state.updateAvailable?.latestVersion
+      ? [{ id: "update", label: `Update Available (${state.updateAvailable.latestVersion})` }]
+      : []),
     { id: "separator", type: "separator" },
     { id: "quit", label: "Quit" }
   ];

package/apps/companion/src/renderer/pet-window.js

@@ -16,6 +16,7 @@ import {
 import { resolveCompanionPetState } from "../../../../packages/session-core/src/pet-state.js";
 import { resolveVisibleBubbles } from "../../../../packages/session-core/src/bubble-linger.js";
 import { resolvePanelPlacement } from "../main/panel-placement.js";
+import { resolveBubbleListMaxHeight } from "../main/bubble-list-viewport.js";
 import { createInteractionController } from "./interaction-controller.js";
 import { createBubbleList } from "./session-bubbles.js";
 
@@ -137,9 +138,11 @@ function placePanel() {
     const alignRight = placement.x + rect.width / 2 > workArea.width / 2;
     list.dataset.openDirection = openUp ? "up" : "down";
     list.dataset.openAlign = alignRight ? "right" : "left";
-    // Cap the height to the room actually available on the chosen side.
+    // Cap the height to the room actually available on the chosen side AND to
+    // three visible bubbles — more sessions are reached by scrolling the list.
     const room = openUp ? placement.y - margin : workArea.height - (placement.y + rect.height) - margin;
-    list.style.maxHeight = `${Math.max(96, Math.round(room))}px`;
+    const bubbleBottoms = Array.from(list.children, (child) => child.offsetTop + child.offsetHeight);
+    list.style.maxHeight = `${resolveBubbleListMaxHeight({ room, bubbleBottoms })}px`;
   }
 }