mirror-mind 0.33.4 → 0.34.0

package/scripts/codex-hooks/session-start.sh

@@ -1,85 +0,0 @@
-#!/usr/bin/env bash
-# Mirror Mind hook wrapper — GENERATED by scripts/generate_hook_wrappers.sh.
-# Edit the generator, never this file: every wrapper shares these bytes and
-# differs only in the hook name and in how it finds the Mirror entry
-# (CV22.DS10.TS5 decision D4; CV22.DS10.US3 decision D5).
-set -uo pipefail
-HOOK="codex:session-start"
-
-# Resolve the tree from THIS FILE, never from the cwd: a runtime spawns hooks
-# from whatever directory the session is in. The tree is a checkout or the
-# installed package; the wrapper's depth to its root is the same in both.
-HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
-REPO_ROOT="$(cd "$HERE/../.." && pwd -P)"
-
-# A hook never fails the user's turn, and never fails in silence: when it
-# cannot do its job it appends ONE line to <mirror home>/hooks.log and exits 0.
-# The home is found the way the core finds it -- MIRROR_HOME, else
-# MIRROR_USER -- from the environment when set there, else from the tree's
-# .env when the wrapper is in a tree, else from the user's config file
-# (~/.config/mirror/env), in the core's order (US3, D3). A GUI launch carries
-# neither variable, and the first wrappers then wrote to a home nobody reads.
-env_file_value() {
-  [ -f "$2" ] || return 0
-  sed -n -E "s/^[[:space:]]*(export[[:space:]]+)?$1[[:space:]]*=[[:space:]]*//p" "$2" \
-    | tail -n 1 | tr -d "\"'\r"
-}
-env_value() {
-  local value=""
-  if [ -n "${!1+set}" ]; then printf '%s' "${!1}"; return; fi
-  [ -z "$REPO_ROOT" ] || value="$(env_file_value "$1" "$REPO_ROOT/.env")"
-  [ -n "$value" ] || value="$(env_file_value "$1" "${XDG_CONFIG_HOME:-$HOME/.config}/mirror/env")"
-  printf '%s' "$value"
-}
-note() {
-  local home user
-  home="$(env_value MIRROR_HOME)"
-  user="$(env_value MIRROR_USER)"
-  if [ -n "$home" ]; then
-    home="${home/#\~/$HOME}"
-  elif [ -n "$user" ]; then
-    home="$HOME/.mirror-minds/$user"
-    [ -d "$home" ] || [ ! -d "$HOME/.mirror/$user" ] || home="$HOME/.mirror/$user"
-  else
-    return 0
-  fi
-  mkdir -p "$home" 2>/dev/null \
-    && printf '%s %s: %s\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$HOOK" "$1" >> "$home/hooks.log" 2>/dev/null
-}
-
-ENTRY="$REPO_ROOT/bin/mirror-hook.js"
-
-# Find Node. /usr/bin/python3 exists on every macOS; node usually lives under
-# nvm or Homebrew and is NOT on the PATH of a GUI-launched runtime. The Python
-# hooks could end in `|| true` because they always found their interpreter;
-# the same silence here would hide a new failure — no logging, no inject, no
-# close tail — that a user would meet weeks later as "Mirror stopped
-# remembering". So an unresolvable Node is RECORDED, never swallowed. The
-# directory the entry was found in is searched first: an npm global bin holds
-# the `node` that installed the package beside `mirror-hook`, while a system
-# `/usr/local/bin/node` can be years older (CI's Ubuntu runner has one).
-NODE="${MIRROR_NODE:-}"
-if [ -z "$NODE" ] || [ ! -x "$NODE" ]; then
-  NODE="$(command -v node 2>/dev/null || true)"
-fi
-for candidate in "$(dirname "$ENTRY")/node" "$HOME/.nvm/current/bin/node" /opt/homebrew/bin/node /usr/local/bin/node; do
-  [ -n "$NODE" ] && break
-  [ -x "$candidate" ] && NODE="$candidate"
-done
-
-if [ -z "$NODE" ]; then
-  note "node not found on PATH; hook skipped. Set MIRROR_NODE."
-  exit 0
-fi
-
-# Not `exec`: the entry exits 0 whatever happens inside it, so a non-zero exit
-# means Node itself could not run the hook -- too old for the loader shim, or
-# it crashed. That used to vanish into a stderr no runtime shows (TS5 handoff
-# review, finding N1). No flags: the entry reads configuration and silences
-# its own warnings (US3, D3).
-"$NODE" "$ENTRY" "$HOOK" "$@"
-status=$?
-if [ "$status" -ne 0 ]; then
-  note "node exited $status before the hook finished ($NODE, $("$NODE" --version 2>/dev/null || echo 'version unknown')); Mirror needs Node 24 or later. Set MIRROR_NODE."
-fi
-exit 0

package/scripts/codex-mirror.sh

@@ -1,48 +0,0 @@
-#!/usr/bin/env bash
-# Run Codex with Mirror Mind logging around it.
-#
-# Codex has no hook system, so this wraps the `codex` command: session start
-# before it, and after it the JSONL Codex wrote is imported, the session is
-# closed, and a silent backup is taken.
-#
-# Every Mirror call goes through a generated hook wrapper under
-# scripts/codex-hooks/, the way every other runtime's hooks do (CV22.DS10.TS5
-# handoff review, finding N3). The wrappers resolve Node explicitly, never fail
-# the session, and record anything they could not do in <mirror home>/hooks.log.
-# This script used to call the front door itself, as a command held in a string
-# that a checkout path with a space split in two -- silently.
-set -euo pipefail
-
-HOOKS="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)/codex-hooks"
-
-# The marker's mtime is how the session this run wrote is told from older ones.
-MARKER="$(mktemp)"
-trap 'rm -f "$MARKER"' EXIT
-
-cd "${CODEX_PROJECT_DIR:-$PWD}"
-
-# 1. Session start.
-bash "$HOOKS/session-start.sh" </dev/null >/dev/null 2>&1 || true
-
-# 2. Codex itself, until the user exits. `set -e` is off around it so the
-# wrap-up below still runs when Codex exits non-zero -- after an MCP startup
-# failure, for example -- and its exit code is still the script's.
-set +e
-codex "$@"
-EXIT_CODE=$?
-set -e
-
-# 3. The JSONL Codex wrote after the marker for this directory, if any:
-# ~/.codex/sessions/YYYY/MM/DD/rollout-<time>-<uuid>.jsonl.
-SESSION_JSONL="$(find ~/.codex/sessions -name "*.jsonl" -newer "$MARKER" \
-  -exec grep -l "\"cwd\":\"$PWD\"" {} + 2>/dev/null | sort | tail -1 || true)"
-SESSION_ID=""
-if [[ -n "$SESSION_JSONL" ]]; then
-  SESSION_ID="$(basename "$SESSION_JSONL" .jsonl \
-    | grep -oE '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}' | tail -1 || true)"
-fi
-
-# 4. Import and close the session when there is one, then the silent backup.
-bash "$HOOKS/session-end.sh" "$SESSION_JSONL" "$SESSION_ID" </dev/null >/dev/null 2>&1 || true
-
-exit "$EXIT_CODE"

package/ts/src/hooks/codex.ts

@@ -1,45 +0,0 @@
-// Codex hook entries (CV22.DS10.TS5 handoff review, finding N3).
-//
-// Codex has no hook system, so `scripts/codex-mirror.sh` wraps the `codex`
-// command itself and calls these through two generated wrappers under
-// `scripts/codex-hooks/`. Until the handoff review the script called the front
-// door directly: it found `node` on PATH alone, silenced every failure, and
-// built its command as a string that a checkout path with a space split in
-// two. Going through the wrappers gives it the same Node resolution and the
-// same hooks.log record as every other runtime.
-//
-// The payload comes as arguments, not stdin: the wrapper, not a runtime,
-// decides what to pass, and a path is safer as one quoted argument than
-// embedded in hand-written JSON.
-
-import { runFrontDoorQuietly } from "./runtime.ts";
-
-/** Wrapper start: make sure logging is on for this session. */
-export async function codexSessionStart(): Promise<number> {
-  await runFrontDoorQuietly("codex:session-start", ["conversation-logger", "session-start"]);
-  return 0;
-}
-
-/**
- * Wrapper exit: import the session Codex wrote, close it, then take the silent
- * backup. The transcript and its session id are both absent when Codex wrote
- * no session for this directory; the backup runs either way, as it always has.
- */
-export async function codexSessionEnd(transcriptPath: string, sessionId: string): Promise<number> {
-  if (transcriptPath && sessionId) {
-    await runFrontDoorQuietly("codex:session-end", [
-      "conversation-logger",
-      "backfill-codex-session",
-      transcriptPath,
-      "--interface",
-      "codex",
-    ]);
-    await runFrontDoorQuietly("codex:session-end", [
-      "conversation-logger",
-      "session-end-pi",
-      sessionId,
-    ]);
-  }
-  await runFrontDoorQuietly("codex:session-end", ["backup", "--silent"]);
-  return 0;
-}