@hayasaka7/haya-pet 0.2.0 → 0.2.2

package/packages/adapters/src/codex-transcript.js

@@ -0,0 +1,73 @@
+// Pure parser for Codex session JSONL records. This is the L3 fallback for live
+// tool activity because Codex PreToolUse hooks may not fire in some builds, while
+// the session transcript still records every tool call and tool result.
+
+const EDIT_TOOLS = new Set(["apply_patch"]);
+
+export function parseCodexTranscriptLine(line, options = {}) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return undefined;
+  }
+
+  if (entry?.type !== "response_item") {
+    return undefined;
+  }
+
+  // Skip records from before the current session (used when replaying a
+  // freshly-discovered transcript so an earlier session's tool calls don't
+  // masquerade as live activity). Records without a parseable timestamp are
+  // kept — losing live events is worse than a rare stale one.
+  const minTimestampMs = options.minTimestampMs ?? 0;
+  if (minTimestampMs > 0 && typeof entry.timestamp === "string") {
+    const timestampMs = Date.parse(entry.timestamp);
+    if (Number.isFinite(timestampMs) && timestampMs < minTimestampMs) {
+      return undefined;
+    }
+  }
+
+  const payload = entry.payload;
+  if (!payload || typeof payload !== "object") {
+    return undefined;
+  }
+
+  if (payload.type === "function_call" || payload.type === "custom_tool_call") {
+    const toolName = typeof payload.name === "string" ? payload.name : undefined;
+    const toolCallId = typeof payload.call_id === "string" ? payload.call_id : undefined;
+    if (!toolName || !toolCallId) {
+      return undefined;
+    }
+    return {
+      type: "tool_started",
+      toolCallId,
+      toolName,
+      state: EDIT_TOOLS.has(toolName) ? "editing_files" : "running_tool"
+    };
+  }
+
+  if (payload.type === "function_call_output" || payload.type === "custom_tool_call_output") {
+    const toolCallId = typeof payload.call_id === "string" ? payload.call_id : undefined;
+    if (!toolCallId) {
+      return undefined;
+    }
+    return { type: "tool_finished", toolCallId };
+  }
+
+  return undefined;
+}
+
+export function parseCodexTranscriptLines(lines, options = {}) {
+  const events = [];
+  for (const line of lines) {
+    if (typeof line !== "string" || line.trim() === "") {
+      continue;
+    }
+    const event = parseCodexTranscriptLine(line, options);
+    if (event) {
+      events.push(event);
+    }
+  }
+  return events;
+}

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

@@ -0,0 +1,120 @@
+// SPIKE tests for the Codex hook adapter prototype.
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  buildCodexHookSettings,
+  mapCodexEventToState,
+  serializeCodexHooksToml
+} from "../src/codex-hooks.js";
+
+test("mapCodexEventToState covers activity events", () => {
+  assert.equal(mapCodexEventToState("UserPromptSubmit"), "thinking");
+  assert.equal(mapCodexEventToState("PostToolUse"), "thinking");
+  assert.equal(mapCodexEventToState("PermissionRequest"), "waiting_approval");
+  assert.equal(mapCodexEventToState("PreCompact"), "compacting");
+  assert.equal(mapCodexEventToState("PostCompact"), "thinking");
+  assert.equal(mapCodexEventToState("SubagentStart"), "running_tool");
+  assert.equal(mapCodexEventToState("SubagentStop"), "thinking");
+  assert.equal(mapCodexEventToState("Stop"), "idle");
+  assert.equal(mapCodexEventToState("Unknown"), undefined);
+});
+
+test("mapCodexEventToState branches PreToolUse on tool name (apply_patch vs command)", () => {
+  assert.equal(mapCodexEventToState("PreToolUse", "apply_patch"), "editing_files");
+  assert.equal(mapCodexEventToState("PreToolUse", "shell_command"), "running_tool");
+  assert.equal(mapCodexEventToState("PreToolUse", "read_file"), "running_tool");
+});
+
+test("Stop is the only idle signal — SubagentStop stays working", () => {
+  // Regression guard for the key Codex-vs-Claude difference: a subagent finishing
+  // mid-turn must NOT flip the pet to idle.
+  assert.notEqual(mapCodexEventToState("SubagentStop"), "idle");
+  assert.equal(mapCodexEventToState("Stop"), "idle");
+});
+
+test("buildCodexHookSettings bakes node + cli, no volatile session id", () => {
+  const settings = buildCodexHookSettings({
+    nodePath: "/usr/bin/node",
+    cliPath: "/app/haya-pet.js"
+  });
+
+  const cmd = settings.hooks.UserPromptSubmit[0].hooks[0].command;
+  assert.equal(settings.hooks.UserPromptSubmit[0].hooks[0].type, "command");
+  // Program (node) must be UNQUOTED and must not lead with a quote — cmd /c on
+  // Windows strips a leading quote and breaks the hook. The cli path is quoted.
+  assert.doesNotMatch(cmd, /^"/);
+  assert.match(cmd, /^\/usr\/bin\/node /);
+  assert.match(cmd, /"\/app\/haya-pet\.js"/);
+  assert.match(cmd, /state thinking$/);
+  assert.doesNotMatch(JSON.stringify(settings), /--session/);
+});
+
+test("buildCodexHookSettings is stable across calls (for hook-trust caching)", () => {
+  const a = buildCodexHookSettings({ nodePath: "n", cliPath: "c" });
+  const b = buildCodexHookSettings({ nodePath: "n", cliPath: "c" });
+  assert.deepEqual(a, b);
+});
+
+test("buildCodexHookSettings splits PreToolUse into edit + command matchers", () => {
+  const pre = buildCodexHookSettings({ nodePath: "n", cliPath: "c" }).hooks.PreToolUse;
+  assert.equal(pre.length, 2);
+  const edit = pre.find((e) => /editing_files/.test(e.hooks[0].command));
+  const other = pre.find((e) => /running_tool/.test(e.hooks[0].command));
+  assert.equal(edit.matcher, "apply_patch");
+  assert.equal(other.matcher, "shell_command");
+});
+
+test("no matcher uses look-around (Codex's Rust regex crate rejects it)", () => {
+  // Regression guard: a `(?!…)` / `(?=…)` matcher is a hard parse error in Codex
+  // and disables that hook. Keep all matchers look-around-free.
+  const settings = buildCodexHookSettings({ nodePath: "n", cliPath: "c" });
+  for (const entries of Object.values(settings.hooks)) {
+    for (const entry of entries) {
+      if (entry.matcher !== undefined) {
+        assert.doesNotMatch(entry.matcher, /\(\?[=!<]/, `look-around in matcher "${entry.matcher}"`);
+      }
+    }
+  }
+});
+
+test("serializeCodexHooksToml emits [[hooks.X]] tables with unquoted program", () => {
+  const settings = buildCodexHookSettings({
+    nodePath: "C:\\nodedir\\node.exe",
+    cliPath: "C:\\app\\haya-pet.js"
+  });
+  const toml = serializeCodexHooksToml(settings, { header: "test header" });
+
+  assert.match(toml, /^# test header\n/);
+  assert.match(toml, /\[\[hooks\.UserPromptSubmit\]\]/);
+  assert.match(toml, /\[\[hooks\.UserPromptSubmit\.hooks\]\]/);
+  assert.match(toml, /type = "command"/);
+  // matcher present for PreToolUse
+  assert.match(toml, /matcher = "apply_patch"/);
+  // The command value (a TOML basic string) must NOT start with an escaped quote
+  // right after the opening quote — i.e. the program is unquoted: command = "C:\\...
+  const cmdLine = toml.split("\n").find((l) => l.startsWith("command ="));
+  assert.doesNotMatch(cmdLine, /^command = "\\"/);
+  // Backslashes are TOML-escaped (doubled).
+  assert.match(toml, /C:\\\\nodedir\\\\node\.exe/);
+});
+
+test("serializeCodexHooksToml round-trips backslashes/quotes safely", () => {
+  const settings = { hooks: { Stop: [{ hooks: [{ type: "command", command: 'a\\b "c"' }] }] } };
+  const toml = serializeCodexHooksToml(settings);
+  // a\b "c"  ->  "a\\b \"c\""
+  assert.match(toml, /command = "a\\\\b \\"c\\""/);
+});
+
+test("buildCodexHookSettings includes Codex's event set (and omits Claude-only events)", () => {
+  const settings = buildCodexHookSettings({ nodePath: "n", cliPath: "c" });
+  for (const event of [
+    "UserPromptSubmit", "PreToolUse", "PostToolUse", "PermissionRequest",
+    "PreCompact", "PostCompact", "SubagentStart", "SubagentStop", "Stop"
+  ]) {
+    assert.ok(settings.hooks[event], `missing hook event ${event}`);
+  }
+  // Claude-only events Codex does not emit must not be registered.
+  for (const event of ["Notification", "PermissionDenied", "PostToolUseFailure", "StopFailure"]) {
+    assert.equal(settings.hooks[event], undefined, `unexpected Claude-only event ${event}`);
+  }
+});

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/src/run-command.js

@@ -256,7 +256,6 @@ async function runObservedCommand({
   registered = true;
   if (pendingState) {
     emitState(pendingState);
-    pendingState = undefined;
   }
 
   await sendProtocolMessage(send, { type: "heartbeat", sessionId, updatedAt: now() });

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