@hayasaka7/haya-pet 0.2.5 → 0.2.7

package/packages/app-state/src/update-check.js

@@ -0,0 +1,173 @@
+// Best-effort npm update check shared by the CLI (one-line notice) and the
+// companion (tray item). One small registry request per TTL window, cached in
+// state.json so the CLI and companion share it; every failure path resolves to
+// undefined — an update notice must never block or break a run. Opt out with
+// HAYA_PET_NO_UPDATE_CHECK=1.
+
+export const UPDATE_PACKAGE_NAME = "@hayasaka7/haya-pet";
+export const UPDATE_COMMAND = `npm install -g ${UPDATE_PACKAGE_NAME}`;
+export const UPDATE_PAGE_URL = `https://www.npmjs.com/package/${UPDATE_PACKAGE_NAME}`;
+
+// The version-specific manifest (a few KB) — not the full packument.
+const REGISTRY_LATEST_URL = "https://registry.npmjs.org/@hayasaka7%2fhaya-pet/latest";
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_TIMEOUT_MS = 3000;
+
+// Strictly-numeric dotted compare ("v" prefix tolerated). Anything else —
+// prerelease tags, garbage, missing values — is conservatively "not newer",
+// so a weird registry response can never produce a false update nag.
+export function isNewerVersion(candidate, current) {
+  const a = parseVersion(candidate);
+  const b = parseVersion(current);
+  if (!a || !b) {
+    return false;
+  }
+
+  for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+    const x = a[i] ?? 0;
+    const y = b[i] ?? 0;
+    if (x !== y) {
+      return x > y;
+    }
+  }
+  return false;
+}
+
+function parseVersion(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    return undefined;
+  }
+  const parts = value.trim().replace(/^v/, "").split(".");
+  if (!parts.every((part) => /^\d+$/.test(part))) {
+    return undefined;
+  }
+  return parts.map((part) => Number.parseInt(part, 10));
+}
+
+export function getLastUpdateCheck(state) {
+  const entry = state?.updateCheck;
+  if (!entry || typeof entry !== "object") {
+    return undefined;
+  }
+  return entry;
+}
+
+export function setUpdateCheck(state, { checkedAt, latestVersion }) {
+  return {
+    ...state,
+    updateCheck: { checkedAt, latestVersion }
+  };
+}
+
+// Resolve the latest published version from the npm registry. The outer timer
+// (not request.setTimeout) also covers DNS stalls, which happen before any
+// socket exists. Always resolves — undefined on any failure.
+export function fetchLatestVersion({
+  url = REGISTRY_LATEST_URL,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  get
+} = {}) {
+  return new Promise((resolve) => {
+    let request;
+    let settled = false;
+    const settle = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      try {
+        request?.destroy?.();
+      } catch {
+        // already closed
+      }
+      resolve(value);
+    };
+
+    // Deliberately ref'd: this timer is what guarantees the promise settles
+    // (and an awaiting caller terminates) even when the request never responds
+    // — e.g. a DNS stall. It is cleared the moment anything else settles, so it
+    // never holds the process open after a normal success or failure.
+    const timer = setTimeout(() => settle(undefined), timeoutMs);
+
+    resolveGet(get)
+      .then((getFn) => {
+        if (settled) {
+          return;
+        }
+        request = getFn(url, { headers: { accept: "application/json" } }, (response) => {
+          if (response.statusCode !== 200) {
+            response.resume();
+            settle(undefined);
+            return;
+          }
+          let body = "";
+          response.setEncoding("utf8");
+          response.on("data", (chunk) => {
+            body += chunk;
+          });
+          response.on("end", () => {
+            try {
+              const version = JSON.parse(body)?.version;
+              settle(typeof version === "string" ? version : undefined);
+            } catch {
+              settle(undefined);
+            }
+          });
+        });
+        request.on("error", () => settle(undefined));
+      })
+      .catch(() => settle(undefined));
+  });
+}
+
+// node:https is imported lazily so merely loading this module (e.g. from the
+// renderer-adjacent companion code or tests) never touches the network stack.
+async function resolveGet(get) {
+  if (get) {
+    return get;
+  }
+  const https = await import("node:https");
+  return https.get;
+}
+
+// The single entry point: load the cached result (or fetch + cache it), and
+// report `{ currentVersion, latestVersion }` only when an update exists.
+// Never throws and never rejects.
+export async function checkForUpdate(options = {}) {
+  const {
+    currentVersion,
+    stateFile,
+    env = process.env,
+    now = Date.now,
+    ttlMs = DEFAULT_TTL_MS,
+    fetchLatest = fetchLatestVersion
+  } = options;
+
+  try {
+    if (env.HAYA_PET_NO_UPDATE_CHECK === "1" || env.HAYA_PET_NO_UPDATE_CHECK === "true") {
+      return undefined;
+    }
+    if (typeof currentVersion !== "string" || currentVersion === "" || !stateFile) {
+      return undefined;
+    }
+
+    const state = await stateFile.load();
+    const cached = getLastUpdateCheck(state);
+
+    let latestVersion;
+    if (cached && Number.isFinite(cached.checkedAt) && now() - cached.checkedAt < ttlMs) {
+      latestVersion = cached.latestVersion;
+    } else {
+      latestVersion = await fetchLatest();
+      if (typeof latestVersion !== "string" || latestVersion === "") {
+        return undefined;
+      }
+      await stateFile.save(setUpdateCheck(state, { checkedAt: now(), latestVersion }));
+    }
+
+    return isNewerVersion(latestVersion, currentVersion) ? { currentVersion, latestVersion } : undefined;
+  } catch {
+    return undefined;
+  }
+}

package/packages/app-state/test/update-check.test.mjs

@@ -0,0 +1,227 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { parsePositionState, serializePositionState } from "../src/state.js";
+import {
+  checkForUpdate,
+  fetchLatestVersion,
+  getLastUpdateCheck,
+  isNewerVersion,
+  setUpdateCheck
+} from "../src/update-check.js";
+
+test("isNewerVersion compares dotted numeric versions", () => {
+  assert.equal(isNewerVersion("0.2.8", "0.2.7"), true);
+  assert.equal(isNewerVersion("0.3.0", "0.2.7"), true);
+  assert.equal(isNewerVersion("1.0.0", "0.9.9"), true);
+  assert.equal(isNewerVersion("0.2.10", "0.2.9"), true);
+  assert.equal(isNewerVersion("v0.2.8", "0.2.7"), true);
+
+  assert.equal(isNewerVersion("0.2.7", "0.2.7"), false);
+  assert.equal(isNewerVersion("0.2.6", "0.2.7"), false);
+  assert.equal(isNewerVersion("0.2", "0.2.0"), false);
+});
+
+test("isNewerVersion is conservative about unparseable versions", () => {
+  assert.equal(isNewerVersion(undefined, "0.2.7"), false);
+  assert.equal(isNewerVersion("0.3.0", undefined), false);
+  assert.equal(isNewerVersion("not-a-version", "0.2.7"), false);
+  assert.equal(isNewerVersion("0.3.0-beta.1", "0.2.7"), false);
+});
+
+test("setUpdateCheck stores the cache immutably and survives (de)serialization", () => {
+  const original = parsePositionState("{}");
+  const updated = setUpdateCheck(original, { checkedAt: 123, latestVersion: "0.3.0" });
+
+  assert.equal(getLastUpdateCheck(original), undefined, "original state untouched");
+  assert.deepEqual(getLastUpdateCheck(updated), { checkedAt: 123, latestVersion: "0.3.0" });
+
+  const reloaded = parsePositionState(serializePositionState(updated));
+  assert.deepEqual(getLastUpdateCheck(reloaded), { checkedAt: 123, latestVersion: "0.3.0" });
+});
+
+function memoryStateFile(initial = parsePositionState("{}")) {
+  let state = initial;
+  const saves = [];
+  return {
+    load: async () => state,
+    save: async (next) => {
+      state = next;
+      saves.push(next);
+      return next;
+    },
+    saves
+  };
+}
+
+test("checkForUpdate fetches, caches, and reports a newer version", async () => {
+  const stateFile = memoryStateFile();
+  let fetches = 0;
+
+  const result = await checkForUpdate({
+    currentVersion: "0.2.7",
+    stateFile,
+    env: {},
+    now: () => 1000,
+    fetchLatest: async () => {
+      fetches += 1;
+      return "0.3.0";
+    }
+  });
+
+  assert.deepEqual(result, { currentVersion: "0.2.7", latestVersion: "0.3.0" });
+  assert.equal(fetches, 1);
+  assert.deepEqual(getLastUpdateCheck(stateFile.saves[0]), { checkedAt: 1000, latestVersion: "0.3.0" });
+});
+
+test("checkForUpdate uses a fresh cache without fetching", async () => {
+  const cached = setUpdateCheck(parsePositionState("{}"), { checkedAt: 1000, latestVersion: "0.3.0" });
+  const stateFile = memoryStateFile(cached);
+
+  const result = await checkForUpdate({
+    currentVersion: "0.2.7",
+    stateFile,
+    env: {},
+    now: () => 1000 + 60_000,
+    fetchLatest: async () => {
+      throw new Error("must not fetch while the cache is fresh");
+    }
+  });
+
+  assert.deepEqual(result, { currentVersion: "0.2.7", latestVersion: "0.3.0" });
+  assert.equal(stateFile.saves.length, 0, "fresh cache is not re-saved");
+});
+
+test("checkForUpdate refetches once the cache expires", async () => {
+  const cached = setUpdateCheck(parsePositionState("{}"), { checkedAt: 0, latestVersion: "0.2.8" });
+  const stateFile = memoryStateFile(cached);
+
+  const result = await checkForUpdate({
+    currentVersion: "0.2.7",
+    stateFile,
+    env: {},
+    now: () => 25 * 60 * 60 * 1000,
+    ttlMs: 24 * 60 * 60 * 1000,
+    fetchLatest: async () => "0.4.0"
+  });
+
+  assert.equal(result.latestVersion, "0.4.0");
+  assert.equal(stateFile.saves.length, 1);
+});
+
+test("checkForUpdate reports nothing when already up to date", async () => {
+  const result = await checkForUpdate({
+    currentVersion: "0.3.0",
+    stateFile: memoryStateFile(),
+    env: {},
+    now: () => 1000,
+    fetchLatest: async () => "0.3.0"
+  });
+
+  assert.equal(result, undefined);
+});
+
+test("checkForUpdate is silent on opt-out, failure, and bad input", async () => {
+  const optedOut = await checkForUpdate({
+    currentVersion: "0.2.7",
+    stateFile: memoryStateFile(),
+    env: { HAYA_PET_NO_UPDATE_CHECK: "1" },
+    fetchLatest: async () => "9.9.9"
+  });
+  assert.equal(optedOut, undefined);
+
+  const fetchFailed = await checkForUpdate({
+    currentVersion: "0.2.7",
+    stateFile: memoryStateFile(),
+    env: {},
+    fetchLatest: async () => undefined
+  });
+  assert.equal(fetchFailed, undefined);
+
+  const loadFailed = await checkForUpdate({
+    currentVersion: "0.2.7",
+    stateFile: { load: async () => { throw new Error("disk"); }, save: async () => {} },
+    env: {},
+    fetchLatest: async () => "9.9.9"
+  });
+  assert.equal(loadFailed, undefined);
+
+  const noVersion = await checkForUpdate({
+    currentVersion: undefined,
+    stateFile: memoryStateFile(),
+    env: {},
+    fetchLatest: async () => "9.9.9"
+  });
+  assert.equal(noVersion, undefined);
+});
+
+function fakeResponse({ statusCode = 200, body = "" } = {}) {
+  const handlers = {};
+  return {
+    statusCode,
+    setEncoding() {},
+    resume() {},
+    on(event, handler) {
+      handlers[event] = handler;
+      return this;
+    },
+    emit(event, payload) {
+      handlers[event]?.(payload);
+    },
+    body
+  };
+}
+
+function fakeGet({ response, requestError } = {}) {
+  return (url, options, onResponse) => {
+    const handlers = {};
+    const request = {
+      on(event, handler) {
+        handlers[event] = handler;
+        return this;
+      },
+      destroy() {
+        this.destroyed = true;
+      }
+    };
+    queueMicrotask(() => {
+      if (requestError) {
+        handlers.error?.(requestError);
+        return;
+      }
+      onResponse(response);
+      response.emit("data", response.body);
+      response.emit("end");
+    });
+    return request;
+  };
+}
+
+test("fetchLatestVersion extracts the version from the registry response", async () => {
+  const version = await fetchLatestVersion({
+    get: fakeGet({ response: fakeResponse({ body: '{"name":"x","version":"0.3.0"}' }) })
+  });
+  assert.equal(version, "0.3.0");
+});
+
+test("fetchLatestVersion resolves undefined on bad status, bad JSON, and errors", async () => {
+  assert.equal(
+    await fetchLatestVersion({ get: fakeGet({ response: fakeResponse({ statusCode: 404, body: "{}" }) }) }),
+    undefined
+  );
+  assert.equal(
+    await fetchLatestVersion({ get: fakeGet({ response: fakeResponse({ body: "not json" }) }) }),
+    undefined
+  );
+  assert.equal(
+    await fetchLatestVersion({ get: fakeGet({ requestError: new Error("offline") }) }),
+    undefined
+  );
+});
+
+test("fetchLatestVersion times out instead of hanging", async () => {
+  const version = await fetchLatestVersion({
+    timeoutMs: 5,
+    get: () => ({ on() { return this; }, destroy() {} }) // never responds
+  });
+  assert.equal(version, undefined);
+});

package/packages/cli-core/src/codex-guardian-watcher.js

@@ -0,0 +1,136 @@
+// Tails the Codex guardian-review trunk rollout and reports review lifecycle
+// events. With `approvals_reviewer = auto_review` ("Approve for me"), Codex
+// never shows the human approval UI for guardian-routed requests — the
+// PermissionRequest hook fires at request creation, then a guardian subagent
+// decides. No hook fires when the review starts or finishes and the
+// GuardianAssessment events are not persisted to the main rollout, so the
+// guardian's own rollout (one trunk per parent thread, one turn per review) is
+// the only observable, event-backed signal. This watcher exists so the pet can
+// show "reviewing" during the auto-review instead of a false "waiting for
+// approval", without ever clearing a real pending approval on a guess.
+import { join } from "node:path";
+import {
+  classifyCodexSessionMeta,
+  parseGuardianTranscriptLines
+} from "../../adapters/src/codex-guardian.js";
+import { listJsonlFiles, readFirstLine, readRange, safeMtime, safeSize } from "./codex-rollout-fs.js";
+
+const DEFAULT_POLL_MS = 700;
+const MTIME_SKEW_MS = 2000;
+
+export function watchCodexGuardianReviews(options = {}) {
+  const {
+    homeDir = process.env.USERPROFILE || process.env.HOME,
+    startedAt = 0,
+    onReviewEvent = () => {},
+    pollIntervalMs = DEFAULT_POLL_MS,
+    sessionsRoot,
+    setInterval: setIntervalFn = setInterval,
+    clearInterval: clearIntervalFn = clearInterval
+  } = options;
+
+  const root = sessionsRoot ?? (homeDir ? join(homeDir, ".codex", "sessions") : undefined);
+  const minMtime = startedAt > 0 ? startedAt - MTIME_SKEW_MS : 0;
+
+  // session_meta classifications are immutable once written, so cache them by
+  // path. A file with no complete first line yet is NOT cached — it is retried
+  // on the next poll (the rollout may still be flushing).
+  const metaByPath = new Map();
+  let mainThreadId;
+  let trunkPath;
+  let offset = 0;
+  let carry = "";
+
+  const classify = (file) => {
+    if (metaByPath.has(file)) {
+      return metaByPath.get(file);
+    }
+    const firstLine = readFirstLine(file);
+    if (firstLine === undefined) {
+      return undefined;
+    }
+    const meta = classifyCodexSessionMeta(firstLine) ?? null;
+    metaByPath.set(file, meta);
+    return meta;
+  };
+
+  const discoverTrunk = () => {
+    let newestMain;
+    let newestTrunk;
+
+    for (const file of listJsonlFiles(root)) {
+      const mtime = safeMtime(file);
+      if (mtime < minMtime) {
+        continue;
+      }
+      const meta = classify(file);
+      if (!meta) {
+        continue;
+      }
+
+      if (meta.kind === "main" && meta.threadId && (!newestMain || mtime > newestMain.mtime)) {
+        newestMain = { threadId: meta.threadId, mtime };
+      }
+      if (meta.kind === "guardian" && (!newestTrunk || mtime > newestTrunk.mtime)) {
+        newestTrunk = { file, parentThreadId: meta.parentThreadId, mtime };
+      }
+    }
+
+    // The guardian trunk only appears at the first review, usually long after
+    // the main rollout — bind the main thread first, then match the trunk to
+    // it so another session's (or a collab subagent's) reviews are ignored.
+    mainThreadId = mainThreadId ?? newestMain?.threadId;
+    if (mainThreadId && newestTrunk?.parentThreadId === mainThreadId) {
+      // Replay the trunk from the start: the first review is usually still in
+      // progress when we find the file, and the per-record timestamp filter
+      // keeps an earlier session's reviews from replaying as live events.
+      trunkPath = newestTrunk.file;
+      offset = 0;
+      carry = "";
+    }
+  };
+
+  const tick = () => {
+    try {
+      if (!trunkPath) {
+        discoverTrunk();
+        if (!trunkPath) {
+          return;
+        }
+      }
+
+      const size = safeSize(trunkPath);
+      if (size <= offset) {
+        if (size < offset) {
+          offset = size;
+          carry = "";
+        }
+        return;
+      }
+
+      const chunk = readRange(trunkPath, offset, size);
+      offset = size;
+
+      const lines = (carry + chunk).split("\n");
+      carry = lines.pop() ?? "";
+
+      for (const event of parseGuardianTranscriptLines(lines, { minTimestampMs: startedAt })) {
+        onReviewEvent(event);
+      }
+    } catch {
+      // best-effort: rollout surprises must never crash the wrapper
+    }
+  };
+
+  const timer = setIntervalFn(tick, pollIntervalMs);
+  if (timer && typeof timer.unref === "function") {
+    timer.unref();
+  }
+
+  return {
+    stop() {
+      clearIntervalFn(timer);
+    },
+    _tick: tick
+  };
+}

package/packages/cli-core/src/codex-rollout-fs.js

@@ -0,0 +1,88 @@
+// Shared best-effort filesystem helpers for tailing Codex rollout JSONL files
+// (~/.codex/sessions/<y>/<m>/<d>/rollout-*.jsonl). Used by the main transcript
+// watcher and the guardian-review watcher. Every helper swallows fs errors —
+// rollout surprises must never crash the wrapper.
+import { closeSync, existsSync, openSync, readdirSync, readSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+// A session_meta first line is normally a few KB, but guardian trunks embed the
+// reviewer's full base instructions (~10 KB observed); leave generous headroom.
+const FIRST_LINE_MAX_BYTES = 262_144;
+
+export function listJsonlFiles(root) {
+  const files = [];
+  if (!root || !existsSync(root)) {
+    return files;
+  }
+
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        files.push(full);
+      }
+    }
+  }
+
+  return files;
+}
+
+export function safeSize(path) {
+  try {
+    return statSync(path).size;
+  } catch {
+    return 0;
+  }
+}
+
+export function safeMtime(path) {
+  try {
+    return statSync(path).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+export function readRange(path, start, end) {
+  const length = end - start;
+  if (length <= 0) {
+    return "";
+  }
+  const fd = openSync(path, "r");
+  try {
+    const buffer = Buffer.alloc(length);
+    const bytesRead = readSync(fd, buffer, 0, length, start);
+    return buffer.toString("utf8", 0, bytesRead);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// First newline-terminated line of a file, or undefined while none exists yet
+// (a rollout that was just created and not flushed). Callers must treat
+// undefined as "retry later", never as a final classification.
+export function readFirstLine(path, maxBytes = FIRST_LINE_MAX_BYTES) {
+  let chunk;
+  try {
+    chunk = readRange(path, 0, Math.min(safeSize(path), maxBytes));
+  } catch {
+    return undefined;
+  }
+
+  const newlineIndex = chunk.indexOf("\n");
+  if (newlineIndex === -1) {
+    return undefined;
+  }
+  return chunk.slice(0, newlineIndex);
+}

package/packages/cli-core/src/codex-transcript-watcher.js

@@ -1,16 +1,10 @@
 // Tails Codex session JSONL and reports tool start/finish activity. Codex hooks
 // cover turn lifecycle, but the transcript is the reliable source for tool use
 // when PreToolUse is unavailable.
-import {
-  closeSync,
-  existsSync,
-  openSync,
-  readdirSync,
-  readSync,
-  statSync
-} from "node:fs";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { parseCodexTranscriptLines } from "../../adapters/src/codex-transcript.js";
+import { listJsonlFiles, readRange, safeMtime, safeSize } from "./codex-rollout-fs.js";
 
 const DEFAULT_POLL_MS = 700;
 const MTIME_SKEW_MS = 2000;
@@ -101,60 +95,3 @@ export function discoverCodexTranscript(root, minMtime = 0) {
   }
   return newest?.file;
 }
-
-function listJsonlFiles(root) {
-  const files = [];
-  const stack = [root];
-
-  while (stack.length > 0) {
-    const dir = stack.pop();
-    let entries;
-    try {
-      entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-
-    for (const entry of entries) {
-      const full = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        stack.push(full);
-      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-        files.push(full);
-      }
-    }
-  }
-
-  return files;
-}
-
-function safeSize(path) {
-  try {
-    return statSync(path).size;
-  } catch {
-    return 0;
-  }
-}
-
-function safeMtime(path) {
-  try {
-    return statSync(path).mtimeMs;
-  } catch {
-    return 0;
-  }
-}
-
-function readRange(path, start, end) {
-  const length = end - start;
-  if (length <= 0) {
-    return "";
-  }
-  const fd = openSync(path, "r");
-  try {
-    const buffer = Buffer.alloc(length);
-    const bytesRead = readSync(fd, buffer, 0, length, start);
-    return buffer.toString("utf8", 0, bytesRead);
-  } finally {
-    closeSync(fd);
-  }
-}