@hayasaka7/haya-pet 0.1.0

package/packages/daemon-core/test/daemon-runtime.test.mjs

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import { PassThrough } from "node:stream";
+import { test } from "../../../test/harness.mjs";
+import { writeProtocolMessage } from "../src/ipc-transport.js";
+import { createDaemonRuntime } from "../src/daemon-runtime.js";
+
+function registerMessage(sessionId) {
+  return {
+    type: "register",
+    sessionId,
+    clientId: "generic",
+    clientDisplayName: "Generic",
+    pid: 12345,
+    cwd: "D:\\Work\\project",
+    projectName: "project",
+    startedAt: 1000
+  };
+}
+
+test("applies protocol messages to the session registry", () => {
+  const changes = [];
+  const runtime = createDaemonRuntime({
+    onSessionChanged: (session) => changes.push(session)
+  });
+
+  runtime.handleMessage(registerMessage("sess_a"));
+  runtime.handleMessage({
+    type: "state",
+    sessionId: "sess_a",
+    state: "waiting_approval",
+    summary: "waiting for command approval",
+    confidence: 0.9,
+    source: "wrapper",
+    updatedAt: 1100
+  });
+
+  assert.equal(runtime.getSession("sess_a").state, "waiting_approval");
+  assert.equal(runtime.getPrioritySession().sessionId, "sess_a");
+  assert.deepEqual(changes.map((session) => session.state), ["idle", "waiting_approval"]);
+});
+
+test("attaches stream input to the daemon runtime", () => {
+  const stream = new PassThrough();
+  const runtime = createDaemonRuntime();
+
+  runtime.attachStream(stream);
+  writeProtocolMessage(stream, registerMessage("sess_stream"));
+
+  assert.equal(runtime.getSession("sess_stream").clientDisplayName, "Generic");
+});
+
+test("reports transport errors without mutating the registry", () => {
+  const stream = new PassThrough();
+  const errors = [];
+  const runtime = createDaemonRuntime({
+    onProtocolError: (error) => errors.push(error)
+  });
+
+  runtime.attachStream(stream);
+  stream.write("{not-json}\n");
+
+  assert.equal(errors.length, 1);
+  assert.match(errors[0].message, /Invalid protocol JSON frame/);
+  assert.deepEqual(runtime.listSessions(), []);
+});

package/packages/daemon-core/test/ipc-server.test.mjs

@@ -0,0 +1,70 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { createIpcClient, createIpcServer } from "../src/ipc-server.js";
+
+test("server receives protocol messages from client", async () => {
+  const received = [];
+  const server = await createIpcServer({
+    endpoint: "test-haya-petd",
+    platform: "test",
+    onMessage: (message) => received.push(message)
+  });
+
+  const client = await createIpcClient({ endpoint: server.endpoint });
+  await client.send({ type: "heartbeat", sessionId: "sess_a", updatedAt: 1 });
+  await waitFor(() => received.length === 1);
+  await client.close();
+  await server.close();
+
+  assert.deepEqual(received, [{ type: "heartbeat", sessionId: "sess_a", updatedAt: 1 }]);
+});
+
+test("server reports invalid client protocol frames", async () => {
+  const errors = [];
+  const server = await createIpcServer({
+    endpoint: "test-haya-petd",
+    platform: "test",
+    onMessage: () => {},
+    onProtocolError: (error) => errors.push(error)
+  });
+
+  const client = await createIpcClient({ endpoint: server.endpoint });
+  client.socket.write("{not-json}\n");
+  await waitFor(() => errors.length === 1);
+  await client.close();
+  await server.close();
+
+  assert.match(errors[0].message, /Invalid protocol JSON frame/);
+});
+
+test("client rejects invalid protocol messages before writing", async () => {
+  const received = [];
+  const server = await createIpcServer({
+    endpoint: "test-haya-petd",
+    platform: "test",
+    onMessage: (message) => received.push(message)
+  });
+
+  const client = await createIpcClient({ endpoint: server.endpoint });
+
+  await assert.rejects(
+    () => client.send({ type: "unknown", sessionId: "sess_a" }),
+    /Unknown protocol message type/
+  );
+
+  await client.close();
+  await server.close();
+  assert.deepEqual(received, []);
+});
+
+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/packages/daemon-core/test/ipc-transport.test.mjs

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict";
+import { PassThrough } from "node:stream";
+import { test } from "../../../test/harness.mjs";
+import {
+  attachProtocolStream,
+  createProtocolMessageReader,
+  encodeProtocolMessage,
+  writeProtocolMessage
+} from "../src/ipc-transport.js";
+
+const heartbeat = {
+  type: "heartbeat",
+  sessionId: "sess_abc123",
+  updatedAt: 1780000010
+};
+
+test("encodes one validated protocol message per JSON line", () => {
+  assert.equal(encodeProtocolMessage(heartbeat), `${JSON.stringify(heartbeat)}\n`);
+  assert.throws(
+    () => encodeProtocolMessage({ type: "unknown", sessionId: "sess_abc123" }),
+    /Unknown protocol message type/
+  );
+});
+
+test("decodes complete and split protocol frames", () => {
+  const messages = [];
+  const errors = [];
+  const reader = createProtocolMessageReader({
+    onMessage: (message) => messages.push(message),
+    onError: (error) => errors.push(error)
+  });
+
+  const encoded = encodeProtocolMessage(heartbeat);
+  reader.push(encoded.slice(0, 5));
+  reader.push(encoded.slice(5));
+
+  assert.deepEqual(messages, [heartbeat]);
+  assert.deepEqual(errors, []);
+});
+
+test("reports invalid JSON and invalid protocol frames without losing later messages", () => {
+  const messages = [];
+  const errors = [];
+  const reader = createProtocolMessageReader({
+    onMessage: (message) => messages.push(message),
+    onError: (error) => errors.push(error)
+  });
+
+  reader.push("{not-json}\n");
+  reader.push(`${JSON.stringify({ type: "state", sessionId: "", state: "busy" })}\n`);
+  reader.push(encodeProtocolMessage(heartbeat));
+
+  assert.deepEqual(messages, [heartbeat]);
+  assert.equal(errors.length, 2);
+  assert.match(errors[0].message, /Invalid protocol JSON frame/);
+  assert.match(errors[1].message, /sessionId must be a non-empty string/);
+});
+
+test("attaches protocol reader and writer to Node streams", async () => {
+  const input = new PassThrough();
+  const output = new PassThrough();
+  const messages = [];
+
+  attachProtocolStream(input, {
+    onMessage: (message) => messages.push(message)
+  });
+
+  writeProtocolMessage(output, heartbeat);
+  input.write(output.read());
+
+  assert.deepEqual(messages, [heartbeat]);
+});

package/packages/daemon-core/test/singleton.test.mjs

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  parseLock,
+  serializeLock,
+  resolveSingletonAction
+} from "../src/singleton.js";
+
+test("round-trips a lock record", () => {
+  const lock = { pid: 1234, startedAt: 100, endpoint: "\\\\.\\pipe\\haya-petd" };
+  const parsed = parseLock(serializeLock(lock));
+  assert.deepEqual(parsed, lock);
+});
+
+test("parses invalid lock content as undefined", () => {
+  assert.equal(parseLock("not json"), undefined);
+  assert.equal(parseLock(JSON.stringify({ startedAt: 1 })), undefined);
+});
+
+test("acquires when no lock is present", () => {
+  assert.equal(resolveSingletonAction({ lock: undefined, isAlive: () => true }), "acquire");
+});
+
+test("forwards to a live daemon", () => {
+  const lock = { pid: 1234, startedAt: 1, endpoint: "x" };
+  assert.equal(resolveSingletonAction({ lock, isAlive: (pid) => pid === 1234 }), "forward");
+});
+
+test("reclaims a stale lock when the process is dead", () => {
+  const lock = { pid: 1234, startedAt: 1, endpoint: "x" };
+  assert.equal(resolveSingletonAction({ lock, isAlive: () => false }), "reclaim");
+});

package/packages/pet-core/src/animation-state.js

@@ -0,0 +1,84 @@
+import { isPetAction } from "./atlas.js";
+
+const DRAG_ACTIONS = Object.freeze({
+  left: "running-left",
+  right: "running-right"
+});
+
+function assertPetAction(action) {
+  if (!isPetAction(action)) {
+    throw new Error(`Unknown pet action: ${action}`);
+  }
+}
+
+export function createAnimationState(stableAction = "idle") {
+  assertPetAction(stableAction);
+
+  return {
+    stableAction,
+    currentAction: stableAction
+  };
+}
+
+export function setStableAction(state, stableAction) {
+  assertPetAction(stableAction);
+
+  return {
+    ...state,
+    stableAction,
+    currentAction: state.dragAction ?? state.oneShotAction ?? stableAction
+  };
+}
+
+export function triggerOneShot(state, oneShotAction, now, durationMs) {
+  assertPetAction(oneShotAction);
+
+  if (!Number.isFinite(now)) {
+    throw new TypeError("now must be a finite timestamp");
+  }
+
+  if (!Number.isFinite(durationMs) || durationMs <= 0) {
+    throw new RangeError("durationMs must be greater than 0");
+  }
+
+  return {
+    ...state,
+    currentAction: oneShotAction,
+    oneShotAction,
+    oneShotStartedAt: now,
+    oneShotEndsAt: now + durationMs,
+    previousStableAction: state.stableAction
+  };
+}
+
+export function setDragAction(state, direction) {
+  const dragAction = DRAG_ACTIONS[direction];
+  if (!dragAction) {
+    throw new Error(`Unknown drag direction: ${direction}`);
+  }
+
+  return {
+    ...state,
+    currentAction: dragAction,
+    dragAction
+  };
+}
+
+export function clearDragAction(state) {
+  const next = { ...state };
+  delete next.dragAction;
+  next.currentAction = next.oneShotAction ?? next.stableAction;
+  return next;
+}
+
+export function resolveCurrentAction(state, now) {
+  if (state.dragAction) {
+    return state.dragAction;
+  }
+
+  if (state.oneShotAction && Number.isFinite(state.oneShotEndsAt) && now < state.oneShotEndsAt) {
+    return state.oneShotAction;
+  }
+
+  return state.stableAction;
+}

package/packages/pet-core/src/animator.js

@@ -0,0 +1,26 @@
+import { getFrameCount } from "./atlas.js";
+import { DEFAULT_FRAME_DURATION_MS } from "./manifest.js";
+
+export function getFrameAt(action, elapsedMs, manifest = {}) {
+  const frameCount = getFrameCount(action);
+  const duration = resolveDuration(action, manifest);
+  const elapsed = Number.isFinite(elapsedMs) && elapsedMs > 0 ? elapsedMs : 0;
+  return Math.floor(elapsed / duration) % frameCount;
+}
+
+export function getActionDurationMs(action, manifest = {}) {
+  return getFrameCount(action) * resolveDuration(action, manifest);
+}
+
+function resolveDuration(action, manifest) {
+  const override = manifest.actionFrameDurations?.[action];
+  if (Number.isFinite(override) && override > 0) {
+    return override;
+  }
+
+  if (Number.isFinite(manifest.frameDurationMs) && manifest.frameDurationMs > 0) {
+    return manifest.frameDurationMs;
+  }
+
+  return DEFAULT_FRAME_DURATION_MS;
+}

package/packages/pet-core/src/atlas.js

@@ -0,0 +1,81 @@
+export const CELL_WIDTH = 192;
+export const CELL_HEIGHT = 208;
+export const ATLAS_COLUMNS = 8;
+export const ATLAS_ROWS = 9;
+export const ATLAS_WIDTH = CELL_WIDTH * ATLAS_COLUMNS;
+export const ATLAS_HEIGHT = CELL_HEIGHT * ATLAS_ROWS;
+
+export const ACTION_ROWS = Object.freeze({
+  idle: 0,
+  "running-right": 1,
+  "running-left": 2,
+  waving: 3,
+  jumping: 4,
+  failed: 5,
+  waiting: 6,
+  running: 7,
+  review: 8
+});
+
+export const FRAME_COUNTS = Object.freeze({
+  idle: 6,
+  "running-right": 8,
+  "running-left": 8,
+  waving: 4,
+  jumping: 5,
+  failed: 8,
+  waiting: 6,
+  running: 6,
+  review: 6
+});
+
+const AI_STATE_TO_PET_ACTION = Object.freeze({
+  idle: "idle",
+  thinking: "review",
+  running_tool: "running",
+  editing_files: "running",
+  waiting_user: "waiting",
+  waiting_approval: "waiting",
+  reviewing: "review",
+  compacting: "review",
+  failed: "failed",
+  success: "jumping",
+  stale: "waiting",
+  exited: "jumping"
+});
+
+export function isPetAction(action) {
+  return Object.prototype.hasOwnProperty.call(ACTION_ROWS, action);
+}
+
+export function getFrameCount(action) {
+  if (!isPetAction(action)) {
+    throw new Error(`Unknown pet action: ${action}`);
+  }
+
+  return FRAME_COUNTS[action];
+}
+
+export function getFrameRect(action, frameIndex) {
+  const frameCount = getFrameCount(action);
+
+  if (!Number.isInteger(frameIndex) || frameIndex < 0 || frameIndex >= frameCount) {
+    throw new RangeError(`Frame index ${frameIndex} is out of range for ${action}; expected 0-${frameCount - 1}`);
+  }
+
+  return {
+    x: frameIndex * CELL_WIDTH,
+    y: ACTION_ROWS[action] * CELL_HEIGHT,
+    width: CELL_WIDTH,
+    height: CELL_HEIGHT
+  };
+}
+
+export function mapAiStateToPetAction(aiState) {
+  const action = AI_STATE_TO_PET_ACTION[aiState];
+  if (!action) {
+    throw new Error(`Unknown AI client state: ${aiState}`);
+  }
+
+  return action;
+}

package/packages/pet-core/src/discovery.js

@@ -0,0 +1,90 @@
+import { readdir as fsReaddir, readFile as fsReadFile, stat as fsStat } from "node:fs/promises";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parsePetManifest } from "./manifest.js";
+
+// Scans pet search paths for Codex-compatible pets. Each pet is a directory
+// containing pet.json plus a spritesheet file. Filesystem functions are
+// injectable so discovery is testable without touching the real disk. Pets are
+// deduplicated by manifest id (first search path wins).
+export async function discoverPets(searchPaths = [], deps = {}) {
+  const { readdir } = resolveFs(deps);
+  const pets = [];
+  const seen = new Set();
+
+  for (const searchPath of searchPaths) {
+    const entries = await safeReaddir(readdir, searchPath);
+
+    for (const entry of entries) {
+      const petDir = join(searchPath, entry);
+      const pet = await loadPetFromDir(petDir, deps);
+      if (pet && !seen.has(pet.manifest.id)) {
+        seen.add(pet.manifest.id);
+        pets.push(pet);
+      }
+    }
+  }
+
+  return pets;
+}
+
+export async function loadPetFromDir(petDir, deps = {}) {
+  const { readFile, stat } = resolveFs(deps);
+  const manifestPath = join(petDir, "pet.json");
+
+  let raw;
+  try {
+    raw = await readFile(manifestPath, "utf8");
+  } catch {
+    return undefined;
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return undefined;
+  }
+
+  const result = parsePetManifest(parsed);
+  if (!result.ok) {
+    return undefined;
+  }
+
+  const spritesheetPath = join(petDir, result.manifest.spritesheet);
+  if (!(await fileExists(stat, spritesheetPath))) {
+    return undefined;
+  }
+
+  return {
+    dir: petDir,
+    manifest: result.manifest,
+    spritesheetPath,
+    spritesheetUrl: pathToFileURL(spritesheetPath).href
+  };
+}
+
+function resolveFs(deps) {
+  return {
+    readdir: deps.readdir ?? fsReaddir,
+    readFile: deps.readFile ?? fsReadFile,
+    stat: deps.stat ?? fsStat
+  };
+}
+
+async function safeReaddir(readdir, dir) {
+  try {
+    return await readdir(dir);
+  } catch {
+    return [];
+  }
+}
+
+async function fileExists(stat, path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/packages/pet-core/src/manifest.js

@@ -0,0 +1,112 @@
+import { ACTION_ROWS, CELL_HEIGHT, CELL_WIDTH } from "./atlas.js";
+
+export const DEFAULT_FRAME_DURATION_MS = 120;
+
+export function parsePetManifest(input) {
+  if (!isPlainObject(input)) {
+    return { ok: false, errors: ["manifest must be an object"] };
+  }
+
+  const errors = [];
+
+  // Accept both this runtime's canonical fields and the Codex Desktop Pet
+  // field names (displayName / spritesheetPath). Canonical wins when both exist.
+  const name = input.name ?? input.displayName;
+  const spritesheet = input.spritesheet ?? input.spritesheetPath;
+
+  requireNonEmptyString(errors, input.id, "id");
+  requireNonEmptyString(errors, name, "name");
+  requireNonEmptyString(errors, spritesheet, "spritesheet");
+
+  const cellWidth = input.cellWidth ?? CELL_WIDTH;
+  const cellHeight = input.cellHeight ?? CELL_HEIGHT;
+
+  if (cellWidth !== CELL_WIDTH) {
+    errors.push(`cellWidth must be ${CELL_WIDTH}`);
+  }
+
+  if (cellHeight !== CELL_HEIGHT) {
+    errors.push(`cellHeight must be ${CELL_HEIGHT}`);
+  }
+
+  const frameDurationMs = resolveDefaultDuration(errors, input.frameDurationMs);
+  const actionFrameDurations = resolveActionDurations(errors, input.actionFrameDurations);
+
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+
+  return {
+    ok: true,
+    errors: [],
+    manifest: {
+      id: input.id,
+      name,
+      spritesheet,
+      cellWidth,
+      cellHeight,
+      frameDurationMs,
+      actionFrameDurations
+    }
+  };
+}
+
+export function getFrameDurationMs(manifest, action) {
+  if (!Object.prototype.hasOwnProperty.call(ACTION_ROWS, action)) {
+    throw new Error(`Unknown pet action: ${action}`);
+  }
+
+  const override = manifest.actionFrameDurations?.[action];
+  return Number.isFinite(override) ? override : manifest.frameDurationMs;
+}
+
+function resolveDefaultDuration(errors, value) {
+  if (value === undefined) {
+    return DEFAULT_FRAME_DURATION_MS;
+  }
+
+  if (!Number.isFinite(value) || value <= 0) {
+    errors.push("frameDurationMs must be a positive number");
+    return DEFAULT_FRAME_DURATION_MS;
+  }
+
+  return value;
+}
+
+function resolveActionDurations(errors, value) {
+  if (value === undefined) {
+    return {};
+  }
+
+  if (!isPlainObject(value)) {
+    errors.push("actionFrameDurations must be an object");
+    return {};
+  }
+
+  const resolved = {};
+  for (const [action, duration] of Object.entries(value)) {
+    if (!Object.prototype.hasOwnProperty.call(ACTION_ROWS, action)) {
+      errors.push(`actionFrameDurations contains unknown action: ${action}`);
+      continue;
+    }
+
+    if (!Number.isFinite(duration) || duration <= 0) {
+      errors.push(`actionFrameDurations.${action} must be a positive number`);
+      continue;
+    }
+
+    resolved[action] = duration;
+  }
+
+  return resolved;
+}
+
+function requireNonEmptyString(errors, value, fieldName) {
+  if (typeof value !== "string" || value.trim() === "") {
+    errors.push(`${fieldName} must be a non-empty string`);
+  }
+}
+
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/pet-core/src/validation.js

@@ -0,0 +1,43 @@
+import { ACTION_ROWS, ATLAS_HEIGHT, ATLAS_WIDTH } from "./atlas.js";
+import { parsePetManifest } from "./manifest.js";
+
+export function validateAtlasDimensions(dimensions) {
+  const errors = [];
+
+  if (!dimensions || dimensions.width !== ATLAS_WIDTH || dimensions.height !== ATLAS_HEIGHT) {
+    errors.push(
+      `spritesheet must be ${ATLAS_WIDTH}x${ATLAS_HEIGHT}, received ${dimensions?.width}x${dimensions?.height}`
+    );
+  }
+
+  return { ok: errors.length === 0, errors };
+}
+
+export function validatePetActions(actionFrameCounts) {
+  const errors = [];
+  const counts = actionFrameCounts ?? {};
+
+  for (const action of Object.keys(ACTION_ROWS)) {
+    const frameCount = counts[action];
+
+    if (!Number.isInteger(frameCount) || frameCount <= 0) {
+      errors.push(`action "${action}" must have at least one used cell`);
+    }
+  }
+
+  return { ok: errors.length === 0, errors };
+}
+
+export function validatePet({ manifest, dimensions, actionFrameCounts } = {}) {
+  const errors = [];
+
+  const manifestResult = parsePetManifest(manifest);
+  if (!manifestResult.ok) {
+    errors.push(...manifestResult.errors);
+  }
+
+  errors.push(...validateAtlasDimensions(dimensions).errors);
+  errors.push(...validatePetActions(actionFrameCounts).errors);
+
+  return { ok: errors.length === 0, errors };
+}