@hayasaka7/haya-pet 0.1.0

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

@@ -0,0 +1,339 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { createDaemonRuntime } from "../../../packages/daemon-core/src/daemon-runtime.js";
+import { createIpcServer } from "../../../packages/daemon-core/src/ipc-server.js";
+import { parseAiPetArgs, runAiPet } from "../src/haya-pet.js";
+
+test("parses generic run command arguments", () => {
+  assert.deepEqual(
+    parseAiPetArgs(["run", "--no-observe", "--client", "generic", "--", "node", "-e", "process.exit(0)"]),
+    {
+      command: "run",
+      clientId: "generic",
+      observe: false,
+      childCommand: "node",
+      childArgs: ["-e", "process.exit(0)"]
+    }
+  );
+});
+
+test("observation is on by default and --no-observe opts out", () => {
+  assert.equal(parseAiPetArgs(["run", "--client", "codex"]).observe, true);
+  assert.equal(parseAiPetArgs(["run", "--no-observe", "--client", "codex"]).observe, false);
+
+  const parsedWithCommand = parseAiPetArgs(["run", "--", "claude", "--resume"]);
+  assert.equal(parsedWithCommand.observe, true);
+  assert.equal(parsedWithCommand.childCommand, "claude");
+  assert.deepEqual(parsedWithCommand.childArgs, ["--resume"]);
+});
+
+test("defaults run command client to generic", () => {
+  assert.equal(parseAiPetArgs(["run", "--", "node"]).clientId, "generic");
+});
+
+test("falls back to the client default command when no -- is given", () => {
+  assert.deepEqual(parseAiPetArgs(["run", "--no-observe", "--client", "codex"]), {
+    command: "run",
+    clientId: "codex",
+    observe: false,
+    childCommand: "codex",
+    childArgs: []
+  });
+  assert.equal(parseAiPetArgs(["run", "--client", "claude-code"]).childCommand, "claude");
+  assert.equal(parseAiPetArgs(["run", "--client", "antigravity"]).childCommand, "antigravity");
+});
+
+test("still requires -- for generic (no default command)", () => {
+  assert.throws(() => parseAiPetArgs(["run", "--client", "generic"]), /no default command/);
+});
+
+test("accepts a bare command without -- (shells may strip the separator)", () => {
+  assert.deepEqual(parseAiPetArgs(["run", "--no-observe", "node", "-v"]), {
+    command: "run",
+    clientId: "generic",
+    observe: false,
+    childCommand: "node",
+    childArgs: ["-v"]
+  });
+  // The shape PowerShell's npm shim produces after stripping `--`:
+  assert.deepEqual(parseAiPetArgs(["run", "--no-observe", "--client", "claude-code", "claude", "--resume"]), {
+    command: "run",
+    clientId: "claude-code",
+    observe: false,
+    childCommand: "claude",
+    childArgs: ["--resume"]
+  });
+});
+
+test("rejects unsupported commands and missing arguments", () => {
+  assert.throws(() => parseAiPetArgs(["status"]), /Unsupported haya-pet command: status/);
+  assert.throws(() => parseAiPetArgs(["run", "--client"]), /--client requires a value/);
+  assert.throws(() => parseAiPetArgs(["run", "--"]), /run requires a child command/);
+  assert.throws(() => parseAiPetArgs(["run", "--bogus"]), /Unknown run option/);
+});
+
+test("runs parsed command through injectable generic runner", async () => {
+  const calls = [];
+  const result = await runAiPet(
+    ["run", "--client", "generic", "--", "node", "-e", "process.exit(0)"],
+    {
+      cwd: "D:\\Work\\project",
+      heartbeatIntervalMs: 10,
+      send: async () => {},
+      runGenericCommand: async (options) => {
+        calls.push(options);
+        return { sessionId: "sess_a", pid: 123, exitCode: 0 };
+      }
+    }
+  );
+
+  assert.equal(result.exitCode, 0);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].command, "node");
+  assert.deepEqual(calls[0].args, ["-e", "process.exit(0)"]);
+  assert.equal(calls[0].clientId, "generic");
+  assert.equal(calls[0].clientDisplayName, "Generic");
+  assert.equal(calls[0].cwd, "D:\\Work\\project");
+  assert.equal(calls[0].heartbeatIntervalMs, 10);
+});
+
+test("runs command through daemon IPC when no send function is injected", async () => {
+  const runtime = createDaemonRuntime();
+  const server = await createIpcServer({
+    endpoint: "test-haya-petd",
+    platform: "test",
+    onMessage: (message) => runtime.handleMessage(message)
+  });
+
+  try {
+    const result = await runAiPet(
+      // --no-observe keeps this lifecycle test on the deterministic plain path.
+      ["run", "--no-observe", "--client", "generic", "--", process.execPath, "-e", "process.exit(0)"],
+      {
+        cwd: process.cwd(),
+        stdio: "ignore",
+        heartbeatIntervalMs: 10,
+        ipcEndpoint: server.endpoint
+      }
+    );
+
+    await waitFor(() => runtime.getSession(result.sessionId)?.state === "exited");
+
+    const session = runtime.getSession(result.sessionId);
+    assert.equal(result.exitCode, 0);
+    assert.equal(session.clientId, "generic");
+    assert.equal(session.state, "exited");
+    assert.equal(session.exitCode, 0);
+  } finally {
+    await server.close();
+  }
+});
+
+test("parses pets list and pets use commands", () => {
+  assert.deepEqual(parseAiPetArgs(["pets"]), { command: "pets", action: "list" });
+  assert.deepEqual(parseAiPetArgs(["pets", "list"]), { command: "pets", action: "list" });
+  assert.deepEqual(parseAiPetArgs(["pets", "use", "cat"]), { command: "pets", action: "use", petId: "cat" });
+  assert.throws(() => parseAiPetArgs(["pets", "use"]), /pets use requires a pet id/);
+  assert.throws(() => parseAiPetArgs(["pets", "bogus"]), /Unknown pets action: bogus/);
+});
+
+test("pets list marks the currently selected pet", async () => {
+  const lines = [];
+  const result = await runAiPet(["pets", "list"], {
+    homeDir: "C:\\Users\\A",
+    discoverPets: async () => [
+      { manifest: { id: "cat", name: "Cat" } },
+      { manifest: { id: "dog", name: "Dog" } }
+    ],
+    createStateFile: () => fakeStateFile({ globalPet: { selectedPetId: "dog" } }),
+    print: (line) => lines.push(line)
+  });
+
+  assert.deepEqual(result.pets, ["cat", "dog"]);
+  assert.equal(result.selectedId, "dog");
+  assert.ok(lines.some((line) => line.startsWith("* dog")));
+  assert.ok(lines.some((line) => line.startsWith("  cat")));
+});
+
+test("pets use stores the selection in the state file", async () => {
+  const store = fakeStateFile({ globalPet: {} });
+  const result = await runAiPet(["pets", "use", "cat"], {
+    homeDir: "C:\\Users\\A",
+    discoverPets: async () => [{ manifest: { id: "cat", name: "Cat" } }],
+    createStateFile: () => store,
+    print: () => {}
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.installed, true);
+  assert.equal(store.current().globalPet.selectedPetId, "cat");
+});
+
+test("pets use still stores an id that is not currently installed", async () => {
+  const store = fakeStateFile({ globalPet: {} });
+  const lines = [];
+  const result = await runAiPet(["pets", "use", "ghost"], {
+    homeDir: "C:\\Users\\A",
+    discoverPets: async () => [],
+    createStateFile: () => store,
+    print: (line) => lines.push(line)
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.installed, false);
+  assert.equal(store.current().globalPet.selectedPetId, "ghost");
+  assert.ok(lines.some((line) => line.includes("not currently installed")));
+});
+
+function fakeStateFile(initial) {
+  let state = initial;
+  return {
+    statePath: "state.json",
+    load: async () => state,
+    save: async (next) => {
+      state = next;
+      return next;
+    },
+    current: () => state
+  };
+}
+
+test("still runs the wrapped command when no daemon is available", async () => {
+  const calls = [];
+  const result = await runAiPet(
+    ["run", "--client", "generic", "--", "node", "-e", "process.exit(0)"],
+    {
+      cwd: process.cwd(),
+      heartbeatIntervalMs: 10,
+      autoStart: false, // no daemon and no auto-start -> degrade gracefully
+      createIpcClient: async () => {
+        throw new Error("ECONNREFUSED");
+      },
+      runGenericCommand: async (options) => {
+        calls.push(options);
+        return { sessionId: "sess_a", pid: 123, exitCode: 0 };
+      }
+    }
+  );
+
+  assert.equal(result.exitCode, 0);
+  assert.equal(calls.length, 1);
+});
+
+test("auto-starts the companion when one is not already running", async () => {
+  const calls = [];
+  let launched = 0;
+  let connects = 0;
+
+  const result = await runAiPet(
+    ["run", "--client", "generic", "--", "node", "-e", "process.exit(0)"],
+    {
+      cwd: process.cwd(),
+      heartbeatIntervalMs: 10,
+      sleep: async () => {}, // no real waiting between connect attempts
+      createIpcClient: async () => {
+        connects += 1;
+        if (connects === 1) {
+          throw new Error("ECONNREFUSED"); // not running yet
+        }
+        return { send: async () => {}, close: async () => {} }; // up after launch
+      },
+      launchCompanion: async () => {
+        launched += 1;
+      },
+      runGenericCommand: async (options) => {
+        calls.push(options);
+        return { sessionId: "sess_a", pid: 123, exitCode: 0 };
+      }
+    }
+  );
+
+  assert.equal(result.exitCode, 0);
+  assert.equal(launched, 1, "launches the companion exactly once");
+  assert.equal(calls.length, 1, "still runs the wrapped command");
+});
+
+test("HAYA_PET_NO_AUTOSTART disables auto-starting the companion", async () => {
+  let launched = 0;
+  await runAiPet(
+    ["run", "--client", "generic", "--", "node", "-e", "process.exit(0)"],
+    {
+      cwd: process.cwd(),
+      heartbeatIntervalMs: 10,
+      env: { HAYA_PET_NO_AUTOSTART: "1" },
+      ipcEndpoint: "test-endpoint",
+      createIpcClient: async () => {
+        throw new Error("ECONNREFUSED");
+      },
+      launchCompanion: async () => {
+        launched += 1;
+      },
+      runGenericCommand: async () => ({ sessionId: "sess_a", pid: 1, exitCode: 0 })
+    }
+  );
+
+  assert.equal(launched, 0);
+});
+
+test("parses the start command and reports when already running", async () => {
+  assert.deepEqual(parseAiPetArgs(["start"]), { command: "start" });
+
+  const lines = [];
+  const result = await runAiPet(["start"], {
+    createIpcClient: async () => ({ send: async () => {}, close: async () => {} }),
+    launchCompanion: async () => {
+      throw new Error("should not launch when already running");
+    },
+    print: (line) => lines.push(line)
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.started, false);
+  assert.ok(lines.some((line) => line.includes("already running")));
+});
+
+test("stop command sends a shutdown to a running companion", async () => {
+  assert.deepEqual(parseAiPetArgs(["stop"]), { command: "stop" });
+
+  const sent = [];
+  const lines = [];
+  const result = await runAiPet(["stop"], {
+    createIpcClient: async () => ({
+      send: async (message) => sent.push(message),
+      close: async () => {}
+    }),
+    print: (line) => lines.push(line)
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.wasRunning, true);
+  assert.deepEqual(sent, [{ type: "shutdown" }]);
+  assert.ok(lines.some((line) => line.includes("stopped")));
+});
+
+test("stop command is a no-op when nothing is running", async () => {
+  const lines = [];
+  const result = await runAiPet(["stop"], {
+    ipcEndpoint: "test-endpoint",
+    createIpcClient: async () => {
+      throw new Error("ECONNREFUSED");
+    },
+    print: (line) => lines.push(line)
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.wasRunning, false);
+  assert.ok(lines.some((line) => line.includes("not running")));
+});
+
+async function waitFor(predicate) {
+  const startedAt = Date.now();
+
+  while (!predicate()) {
+    if (Date.now() - startedAt > 1000) {
+      throw new Error("Timed out waiting for condition");
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+}

package/apps/companion/README.md

@@ -0,0 +1,83 @@
+# Haya Pet Companion (Electron overlay)
+
+The desktop overlay app for the AI CLI pet runtime. It hosts the daemon IPC
+server, renders the global pet, and shows the session bubbles. (A reply/approval
+"task talk window" is scaffolded but parked — see below.)
+
+> Most users never launch this directly: `haya-pet run` auto-starts it. This doc
+> covers its internals. For installing/using Haya Pet, see the
+> [root README](../../README.md) and [docs/architecture.md](../../docs/architecture.md).
+
+## Architecture
+
+The companion is intentionally thin glue. All decision logic lives in the
+unit-tested pure packages and is imported directly:
+
+| Concern | Source of truth |
+|---|---|
+| Pet atlas / frames / animation | `packages/pet-core` |
+| Click vs drag | `apps/companion/src/renderer/interaction-controller.js` |
+| Window options / overlay vs fallback | `src/main/window-options.js` |
+| Display clamping / DPI | `src/main/display-manager.js` |
+| Position persistence | `src/main/position-store.js` + `state-file.js` |
+| Session bubbles | `packages/session-core/src/bubble-view.js` |
+| Adapter capabilities | `packages/adapters` |
+| Task status / controls / reply safety | `packages/task-core` |
+| Tray menu model | `src/main/tray-menu.js` |
+| Daemon singleton | `packages/daemon-core/src/singleton.js` |
+
+```
+main process (index.js)
+  ├─ IPC server (daemon-core)  ← haya-pet wrappers send register/state/heartbeat
+  ├─ daemon runtime + session registry
+  ├─ overlay BrowserWindow  → renderer
+  └─ tray + position persistence
+
+renderer
+  ├─ pet-window.js      (Layer 1: pet canvas + drag + panel placement)
+  ├─ session-bubbles.js (Layer 2: bubbles + folder toggle + status icons)
+  └─ task-talk-window.js(Layer 3: reply/approval surface — PARKED, not wired)
+```
+
+## Run
+
+Normally you don't — `haya-pet run` (or `haya-pet start`) launches the overlay by
+spawning Electron, which is a root runtime dependency. For development you can
+still start it directly:
+
+```bash
+npm start          # electron .  (from apps/companion)
+```
+
+Requires Node ≥ 18. Then, from any terminal, launch an AI CLI through the wrapper
+so the pet reflects it:
+
+```bash
+haya-pet run --client generic -- sleep 10
+haya-pet run --client codex -- codex
+```
+
+## Pets
+
+Pets are discovered from `~/.codex/pets` and `~/.haya-pet/pets`. Without a
+spritesheet the renderer draws labelled placeholder frames so interactions and
+state mapping remain testable. See `assets/fallback-pet/README.md`.
+
+Select a pet from the tray menu → **Installed Pets**, or from the CLI:
+
+```bash
+haya-pet pets              # list (the * marks the selected pet)
+haya-pet pets use my-pet   # persist the selection; used on next companion start
+```
+
+The selection is stored in the shared state file (`globalPet.selectedPetId`),
+so the companion starts with your last selected pet.
+
+## Safety
+
+- The overlay never steals focus (`focusable: false` on supported platforms) and
+  is click-through except over the pet and bubbles.
+- All IPC is local-only; nothing is sent to the network.
+- When the parked reply/approval surface is wired up, replies will be gated by
+  adapter capability (wrapper-only clients can't inject text blindly) and
+  approvals will always require explicit user action.

package/apps/companion/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@haya-pet/companion",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Electron overlay companion app for the AI CLI pet runtime.",
+  "main": "src/main/index.js",
+  "scripts": {
+    "start": "electron ."
+  },
+  "devDependencies": {
+    "electron": "42.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/apps/companion/src/main/display-manager.js

@@ -0,0 +1,71 @@
+const DEFAULT_SIZE = Object.freeze({
+  width: 192,
+  height: 208
+});
+
+export function resolveSavedPosition(savedPosition, displays, size = DEFAULT_SIZE) {
+  const display = findDisplayForSavedPosition(savedPosition, displays);
+  const windowBounds = savedPosition
+    ? {
+        x: savedPosition.x,
+        y: savedPosition.y,
+        width: savedPosition.width ?? size.width,
+        height: savedPosition.height ?? size.height
+      }
+    : defaultBoundsForDisplay(display, size);
+  const clamped = clampWindowBounds(windowBounds, display);
+
+  return {
+    ...clamped,
+    displayId: display.id,
+    scaleFactor: display.scaleFactor ?? 1
+  };
+}
+
+export function clampWindowBounds(bounds, display) {
+  const workArea = display.workArea ?? display.bounds;
+  const width = bounds.width ?? DEFAULT_SIZE.width;
+  const height = bounds.height ?? DEFAULT_SIZE.height;
+  const maxX = workArea.x + workArea.width - width;
+  const maxY = workArea.y + workArea.height - height;
+
+  return {
+    x: clamp(bounds.x ?? workArea.x, workArea.x, maxX),
+    y: clamp(bounds.y ?? workArea.y, workArea.y, maxY),
+    width,
+    height
+  };
+}
+
+function findDisplayForSavedPosition(savedPosition, displays) {
+  if (!Array.isArray(displays) || displays.length === 0) {
+    throw new Error("At least one display is required");
+  }
+
+  if (savedPosition?.displayId) {
+    const savedDisplay = displays.find((display) => display.id === savedPosition.displayId);
+    if (savedDisplay) {
+      return savedDisplay;
+    }
+  }
+
+  return displays.find((display) => display.primary) ?? displays[0];
+}
+
+function defaultBoundsForDisplay(display, size) {
+  const workArea = display.workArea ?? display.bounds;
+  return {
+    x: workArea.x + workArea.width - size.width,
+    y: workArea.y + workArea.height - size.height,
+    width: size.width,
+    height: size.height
+  };
+}
+
+function clamp(value, min, max) {
+  if (max < min) {
+    return min;
+  }
+
+  return Math.min(Math.max(value, min), max);
+}