@hayasaka7/haya-pet 0.2.0 → 0.2.1

package/packages/adapters/test/codex-transcript.test.mjs

@@ -0,0 +1,97 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { parseCodexTranscriptLine, parseCodexTranscriptLines } from "../src/codex-transcript.js";
+
+test("parseCodexTranscriptLine reports shell tool starts as running tools", () => {
+  const event = parseCodexTranscriptLine(JSON.stringify({
+    type: "response_item",
+    payload: {
+      type: "function_call",
+      name: "shell_command",
+      call_id: "call_shell"
+    }
+  }));
+
+  assert.deepEqual(event, {
+    type: "tool_started",
+    toolCallId: "call_shell",
+    toolName: "shell_command",
+    state: "running_tool"
+  });
+});
+
+test("parseCodexTranscriptLine reports apply_patch starts as file editing", () => {
+  const event = parseCodexTranscriptLine(JSON.stringify({
+    type: "response_item",
+    payload: {
+      type: "custom_tool_call",
+      name: "apply_patch",
+      call_id: "call_patch"
+    }
+  }));
+
+  assert.deepEqual(event, {
+    type: "tool_started",
+    toolCallId: "call_patch",
+    toolName: "apply_patch",
+    state: "editing_files"
+  });
+});
+
+test("parseCodexTranscriptLine reports tool output as tool finished", () => {
+  const event = parseCodexTranscriptLine(JSON.stringify({
+    type: "response_item",
+    payload: {
+      type: "function_call_output",
+      call_id: "call_shell",
+      output: "done"
+    }
+  }));
+
+  assert.deepEqual(event, {
+    type: "tool_finished",
+    toolCallId: "call_shell"
+  });
+});
+
+test("parseCodexTranscriptLines ignores malformed and unrelated lines", () => {
+  const lines = [
+    "",
+    "{not-json",
+    JSON.stringify({ type: "event_msg", payload: { type: "agent_message" } }),
+    JSON.stringify({ type: "response_item", payload: { type: "function_call", name: "shell_command", call_id: "call_1" } })
+  ];
+
+  assert.deepEqual(parseCodexTranscriptLines(lines), [
+    {
+      type: "tool_started",
+      toolCallId: "call_1",
+      toolName: "shell_command",
+      state: "running_tool"
+    }
+  ]);
+});
+
+test("parseCodexTranscriptLines can skip records older than the session start", () => {
+  const lines = [
+    JSON.stringify({
+      timestamp: "2026-06-08T10:59:59.000Z",
+      type: "response_item",
+      payload: { type: "function_call", name: "shell_command", call_id: "call_old" }
+    }),
+    JSON.stringify({
+      timestamp: "2026-06-08T11:00:01.000Z",
+      type: "response_item",
+      payload: { type: "function_call", name: "shell_command", call_id: "call_new" }
+    })
+  ];
+
+  assert.deepEqual(parseCodexTranscriptLines(lines, { minTimestampMs: Date.parse("2026-06-08T11:00:00.000Z") }), [
+    {
+      type: "tool_started",
+      toolCallId: "call_new",
+      toolName: "shell_command",
+      state: "running_tool"
+    }
+  ]);
+});

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

@@ -13,23 +13,28 @@ export function createDefaultPositionState() {
     settings: {
       displayMode: "hybrid",
       attachBubblesToTerminals: true,
-      claudeHooks: false
+      hooksEnabled: false
     }
   };
 }
 
-export function setClaudeHooksEnabled(state, enabled) {
+// Global live-status hooks toggle — covers every hook-capable client (Claude Code,
+// Codex). One switch keeps the user-facing model simple; per-run env vars still
+// override it (see resolveHooksEnabled in the CLI).
+export function setHooksEnabled(state, enabled) {
   return {
     ...state,
     settings: {
       ...state.settings,
-      claudeHooks: Boolean(enabled)
+      hooksEnabled: Boolean(enabled)
     }
   };
 }
 
-export function getClaudeHooksEnabled(state) {
-  return Boolean(state?.settings?.claudeHooks);
+export function getHooksEnabled(state) {
+  // Back-compat: honor the legacy Claude-only `claudeHooks` key if a user enabled
+  // it before the toggle went global.
+  return Boolean(state?.settings?.hooksEnabled ?? state?.settings?.claudeHooks);
 }
 
 export function updateGlobalPetPosition(state, position) {

package/packages/cli-core/src/codex-hook-injection.js

@@ -0,0 +1,49 @@
+// Resolves stable paths, builds the Codex hook settings, serializes them to TOML,
+// and writes them to a STABLE named-profile file inside CODEX_HOME. The wrapper
+// then launches `codex -p <profileName>`, which layers these hooks ON TOP of the
+// user's base config (auth/model/MCP untouched) and is inert for any codex run
+// that doesn't pass `-p <profileName>`.
+//
+// Like the Claude injector, the file path and command strings are kept identical
+// across sessions so Codex's hook-trust review only needs approving once. fnm hands
+// out a per-shell symlink for process.execPath that dies when the launching shell
+// exits, so we realpath it before baking it into the hook command.
+import { mkdirSync, realpathSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildCodexHookSettings, serializeCodexHooksToml } from "../../adapters/src/codex-hooks.js";
+
+const DEFAULT_CLI_PATH = fileURLToPath(new URL("../../../apps/cli/src/haya-pet.js", import.meta.url));
+const PROFILE_NAME = "haya-pet";
+const PROFILE_FILE = `${PROFILE_NAME}.config.toml`;
+
+export function injectCodexHooks({ nodePath, cliPath, codexHome, env = process.env } = {}) {
+  const resolvedNode = nodePath ?? safeRealpath(process.execPath);
+  const resolvedCli = cliPath ?? safeRealpath(DEFAULT_CLI_PATH);
+  const home = codexHome ?? env.CODEX_HOME ?? join(homedir(), ".codex");
+
+  const settings = buildCodexHookSettings({ nodePath: resolvedNode, cliPath: resolvedCli });
+  const toml = serializeCodexHooksToml(settings, {
+    header: "haya-pet live-status hooks profile. Managed by haya-pet; safe to delete."
+  });
+
+  // A fixed path with session-independent content: concurrent sessions just
+  // rewrite identical bytes, and the hooks stay "trusted" across launches.
+  mkdirSync(home, { recursive: true });
+  const profilePath = join(home, PROFILE_FILE);
+  writeFileSync(profilePath, toml, "utf8");
+
+  // The profile file is stable and reusable on purpose — leaving it in place is
+  // what lets Codex remember the hooks are trusted. cleanup is a no-op kept for
+  // API symmetry with the caller's finally block.
+  return { profileName: PROFILE_NAME, profilePath, cleanup: () => {} };
+}
+
+function safeRealpath(target) {
+  try {
+    return realpathSync(target);
+  } catch {
+    return target;
+  }
+}

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

@@ -0,0 +1,160 @@
+// 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 { join } from "node:path";
+import { parseCodexTranscriptLines } from "../../adapters/src/codex-transcript.js";
+
+const DEFAULT_POLL_MS = 700;
+const MTIME_SKEW_MS = 2000;
+
+export function watchCodexTranscript(options = {}) {
+  const {
+    homeDir = process.env.USERPROFILE || process.env.HOME,
+    startedAt = 0,
+    onToolEvent = () => {},
+    pollIntervalMs = DEFAULT_POLL_MS,
+    sessionsRoot,
+    transcriptPath: fixedPath,
+    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;
+
+  let transcriptPath = fixedPath;
+  let offset = 0;
+  let carry = "";
+
+  const tick = () => {
+    try {
+      if (!transcriptPath) {
+        transcriptPath = discoverCodexTranscript(root, minMtime);
+        if (!transcriptPath) {
+          return;
+        }
+        // Replay from the start rather than skipping to the end: Codex may
+        // have written the session's first tool calls before our first poll,
+        // and skipping them would lose the initial running-tool status. The
+        // per-record timestamp filter below keeps an earlier session's records
+        // (in a resumed/rotated file) from replaying as live activity.
+      }
+
+      const size = safeSize(transcriptPath);
+      if (size <= offset) {
+        if (size < offset) {
+          offset = size;
+          carry = "";
+        }
+        return;
+      }
+
+      const chunk = readRange(transcriptPath, offset, size);
+      offset = size;
+
+      const lines = (carry + chunk).split("\n");
+      carry = lines.pop() ?? "";
+
+      for (const event of parseCodexTranscriptLines(lines, { minTimestampMs: startedAt })) {
+        onToolEvent(event);
+      }
+    } catch {
+      // best-effort: transcript 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
+  };
+}
+
+export function discoverCodexTranscript(root, minMtime = 0) {
+  if (!root || !existsSync(root)) {
+    return undefined;
+  }
+
+  let newest;
+  for (const file of listJsonlFiles(root)) {
+    const mtime = safeMtime(file);
+    if (mtime < minMtime) {
+      continue;
+    }
+    if (!newest || mtime > newest.mtime) {
+      newest = { file, mtime };
+    }
+  }
+  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-hook-injection.test.mjs

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "../../../test/harness.mjs";
+import { injectCodexHooks } from "../src/codex-hook-injection.js";
+
+test("injectCodexHooks writes a stable profile into CODEX_HOME and returns its name", () => {
+  const home = mkdtempSync(join(tmpdir(), "haya-codex-home-"));
+  try {
+    const result = injectCodexHooks({
+      nodePath: "C:\\nodedir\\node.exe",
+      cliPath: "C:\\app\\haya-pet.js",
+      codexHome: home
+    });
+
+    assert.equal(result.profileName, "haya-pet");
+    assert.equal(result.profilePath, join(home, "haya-pet.config.toml"));
+
+    const toml = readFileSync(result.profilePath, "utf8");
+    assert.match(toml, /\[\[hooks\.UserPromptSubmit\]\]/);
+    assert.match(toml, /state thinking/);
+    // Program unquoted (cmd /c strips a leading quote on Windows).
+    const cmdLine = toml.split("\n").find((l) => l.startsWith("command ="));
+    assert.doesNotMatch(cmdLine, /^command = "\\"/);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("injectCodexHooks honors CODEX_HOME from env and is stable across calls", () => {
+  const home = mkdtempSync(join(tmpdir(), "haya-codex-home-"));
+  try {
+    const opts = { nodePath: "n", cliPath: "c", env: { CODEX_HOME: home } };
+    const a = injectCodexHooks(opts);
+    const first = readFileSync(a.profilePath, "utf8");
+    const b = injectCodexHooks(opts);
+    const second = readFileSync(b.profilePath, "utf8");
+
+    assert.equal(a.profilePath, join(home, "haya-pet.config.toml"));
+    assert.equal(first, second, "stable content keeps Codex hook-trust cached");
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,108 @@
+import assert from "node:assert/strict";
+import { appendFileSync, mkdirSync, mkdtempSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "../../../test/harness.mjs";
+import { discoverCodexTranscript, watchCodexTranscript } from "../src/codex-transcript-watcher.js";
+
+const noopTimers = { setInterval: () => ({}), clearInterval: () => {} };
+
+function toolStart(toolName = "shell_command", callId = "call_1", timestamp) {
+  return `${JSON.stringify({
+    ...(timestamp ? { timestamp } : {}),
+    type: "response_item",
+    payload: { type: "function_call", name: toolName, call_id: callId }
+  })}\n`;
+}
+
+test("discoverCodexTranscript finds the newest session jsonl under date folders", () => {
+  const root = mkdtempSync(join(tmpdir(), "codex-sessions-"));
+  const oldDir = join(root, "2026", "06", "07");
+  const newDir = join(root, "2026", "06", "08");
+  mkdirSync(oldDir, { recursive: true });
+  mkdirSync(newDir, { recursive: true });
+
+  const oldFile = join(oldDir, "rollout-old.jsonl");
+  const newFile = join(newDir, "rollout-new.jsonl");
+  writeFileSync(oldFile, "{}\n");
+  writeFileSync(newFile, "{}\n");
+  appendFileSync(newFile, "{}\n");
+
+  assert.equal(discoverCodexTranscript(root), newFile);
+});
+
+test("discoverCodexTranscript skips files older than session start", () => {
+  const root = mkdtempSync(join(tmpdir(), "codex-sessions-"));
+  const dir = join(root, "2026", "06", "08");
+  mkdirSync(dir, { recursive: true });
+
+  const oldFile = join(dir, "rollout-old.jsonl");
+  writeFileSync(oldFile, "{}\n");
+  const past = new Date(Date.now() - 3_600_000);
+  utimesSync(oldFile, past, past);
+
+  assert.equal(discoverCodexTranscript(root, Date.now() - 1000), undefined);
+});
+
+test("watchCodexTranscript reports appended tool events", () => {
+  const dir = mkdtempSync(join(tmpdir(), "codex-transcript-"));
+  const path = join(dir, "session.jsonl");
+  writeFileSync(path, "");
+
+  const events = [];
+  const watcher = watchCodexTranscript({
+    transcriptPath: path,
+    onToolEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+  appendFileSync(path, toolStart("shell_command", "call_shell"));
+  watcher._tick();
+
+  assert.deepEqual(events, [
+    {
+      type: "tool_started",
+      toolCallId: "call_shell",
+      toolName: "shell_command",
+      state: "running_tool"
+    }
+  ]);
+
+  watcher.stop();
+});
+
+test("watchCodexTranscript replays current-session records when a transcript is first discovered", () => {
+  const root = mkdtempSync(join(tmpdir(), "codex-sessions-"));
+  const dir = join(root, "2026", "06", "08");
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, "rollout-new.jsonl");
+  writeFileSync(
+    path,
+    [
+      toolStart("shell_command", "call_old", "2026-06-08T10:59:59.000Z"),
+      toolStart("shell_command", "call_new", "2026-06-08T11:00:01.000Z")
+    ].join("")
+  );
+
+  const events = [];
+  const watcher = watchCodexTranscript({
+    sessionsRoot: root,
+    startedAt: Date.parse("2026-06-08T11:00:00.000Z"),
+    onToolEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+
+  assert.deepEqual(events, [
+    {
+      type: "tool_started",
+      toolCallId: "call_new",
+      toolName: "shell_command",
+      state: "running_tool"
+    }
+  ]);
+
+  watcher.stop();
+});

package/packages/daemon-core/src/approval-process-watcher.js

@@ -0,0 +1,169 @@
+// Detects that the user ACCEPTED a client's permission prompt by observing the
+// client's process tree. Claude Code (and similar CLIs) emit no hook and write
+// no transcript record at the moment of a manual approval — the only real-world
+// signal is that the approved command actually starts running as a new process
+// under the client. This watcher turns that into an event.
+//
+// Safety contract (the project rule this exists to honor): a pending-approval
+// warning must NEVER be cleared by a guess or a timer. The watcher only reports
+// "approved" when a NEW descendant process appears after the prompt and is still
+// alive on the next poll. Short-lived blips (our own hook reporter, the user's
+// hooks) die between polls and are filtered out. A missed detection is always
+// safe — the pet just keeps showing "waiting" until the tool finishes.
+
+const DEFAULT_POLL_INTERVAL_MS = 1500;
+
+// Polls a full-process-table lister and fires `onApproved` ONCE when a new
+// descendant of `rootPid` persists across two consecutive snapshots.
+export function watchForApprovedProcess(options = {}) {
+  const {
+    rootPid,
+    listProcesses,
+    onApproved = () => {},
+    pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
+    immediate = true,
+    setInterval: setIntervalFn = setInterval,
+    clearInterval: clearIntervalFn = clearInterval
+  } = options;
+
+  let baseline;
+  let candidates = new Set();
+  let stopped = false;
+  let ticking = false;
+
+  const tick = async () => {
+    if (stopped || ticking) {
+      return;
+    }
+    ticking = true;
+    try {
+      const table = await listProcesses();
+      const descendants = collectDescendants(table, rootPid);
+
+      if (!baseline) {
+        // First successful snapshot: everything already running (the client
+        // itself, its shell, the hook that reported the prompt) is baseline
+        // and can never count as the approved command.
+        baseline = descendants;
+        return;
+      }
+
+      const fresh = new Set();
+      for (const pid of descendants) {
+        if (baseline.has(pid)) {
+          continue;
+        }
+        if (candidates.has(pid)) {
+          // Seen in two consecutive snapshots — a real, persistent process.
+          stop();
+          onApproved({ pid });
+          return;
+        }
+        fresh.add(pid);
+      }
+      candidates = fresh;
+    } catch {
+      // Snapshots are best-effort; a failed poll must never break the daemon.
+    } finally {
+      ticking = false;
+    }
+  };
+
+  const timer = setIntervalFn(tick, pollIntervalMs);
+  if (timer && typeof timer.unref === "function") {
+    timer.unref();
+  }
+
+  function stop() {
+    if (stopped) {
+      return;
+    }
+    stopped = true;
+    clearIntervalFn(timer);
+  }
+
+  if (immediate) {
+    // Take the baseline right away rather than a full poll interval later, so a
+    // quickly-approved command is less likely to slip into the baseline.
+    void tick();
+  }
+
+  return { stop, _tick: tick };
+}
+
+// Walks the process table for all (transitive) descendants of rootPid. The
+// client may sit behind shim layers (cmd.exe -> claude.exe -> command), so the
+// whole subtree counts, not just direct children.
+export function collectDescendants(table, rootPid) {
+  const childrenByParent = new Map();
+  for (const entry of table) {
+    if (!Number.isInteger(entry?.pid) || !Number.isInteger(entry?.ppid)) {
+      continue;
+    }
+    const siblings = childrenByParent.get(entry.ppid);
+    if (siblings) {
+      siblings.push(entry.pid);
+    } else {
+      childrenByParent.set(entry.ppid, [entry.pid]);
+    }
+  }
+
+  const descendants = new Set();
+  const queue = [rootPid];
+  while (queue.length > 0) {
+    const parent = queue.pop();
+    for (const child of childrenByParent.get(parent) ?? []) {
+      if (!descendants.has(child)) {
+        descendants.add(child);
+        queue.push(child);
+      }
+    }
+  }
+  return descendants;
+}
+
+// Bridges session state changes to per-session watchers: watch a session's
+// process tree only while it sits in waiting_approval (and has a known pid),
+// stop the moment any other state arrives (finish, denial, exit), and report
+// detections with the owning sessionId.
+export function createApprovalWatchCoordinator(options = {}) {
+  const { createWatcher, onApproved = () => {} } = options;
+  const watchers = new Map();
+
+  return {
+    onSessionChanged(session) {
+      if (!session || typeof session.sessionId !== "string") {
+        return;
+      }
+
+      const { sessionId, pid, state } = session;
+
+      if (state === "waiting_approval" && Number.isInteger(pid)) {
+        if (!watchers.has(sessionId)) {
+          const watcher = createWatcher({
+            rootPid: pid,
+            onApproved: (event) => {
+              watchers.delete(sessionId);
+              onApproved(sessionId, event);
+            }
+          });
+          watchers.set(sessionId, watcher);
+        }
+        return;
+      }
+
+      const watcher = watchers.get(sessionId);
+      if (watcher) {
+        watchers.delete(sessionId);
+        watcher.stop();
+      }
+    },
+
+    stopAll() {
+      for (const watcher of watchers.values()) {
+        watcher.stop();
+      }
+      watchers.clear();
+    }
+  };
+}