@hayasaka7/haya-pet 0.2.4 → 0.2.6

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);
-  }
-}

package/packages/cli-core/test/codex-guardian-watcher.test.mjs

@@ -0,0 +1,217 @@
+import assert from "node:assert/strict";
+import { appendFileSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "../../../test/harness.mjs";
+import { watchCodexGuardianReviews } from "../src/codex-guardian-watcher.js";
+
+const noopTimers = { setInterval: () => ({}), clearInterval: () => {} };
+
+function metaLine(payload) {
+  return `${JSON.stringify({ type: "session_meta", payload })}\n`;
+}
+
+function reviewStarted(turnId = "turn-1", timestamp) {
+  return `${JSON.stringify({
+    ...(timestamp ? { timestamp } : {}),
+    type: "event_msg",
+    payload: { type: "task_started", turn_id: turnId }
+  })}\n`;
+}
+
+function reviewFinished(outcome, turnId = "turn-1") {
+  return `${JSON.stringify({
+    type: "event_msg",
+    payload: {
+      type: "task_complete",
+      turn_id: turnId,
+      last_agent_message: JSON.stringify({ outcome })
+    }
+  })}\n`;
+}
+
+function makeSessionsRoot() {
+  const root = mkdtempSync(join(tmpdir(), "codex-guardian-"));
+  const dir = join(root, "2026", "06", "12");
+  mkdirSync(dir, { recursive: true });
+  return { root, dir };
+}
+
+test("watchCodexGuardianReviews tails the guardian trunk of the main session", () => {
+  const { root, dir } = makeSessionsRoot();
+  writeFileSync(
+    join(dir, "rollout-main.jsonl"),
+    metaLine({ id: "main-1", parent_thread_id: null, source: "cli", thread_source: "user" })
+  );
+  // A non-guardian subagent of the same parent must not be tailed.
+  writeFileSync(
+    join(dir, "rollout-collab.jsonl"),
+    metaLine({ id: "agent-1", parent_thread_id: "main-1", source: { subagent: { other: "collab" } } }) +
+      reviewStarted("decoy")
+  );
+  const trunkPath = join(dir, "rollout-guardian.jsonl");
+  writeFileSync(
+    trunkPath,
+    metaLine({ id: "guardian-1", parent_thread_id: "main-1", source: { subagent: { other: "guardian" } } })
+  );
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    onReviewEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+  assert.deepEqual(events, [], "no review turns yet");
+
+  appendFileSync(trunkPath, reviewStarted());
+  watcher._tick();
+  appendFileSync(trunkPath, reviewFinished("allow"));
+  watcher._tick();
+
+  assert.deepEqual(events, [
+    { type: "review_started" },
+    { type: "review_finished", outcome: "allow" }
+  ]);
+
+  watcher.stop();
+});
+
+test("watchCodexGuardianReviews replays a trunk discovered after the review began", () => {
+  const { root, dir } = makeSessionsRoot();
+  writeFileSync(
+    join(dir, "rollout-main.jsonl"),
+    metaLine({ id: "main-1", parent_thread_id: null, source: "cli", thread_source: "user" })
+  );
+  writeFileSync(
+    join(dir, "rollout-guardian.jsonl"),
+    metaLine({ id: "guardian-1", parent_thread_id: "main-1", source: { subagent: { other: "guardian" } } }) +
+      reviewStarted("turn-1") +
+      reviewFinished("deny", "turn-1")
+  );
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    onReviewEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+
+  assert.deepEqual(events, [
+    { type: "review_started" },
+    { type: "review_finished", outcome: "deny" }
+  ]);
+
+  watcher.stop();
+});
+
+test("watchCodexGuardianReviews skips review records from before the session start", () => {
+  const { root, dir } = makeSessionsRoot();
+  writeFileSync(
+    join(dir, "rollout-main.jsonl"),
+    metaLine({ id: "main-1", parent_thread_id: null, source: "cli", thread_source: "user" })
+  );
+  writeFileSync(
+    join(dir, "rollout-guardian.jsonl"),
+    metaLine({ id: "guardian-1", parent_thread_id: "main-1", source: { subagent: { other: "guardian" } } }) +
+      reviewStarted("turn-old", "2026-06-12T00:00:00.000Z") +
+      reviewStarted("turn-new", "2026-06-12T02:00:00.000Z")
+  );
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    startedAt: Date.parse("2026-06-12T01:00:00.000Z"),
+    onReviewEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+
+  assert.deepEqual(events, [{ type: "review_started" }]);
+
+  watcher.stop();
+});
+
+test("watchCodexGuardianReviews emits nothing without a classifiable main session", () => {
+  const { root, dir } = makeSessionsRoot();
+  // Guardian trunk exists but there is no main rollout to bind its parent to.
+  writeFileSync(
+    join(dir, "rollout-guardian.jsonl"),
+    metaLine({ id: "guardian-1", parent_thread_id: "main-1", source: { subagent: { other: "guardian" } } }) +
+      reviewStarted()
+  );
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    onReviewEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+  watcher._tick();
+
+  assert.deepEqual(events, []);
+
+  watcher.stop();
+});
+
+test("watchCodexGuardianReviews ignores guardian trunks of other parents", () => {
+  const { root, dir } = makeSessionsRoot();
+  writeFileSync(
+    join(dir, "rollout-main.jsonl"),
+    metaLine({ id: "main-1", parent_thread_id: null, source: "cli", thread_source: "user" })
+  );
+  writeFileSync(
+    join(dir, "rollout-guardian-other.jsonl"),
+    metaLine({ id: "guardian-9", parent_thread_id: "someone-else", source: { subagent: { other: "guardian" } } }) +
+      reviewStarted()
+  );
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    onReviewEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+
+  assert.deepEqual(events, []);
+
+  watcher.stop();
+});
+
+test("watchCodexGuardianReviews picks up a trunk created after watching began", () => {
+  const { root, dir } = makeSessionsRoot();
+  writeFileSync(
+    join(dir, "rollout-main.jsonl"),
+    metaLine({ id: "main-1", parent_thread_id: null, source: "cli", thread_source: "user" })
+  );
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    onReviewEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+  assert.deepEqual(events, [], "no trunk yet");
+
+  const trunkPath = join(dir, "rollout-guardian.jsonl");
+  writeFileSync(
+    trunkPath,
+    metaLine({ id: "guardian-1", parent_thread_id: "main-1", source: { subagent: { other: "guardian" } } }) +
+      reviewStarted()
+  );
+  watcher._tick();
+
+  assert.deepEqual(events, [{ type: "review_started" }]);
+
+  watcher.stop();
+});

package/.github/workflows/ci.yml

@@ -1,75 +0,0 @@
-name: CI
-
-# Run code quality checks and the test suite on every push that touches code.
-on:
-  push:
-    paths:
-      - "**/*.js"
-      - "**/*.mjs"
-      - "**/*.cjs"
-      - "package.json"
-      - "package-lock.json"
-      - ".github/workflows/ci.yml"
-  pull_request:
-    paths:
-      - "**/*.js"
-      - "**/*.mjs"
-      - "**/*.cjs"
-      - "package.json"
-      - "package-lock.json"
-      - ".github/workflows/ci.yml"
-
-concurrency:
-  group: ci-${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  lint:
-    name: Code quality (ESLint)
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          cache: npm
-
-      - name: Install dependencies
-        # Electron's binary isn't needed for linting or tests; skip the ~150 MB
-        # download so CI is fast and isn't at the mercy of the Electron CDN.
-        env:
-          ELECTRON_SKIP_BINARY_DOWNLOAD: "1"
-        run: npm ci
-
-      - name: Run ESLint
-        run: npm run lint
-
-  test:
-    name: Tests (Node ${{ matrix.node }} on ${{ matrix.os }})
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        node: [20, 22]
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-          cache: npm
-
-      - name: Install dependencies
-        env:
-          ELECTRON_SKIP_BINARY_DOWNLOAD: "1"
-        run: npm ci
-
-      - name: Run the test suite
-        run: npm test

package/.github/workflows/release.yml

@@ -1,61 +0,0 @@
-name: Release
-
-# Publish to npm when a version tag is pushed, e.g.:
-#   npm version patch            # bumps package.json + creates a vX.Y.Z tag
-#   git push --follow-tags
-# or manually:
-#   git tag v0.1.1 && git push origin v0.1.1
-on:
-  push:
-    tags:
-      - "v*"
-
-permissions:
-  contents: read
-  id-token: write # required for npm provenance (--provenance)
-
-concurrency:
-  group: release-${{ github.ref }}
-  cancel-in-progress: false
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out the tagged commit
-        uses: actions/checkout@v4
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          registry-url: "https://registry.npmjs.org"
-
-      - name: Install dependencies
-        # Electron's binary isn't needed to test or publish; skip the ~150 MB
-        # download so CI is fast and isn't at the mercy of the Electron CDN.
-        env:
-          ELECTRON_SKIP_BINARY_DOWNLOAD: "1"
-        run: npm ci
-
-      - name: Run the test suite
-        run: npm test
-
-      - name: Verify the tag matches package.json version
-        run: |
-          TAG="${GITHUB_REF_NAME#v}"
-          PKG="$(node -p "require('./package.json').version")"
-          echo "tag=$TAG package.json=$PKG"
-          if [ "$TAG" != "$PKG" ]; then
-            echo "::error::Tag v$TAG does not match package.json version $PKG"
-            exit 1
-          fi
-
-      - name: Publish to npm
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-        # --access public is needed for the first publish of a scoped package and
-        # harmless otherwise. --provenance attaches a signed build attestation
-        # (requires a public repo + the id-token permission above; drop it if the
-        # repo is private).
-        run: npm publish --provenance --access public