@quantiya/codevibe-codex-plugin 2.0.11 → 2.0.14

package/hooks/common.sh

@@ -117,9 +117,9 @@ is_codevibe_codex_daemon() {
   esac
 }
 
-# (#638 G5/H2/H3) THE identity-guarded reap: TERM → bounded wait → identity
+# (#638 G5/H2/H3) THE identity-guarded reap: graceful signal → bounded wait → identity
 # re-check → KILL → settle. Identity (is_codevibe_codex_daemon) is re-verified
-# immediately before EVERY signal — the PID can die after the SIGTERM and be
+# immediately before EVERY signal — the PID can die after the graceful signal and be
 # recycled to an unrelated process during the settle poll, so signaling blind
 # could kill a foreign process. Works for BOTH our own background child (`wait`
 # collects its status instantly, closing the PID-reuse window) and a non-child
@@ -127,13 +127,15 @@ is_codevibe_codex_daemon() {
 # provides the settle). Returns 0 when the daemon is provably gone, 1 when the
 # PID was not (or stopped being) our daemon and was left alone.
 _reap_codevibe_codex_daemon_pid() {
-  local pid="$1" why="$2"
+  local pid="$1" why="$2" graceful_signal="${3:-TERM}"
   [ -n "$pid" ] || return 1
   if ! is_codevibe_codex_daemon "$pid"; then
     log "WARN" "reap($why): pid $pid is not our daemon (recycled/replaced) — not signaling"
     return 1
   fi
-  kill "$pid" 2>/dev/null            # SIGTERM: let it run its graceful shutdown
+  # TERM is a real terminal/session shutdown. USR2 is a daemon handoff: the
+  # replacement must reclaim the still-ACTIVE hosted row and its history.
+  kill -s "$graceful_signal" "$pid" 2>/dev/null
   local reap=0
   while [ $reap -lt 10 ] && ps -p "$pid" > /dev/null 2>&1; do
     sleep 0.2
@@ -439,7 +441,7 @@ ensure_codex_daemon() {
         ;;
       *)
         log "WARN" "ensure_codex_daemon: reaping wedged daemon pid $wedged_pid on excluded port $exclude_port (via $wedged_src) before relaunch (#638 H2)"
-        _reap_codevibe_codex_daemon_pid "$wedged_pid" "wedged /event on port $exclude_port"
+        _reap_codevibe_codex_daemon_pid "$wedged_pid" "wedged /event on port $exclude_port" USR2
         ;;
     esac
   fi
@@ -528,10 +530,13 @@ send_to_server() {
     # (accepts TCP, never responds) must not hang the hook indefinitely — hooks
     # block the agent UI. --connect-timeout 2 bounds connection establishment;
     # --max-time 10 bounds the whole POST (generous for a slow-network POST).
-    response=$(curl -s --connect-timeout 2 --max-time 10 -w "\n%{http_code}" \
+    # Stream the payload over stdin. Passing a screenshot-bearing PostToolUse
+    # body through `-d "$json_data"` puts it in argv and can fail locally with
+    # E2BIG before curl reaches the healthy daemon.
+    response=$(printf '%s' "$json_data" | curl -s --connect-timeout 2 --max-time 10 -w "\n%{http_code}" \
       -X POST \
       -H "Content-Type: application/json" \
-      -d "$json_data" \
+      --data-binary @- \
       "$server_url/$endpoint" 2>&1)
     curl_exit=$?
     http_code=$(echo "$response" | tail -n 1)
@@ -551,6 +556,13 @@ send_to_server() {
     log "WARN" "No server URL (port file missing) — will attempt daemon relaunch"
   fi
 
+  # A local exec failure means curl never contacted the daemon. Replacing a
+  # health-passing process in response would retire or disrupt a valid session.
+  if [ "$curl_exit" -eq 126 ] || [ "$curl_exit" -eq 127 ]; then
+    log "ERROR" "Local curl invocation failed (exit $curl_exit) — not replacing the Codex daemon"
+    return 1
+  fi
+
   # (#638) TRANSPORT failure = curl non-zero OR HTTP 000 (dead daemon / missing
   # port file). Relaunch the daemon ONCE and retry the POST once (one relaunch
   # max, no loops). NOT for app 4xx/5xx — the daemon is alive and rejected the
@@ -574,10 +586,10 @@ send_to_server() {
     local new_port retry
     if new_port=$(ensure_codex_daemon "$failed_port" "$failed_pid"); then
       log "INFO" "Relaunched Codex daemon on port $new_port, retrying POST /$endpoint"
-      retry=$(curl -s --connect-timeout 2 --max-time 10 -w "\n%{http_code}" \
+      retry=$(printf '%s' "$json_data" | curl -s --connect-timeout 2 --max-time 10 -w "\n%{http_code}" \
         -X POST \
         -H "Content-Type: application/json" \
-        -d "$json_data" \
+        --data-binary @- \
         "http://localhost:${new_port}/$endpoint" 2>&1)
       curl_exit=$?
       http_code=$(echo "$retry" | tail -n 1)

package/libexec/codex-hook-config.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const fs = require('fs');
+
+const OUR_HOOK_FILES = new Set([
+  'session-start.sh',
+  'user-prompt.sh',
+  'pre-tool-use.sh',
+  'permission-request.sh',
+  'post-tool-use.sh',
+  'stop.sh',
+]);
+
+function hookScriptPath(command) {
+  if (typeof command !== 'string') return null;
+  const match = command.trim().match(/^bash\s+(?:"([^"]+)"|'([^']+)'|(\S+))$/);
+  return match ? (match[1] || match[2] || match[3]) : null;
+}
+
+function isOurCommand(command) {
+  const scriptPath = hookScriptPath(command);
+  if (!scriptPath) return false;
+
+  const filename = scriptPath.slice(scriptPath.lastIndexOf('/') + 1);
+  if (!OUR_HOOK_FILES.has(filename) || !scriptPath.endsWith(`/hooks/${filename}`)) {
+    return false;
+  }
+
+  if (scriptPath.includes('/codevibe-codex-plugin/hooks/')) {
+    return true;
+  }
+
+  // Development links can use task-specific repository names rather than the
+  // canonical package directory. Keep this deliberately limited to CodeVibe's
+  // agent-worktree layout so an unrelated hook with the same filename survives.
+  return /\/\.agent-worktrees\/[^/]+\/codevibe-codex-[^/]+\/hooks\/[^/]+$/.test(scriptPath);
+}
+
+function stripOurHooksFromEntry(entry) {
+  if (!entry || typeof entry !== 'object' || !Array.isArray(entry.hooks)) {
+    return entry;
+  }
+  const filtered = entry.hooks.filter((hook) => !(hook && isOurCommand(hook.command)));
+  if (filtered.length === entry.hooks.length) return entry;
+  if (filtered.length === 0) return null;
+  return { ...entry, hooks: filtered };
+}
+
+function ownedCommands(entries) {
+  return entries
+    .flatMap((entry) => entry && typeof entry === 'object' && Array.isArray(entry.hooks)
+      ? entry.hooks
+      : [])
+    .map((hook) => hook && hook.command)
+    .filter(isOurCommand)
+    .sort();
+}
+
+function mergeHookConfig(existingObj, nextObj, existed = true) {
+  const existingHooks = existingObj && typeof existingObj === 'object'
+    && existingObj.hooks && typeof existingObj.hooks === 'object'
+    ? existingObj.hooks
+    : {};
+  const nextHooks = nextObj && typeof nextObj === 'object'
+    && nextObj.hooks && typeof nextObj.hooks === 'object'
+    ? nextObj.hooks
+    : {};
+
+  let allPresent = existed;
+  for (const key of Object.keys(nextHooks)) {
+    const existingEntries = Array.isArray(existingHooks[key]) ? existingHooks[key] : [];
+    const nextEntries = Array.isArray(nextHooks[key]) ? nextHooks[key] : [];
+    if (JSON.stringify(ownedCommands(existingEntries)) !== JSON.stringify(ownedCommands(nextEntries))) {
+      allPresent = false;
+      break;
+    }
+  }
+  if (allPresent) {
+    return { outcome: 'already_installed', config: existingObj };
+  }
+
+  const mergedHooks = { ...existingHooks };
+  for (const key of Object.keys(nextHooks)) {
+    const existingEntries = Array.isArray(existingHooks[key]) ? existingHooks[key] : [];
+    const cleanedExisting = existingEntries
+      .map(stripOurHooksFromEntry)
+      .filter((entry) => entry !== null && entry !== undefined);
+    const nextEntries = Array.isArray(nextHooks[key]) ? nextHooks[key] : [];
+    mergedHooks[key] = [...cleanedExisting, ...nextEntries];
+  }
+
+  return {
+    outcome: existed ? 'merged' : 'fresh_install',
+    config: existingObj && typeof existingObj === 'object'
+      ? { ...existingObj, hooks: mergedHooks }
+      : { hooks: mergedHooks },
+  };
+}
+
+function cleanHookConfig(existingObj) {
+  if (!existingObj || typeof existingObj !== 'object'
+    || !existingObj.hooks || typeof existingObj.hooks !== 'object') {
+    return existingObj;
+  }
+
+  const hooks = { ...existingObj.hooks };
+  for (const key of Object.keys(hooks)) {
+    if (!Array.isArray(hooks[key])) continue;
+    hooks[key] = hooks[key]
+      .map(stripOurHooksFromEntry)
+      .filter((entry) => entry !== null && entry !== undefined);
+  }
+  return { ...existingObj, hooks };
+}
+
+function writeAtomic(target, value) {
+  const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(value, null, 2));
+    fs.renameSync(temporary, target);
+  } catch (error) {
+    try { fs.unlinkSync(temporary); } catch {}
+    throw error;
+  }
+}
+
+function runMerge() {
+  const target = process.env.CV_EXISTING;
+  let existingObj = null;
+  let existed = false;
+  try {
+    if (fs.existsSync(target)) {
+      existed = true;
+      existingObj = JSON.parse(fs.readFileSync(target, 'utf8'));
+    }
+  } catch (error) {
+    process.stderr.write(`PARSE_EXISTING_FAILED:${error.message || String(error)}`);
+    return 2;
+  }
+
+  let nextObj;
+  try {
+    nextObj = JSON.parse(process.env.CV_NEW);
+  } catch (error) {
+    process.stderr.write(`PARSE_NEW_FAILED:${error.message || String(error)}`);
+    return 3;
+  }
+
+  const result = mergeHookConfig(existingObj, nextObj, existed);
+  if (result.outcome !== 'already_installed') {
+    try {
+      writeAtomic(target, result.config);
+    } catch (error) {
+      process.stderr.write(`WRITE_FAILED:${error.message || String(error)}`);
+      return 4;
+    }
+  }
+  process.stdout.write(`OUTCOME:${result.outcome}\n`);
+  return 0;
+}
+
+function runCleanup() {
+  const target = process.env.CV_HOOKS_FILE;
+  try {
+    const existingObj = JSON.parse(fs.readFileSync(target, 'utf8'));
+    writeAtomic(target, cleanHookConfig(existingObj));
+    return 0;
+  } catch (error) {
+    process.stderr.write(`CLEAN_FAILED:${error.message || String(error)}`);
+    return 1;
+  }
+}
+
+if (require.main === module) {
+  const action = process.argv[2];
+  const exitCode = action === 'merge'
+    ? runMerge()
+    : action === 'cleanup'
+      ? runCleanup()
+      : 64;
+  process.exit(exitCode);
+}
+
+module.exports = {
+  cleanHookConfig,
+  isOurCommand,
+  mergeHookConfig,
+};

package/libexec/companion-launcher

@@ -259,55 +259,10 @@ cleanup() {
         # Only remove if no other codevibe-codex sessions are running
         if [ "$(pgrep -f 'codevibe-codex' | wc -l)" -le 1 ]; then
             log "Removing CodeVibe hooks from $HOME/.codex/hooks.json"
-            # Cleanup mirrors install: same ownership predicate + the
-            # same INNER-hooks[] split so a matcher entry mixing user
-            # hooks with ours keeps the user hook. Same per-process
-            # tmp suffix avoids two concurrent cleanups racing.
-            if CV_HOOKS_FILE="$HOME/.codex/hooks.json" node -e '
-              const fs = require("fs");
-              const OUR_HOOK_FILES = new Set([
-                "session-start.sh",
-                "user-prompt.sh",
-                "pre-tool-use.sh",
-                "post-tool-use.sh",
-                "stop.sh",
-              ]);
-              const OWN_PATH_MARKER = "codevibe-codex-plugin/hooks/";
-              const isOurCommand = (command) => {
-                if (typeof command !== "string") return false;
-                if (command.indexOf(OWN_PATH_MARKER) === -1) return false;
-                for (const f of OUR_HOOK_FILES) {
-                  if (command.endsWith("/" + f)) return true;
-                }
-                return false;
-              };
-              const stripOurHooksFromEntry = (entry) => {
-                if (!entry || typeof entry !== "object" || !Array.isArray(entry.hooks)) return entry;
-                const filtered = entry.hooks.filter((h) => !(h && isOurCommand(h.command)));
-                if (filtered.length === entry.hooks.length) return entry;
-                if (filtered.length === 0) return null;
-                return { ...entry, hooks: filtered };
-              };
-              try {
-                const target = process.env.CV_HOOKS_FILE;
-                const data = JSON.parse(fs.readFileSync(target, "utf8"));
-                if (data && typeof data === "object" && data.hooks && typeof data.hooks === "object") {
-                  for (const k of Object.keys(data.hooks)) {
-                    if (Array.isArray(data.hooks[k])) {
-                      data.hooks[k] = data.hooks[k]
-                        .map(stripOurHooksFromEntry)
-                        .filter((entry) => entry !== null && entry !== undefined);
-                    }
-                  }
-                }
-                const tmp = target + "." + process.pid + "." + Date.now() + ".tmp";
-                fs.writeFileSync(tmp, JSON.stringify(data, null, 2));
-                fs.renameSync(tmp, target);
-              } catch (e) {
-                process.stderr.write("CLEAN_FAILED:" + (e && e.message ? e.message : String(e)));
-                process.exit(1);
-              }
-            ' 2>>"$LOG_FILE"; then
+            # The shared helper keeps install and cleanup ownership rules in
+            # lockstep, including task-named CodeVibe agent worktrees.
+            if CV_HOOKS_FILE="$HOME/.codex/hooks.json" \
+              node "$PLUGIN_DIR/libexec/codex-hook-config.js" cleanup 2>>"$LOG_FILE"; then
               :
             else
               log "WARN: failed to clean CodeVibe hooks from hooks.json (left as-is)"
@@ -539,9 +494,9 @@ _CV_HOOKS_REASON=""
 #    keeps the user hook (only the CodeVibe hooks get stripped, not
 #    the surrounding entry).
 #
-#  - Ownership predicate: path-prefix `codevibe-codex-plugin/hooks/`
-#    AND filename tail in the allow-list of our hook script names.
-#    Rejects user paths like /Users/codevibe-codex/foo.sh.
+#  - Ownership predicate: canonical package paths or CodeVibe's strict
+#    `.agent-worktrees/<agent>/codevibe-codex-*/hooks/` layout, plus a
+#    filename allowlist. Rejects unrelated user hook paths.
 #
 #  - Per-process tmp file (.<pid>.<time>.tmp): two concurrent installs
 #    won't clobber each other's intermediate state. Final rename is
@@ -555,112 +510,8 @@ _CV_HOOKS_REASON=""
 GENERATED_HOOKS=$(generate_hooks_json)
 if INSTALLER_OUTPUT=$(CV_EXISTING="$CODEX_HOOKS_FILE" \
                      CV_NEW="$GENERATED_HOOKS" \
-                     node -e '
-  const fs = require("fs");
-  const OUR_HOOK_FILES = new Set([
-    "session-start.sh",
-    "user-prompt.sh",
-    "pre-tool-use.sh",
-    "permission-request.sh",
-    "post-tool-use.sh",
-    "stop.sh",
-  ]);
-  const OWN_PATH_MARKER = "codevibe-codex-plugin/hooks/";
-  const isOurCommand = (command) => {
-    if (typeof command !== "string") return false;
-    if (command.indexOf(OWN_PATH_MARKER) === -1) return false;
-    for (const f of OUR_HOOK_FILES) {
-      if (command.endsWith("/" + f)) return true;
-    }
-    return false;
-  };
-  // Strip our hooks from a single matcher entrys inner hooks[] array.
-  // Returns null if NO non-owned hooks remain (whole entry should be
-  // dropped); otherwise returns a new entry with only the user-owned
-  // hooks. Returns the original entry unchanged if it contains none of
-  // ours (preserves identity for unrelated entries).
-  const stripOurHooksFromEntry = (entry) => {
-    if (!entry || typeof entry !== "object" || !Array.isArray(entry.hooks)) {
-      return entry;
-    }
-    const filtered = entry.hooks.filter((h) => !(h && isOurCommand(h.command)));
-    if (filtered.length === entry.hooks.length) return entry;
-    if (filtered.length === 0) return null;
-    return { ...entry, hooks: filtered };
-  };
-  const ownedCommands = (entries) => entries
-    .flatMap((entry) => entry && typeof entry === "object" && Array.isArray(entry.hooks)
-      ? entry.hooks
-      : [])
-    .map((hook) => hook && hook.command)
-    .filter(isOurCommand)
-    .sort();
-
-  let existingObj = null;
-  let existed = false;
-  try {
-    if (fs.existsSync(process.env.CV_EXISTING)) {
-      existed = true;
-      existingObj = JSON.parse(fs.readFileSync(process.env.CV_EXISTING, "utf8"));
-    }
-  } catch (e) {
-    process.stderr.write("PARSE_EXISTING_FAILED:" + (e && e.message ? e.message : String(e)));
-    process.exit(2);
-  }
-  let nextObj;
-  try {
-    nextObj = JSON.parse(process.env.CV_NEW);
-  } catch (e) {
-    process.stderr.write("PARSE_NEW_FAILED:" + (e && e.message ? e.message : String(e)));
-    process.exit(3);
-  }
-
-  const existingHooks = (existingObj && typeof existingObj === "object" &&
-    existingObj.hooks && typeof existingObj.hooks === "object") ? existingObj.hooks : {};
-  const nextHooks = (nextObj && typeof nextObj === "object" &&
-    nextObj.hooks && typeof nextObj.hooks === "object") ? nextObj.hooks : {};
-  let allPresent = existed;
-  for (const k of Object.keys(nextHooks)) {
-    const existingArr = Array.isArray(existingHooks[k]) ? existingHooks[k] : [];
-    const nextArr = Array.isArray(nextHooks[k]) ? nextHooks[k] : [];
-    if (JSON.stringify(ownedCommands(existingArr)) !== JSON.stringify(ownedCommands(nextArr))) {
-      allPresent = false;
-      break;
-    }
-  }
-  if (allPresent) {
-    process.stdout.write("OUTCOME:already_installed\n");
-    process.exit(0);
-  }
-
-  const mergedHooks = { ...existingHooks };
-  for (const k of Object.keys(nextHooks)) {
-    const existingArr = Array.isArray(existingHooks[k]) ? existingHooks[k] : [];
-    const cleanedExisting = existingArr
-      .map(stripOurHooksFromEntry)
-      .filter((entry) => entry !== null && entry !== undefined);
-    const nextArr = Array.isArray(nextHooks[k]) ? nextHooks[k] : [];
-    mergedHooks[k] = [...cleanedExisting, ...nextArr];
-  }
-
-  const out = (existingObj && typeof existingObj === "object")
-    ? { ...existingObj, hooks: mergedHooks }
-    : { hooks: mergedHooks };
-  const outcome = existed ? "merged" : "fresh_install";
-  const target = process.env.CV_EXISTING;
-  // Per-process tmp suffix avoids two concurrent installs both writing
-  // ${target}.tmp and one mvs the others half-written file.
-  const tmp = target + "." + process.pid + "." + Date.now() + ".tmp";
-  try {
-    fs.writeFileSync(tmp, JSON.stringify(out, null, 2));
-    fs.renameSync(tmp, target);
-  } catch (e) {
-    try { fs.unlinkSync(tmp); } catch {}
-    process.stderr.write("WRITE_FAILED:" + (e && e.message ? e.message : String(e)));
-    process.exit(4);
-  }
-  process.stdout.write("OUTCOME:" + outcome + "\n");
-' 2>>"$LOG_FILE"); then
+                     node "$PLUGIN_DIR/libexec/codex-hook-config.js" merge \
+                     2>>"$LOG_FILE"); then
   INSTALLER_RC=0
 else
   INSTALLER_RC=$?

package/node_modules/@quantiya/codevibe-core/dist/__tests__/gate-ux-regressions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@quantiya/codevibe-core/dist/index.d.ts

@@ -43,7 +43,7 @@ export { ToolActivityOutbox, type ToolActivityOutboxOptions, type ListPendingRes
 export { ToolActivityLedger, LedgerEntrySchema, LedgerFileSchema, LegacyOwnedFileSchema, type LedgerEntry, type LedgerFile, type LegacyOwnedFile, type OccurrenceRef, type ToolActivityLedgerOptions, } from './tool-activity';
 export { ToolReplayCursor, ReplayFrameTooLargeError, ReplayCursorStateSchema, DEFAULT_REPLAY_READ_BYTES, DEFAULT_REPLAY_MAX_FRAME_BYTES, type ReplayCursorState, type ReplayFrame, type ReadFramesResult, type ToolReplayCursorOptions, } from './tool-activity';
 export { ToolActivitySessionMap, InProcessRolloutLock, SessionMapRecordSchema, type RolloutLock, type RolloutOwnership, type SessionMapRecord, type ToolActivitySessionMapOptions, } from './tool-activity';
-export { ToolActivityConsolidator, isSessionKeyStaleError, type ObservedOccurrence, type ObserveDisposition, type ToolActivityTransport, type ToolActivityConsolidatorOptions, } from './tool-activity';
+export { ToolActivityConsolidator, isSessionKeyStaleError, isTerminalSessionError, type ObservedOccurrence, type ObserveDisposition, type ToolActivityTransport, type ToolActivityConsolidatorOptions, } from './tool-activity';
 export { SocketRolloutLock, type SocketRolloutLockOptions, FlockRolloutLock, type FlockRolloutLockOptions, type FlockSyncFn, type FlockFlag, createRolloutLock, type CreateRolloutLockOptions, } from './tool-activity';
 export { ToolActivityOccurrenceSchema, ToolActivityDetailSchema, ToolActivityGroupSchema, ToolActivityManifestSchema, ToolActivityOutboxEnvelopeSchema, type ToolActivityOccurrence, type ToolActivityDetail, type ToolActivityGroup, type ToolActivityManifest, type ToolActivityOutboxEnvelope, } from './tool-activity';
 export { digestOf, stableStringify } from './tool-activity';