@quantiya/codevibe-gemini-plugin 1.0.22 → 1.0.24

package/bin/codevibe-gemini

@@ -172,10 +172,49 @@ _CV_INSIDE_TMUX="false"; [ -n "$TMUX" ] && _CV_INSIDE_TMUX="true"
 _CV_IS_TTY="false"; { [ -t 0 ] && [ -t 1 ]; } && _CV_IS_TTY="true"
 cv_telem "wrapper_started" "\"invocation\":\"session\",\"os\":\"$_CV_OS_VER\",\"arch\":\"$_CV_ARCH_VER\",\"gemini_version\":\"$_CV_GEMINI_VER\",\"node_version\":\"$_CV_NODE_VER\",\"tmux_version\":\"$_CV_TMUX_VER\",\"gemini_auth_present\":$_CV_GEMINI_AUTH,\"gemini_settings_present\":$_CV_GEMINI_SETTINGS,\"inside_tmux\":$_CV_INSIDE_TMUX,\"is_terminal\":$_CV_IS_TTY"
 
+# Configuration — hoisted ABOVE configure_hooks_if_needed because the
+# function logs to $LOG_FILE on failure paths. With LOG_FILE undefined,
+# `2>>"$LOG_FILE"` becomes `2>>""` and the redirection silently fails
+# (or, on stricter shells, breaks the function entirely). Codified
+# 2026-04-30 after R1 caught the ordering bug.
+TMUX_SESSION_PREFIX="codevibe-gemini"
+LOG_FILE="${CODEVIBE_TMPDIR}/codevibe-gemini-wrapper.log"
+MCP_LOG_FILE="${CODEVIBE_TMPDIR}/codevibe-gemini-mcp.log"
+
+log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" >> "$LOG_FILE"
+}
+
+# jq is required at HOOK RUNTIME (not just install time) by every Gemini
+# hook script — see hooks/*.sh: jq parses the stdin JSON Gemini CLI feeds
+# into each hook. The wrapper's own hook merger (below) was ported off jq
+# but the bundled hook scripts still require it. Without jq, hooks fire
+# but produce empty payloads, which lands as a 0-event ghost session in
+# DDB — same silent-failure pattern as the codex jq-merge bug. Until the
+# hooks are ported to a no-jq parser (see follow-up task), fail closed
+# with a clear reason so users get an actionable error instead of a
+# session that quietly never syncs.
+#
+# Codex hooks are unaffected — they don't use jq at runtime.
+if ! command -v jq &> /dev/null; then
+    echo "Error: jq is required by CodeVibe Gemini hooks but is not installed."
+    echo "Install with: brew install jq  (macOS) or  apt-get install jq  (Debian/Ubuntu) or  dnf install jq  (Fedora)"
+    cv_failed "jq_missing_for_hooks"
+    sleep 1
+    exit 1
+fi
+
 # Export hooks directory for hook scripts to use
 export CODEVIBE_HOOKS_DIR="$PLUGIN_DIR/hooks"
 
-# Auto-configure hooks on startup if not already configured
+# Auto-configure hooks on startup if not already configured.
+# Sets _CV_HOOKS_OUTCOME / _CV_HOOKS_REASON for the hooks_install_outcome
+# telemetry beacon fired in the caller. Gemini events flow ONLY through
+# hooks (no transcript fallback for tool/approval events), so a silent
+# skip here = a 0-event ghost session in DDB. Codified after the susyustc
+# 2026-04 silent-failure pattern was traced to the codex twin of this bug.
+_CV_HOOKS_OUTCOME="unknown"
+_CV_HOOKS_REASON=""
 configure_hooks_if_needed() {
     GEMINI_SETTINGS_DIR="$HOME/.gemini"
     GEMINI_SETTINGS_FILE="$GEMINI_SETTINGS_DIR/settings.json"
@@ -193,51 +232,194 @@ configure_hooks_if_needed() {
     if [ ! -f "$TEMPLATE_FILE" ]; then
         echo "⚠ Hooks template not found at: $TEMPLATE_FILE"
         echo "  Try: npm install -g @quantiya/codevibe@latest"
+        _CV_HOOKS_OUTCOME="template_missing"
+        _CV_HOOKS_REASON="bundled_template_not_found"
         return
     fi
 
-    if [ ! -f "$GEMINI_SETTINGS_FILE" ]; then
-        # No settings file — create from template
-        echo "Configuring Gemini CLI hooks for CodeVibe..."
-        sed "s|__CODEVIBE_HOOKS_DIR__|$HOOKS_DIR|g" "$TEMPLATE_FILE" > "$GEMINI_SETTINGS_FILE"
-        echo "✓ Hooks configured at: $GEMINI_SETTINGS_FILE"
-    elif ! grep -q "codevibe" "$GEMINI_SETTINGS_FILE" 2>/dev/null; then
-        # Settings exists but no CodeVibe hooks present — append ours
-        echo "Adding CodeVibe hooks to Gemini CLI settings..."
-        if command -v jq >/dev/null 2>&1; then
-            HOOKS_JSON=$(sed "s|__CODEVIBE_HOOKS_DIR__|$HOOKS_DIR|g" "$TEMPLATE_FILE")
-            # Append CodeVibe hook entries to each hook array, preserving existing user hooks
-            jq -s '
-              .[0] as $existing | .[1] as $new |
-              $existing | .hooks = (
-                ($existing.hooks // {}) as $eh |
-                ($new.hooks // {}) as $nh |
-                ($eh | keys) + ($nh | keys) | unique | map(
-                  { (.) : (($eh[.] // []) + ($nh[.] // [])) }
-                ) | add // {}
-              )
-            ' "$GEMINI_SETTINGS_FILE" <(echo "$HOOKS_JSON") > "${GEMINI_SETTINGS_FILE}.tmp" && \
-                mv "${GEMINI_SETTINGS_FILE}.tmp" "$GEMINI_SETTINGS_FILE" && \
-                echo "✓ CodeVibe hooks added to: $GEMINI_SETTINGS_FILE" || \
-                echo "⚠ Failed to add hooks. Delete $GEMINI_SETTINGS_FILE and restart to auto-configure."
-        else
-            echo "⚠ jq not found — cannot add hooks to existing settings."
-            echo "  Delete $GEMINI_SETTINGS_FILE and restart to auto-configure."
-        fi
+    # Single Node-based hook installer: handles fresh install, idempotent
+    # merge, and "already installed" detection — all with a stable
+    # ownership predicate (path-prefix + filename-tail). Why one combined
+    # script vs three branches with grep:
+    #
+    #  - The "already installed" check used to be `grep -q "codevibe"`
+    #    over the whole file. That false-positives if any unrelated user
+    #    setting happens to contain "codevibe" (a path, a comment field
+    #    in JSON, etc.). The structured check looks for our specific
+    #    hook-script files.
+    #
+    #  - The merge used to unconditionally APPEND our entries to existing
+    #    arrays. Two concurrent codevibe-gemini starts could each read
+    #    the pre-merge state and each append, producing duplicate entries
+    #    that then double-fire every event. The new merger filters out
+    #    OUR previously-installed entries (any version's path) before
+    #    appending fresh ones. Multiple runs converge to the same
+    #    settings.json regardless of interleaving.
+    HOOKS_JSON=$(sed "s|__CODEVIBE_HOOKS_DIR__|$HOOKS_DIR|g" "$TEMPLATE_FILE")
+    # Wrapping in `if … ; then … else INSTALLER_RC=$? ; fi` is required
+    # under `set -e` to capture Node's non-zero exit codes; a bare
+    # `VAR=$(cmd)` followed by `RC=$?` would short-circuit on Node's
+    # exit before $? gets read, defeating the fail-closed mapping below.
+    if INSTALLER_OUTPUT=$(CV_EXISTING="$GEMINI_SETTINGS_FILE" \
+                         CV_NEW="$HOOKS_JSON" \
+                         node -e '
+      const fs = require("fs");
+      const OUR_HOOK_FILES = new Set([
+        "session-start.sh",
+        "session-end.sh",
+        "before-agent.sh",
+        "after-agent.sh",
+        "before-tool.sh",
+        "after-tool.sh",
+        "notification.sh",
+      ]);
+      const OWN_PATH_MARKER = "codevibe-gemini-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 (drop the entry);
+      // otherwise returns a new entry with only the user hooks. Returns
+      // the original entry unchanged when it contains none of ours.
+      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 entryContainsOurs = (entry) =>
+        entry && typeof entry === "object" && Array.isArray(entry.hooks) &&
+        entry.hooks.some((h) => h && isOurCommand(h.command));
+
+      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 arr = Array.isArray(existingHooks[k]) ? existingHooks[k] : [];
+        if (!arr.some(entryContainsOurs)) {
+          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 renaming the others half-write.
+      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
+      INSTALLER_RC=0
+    else
+      INSTALLER_RC=$?
+    fi
+    if [ "$INSTALLER_RC" -eq 0 ]; then
+        case "$INSTALLER_OUTPUT" in
+          OUTCOME:already_installed*)
+            _CV_HOOKS_OUTCOME="already_installed"
+            ;;
+          OUTCOME:merged*)
+            echo "✓ CodeVibe hooks added to: $GEMINI_SETTINGS_FILE"
+            _CV_HOOKS_OUTCOME="merged"
+            ;;
+          OUTCOME:fresh_install*)
+            echo "✓ Hooks configured at: $GEMINI_SETTINGS_FILE"
+            _CV_HOOKS_OUTCOME="fresh_install"
+            ;;
+          *)
+            _CV_HOOKS_OUTCOME="merge_failed"
+            _CV_HOOKS_REASON="unrecognized_outcome"
+            log "ERROR: hooks installer returned unrecognized outcome: $INSTALLER_OUTPUT"
+            ;;
+        esac
+    else
+        case "$INSTALLER_RC" in
+          2) _CV_HOOKS_OUTCOME="merge_failed"; _CV_HOOKS_REASON="parse_existing_error" ;;
+          3) _CV_HOOKS_OUTCOME="merge_failed"; _CV_HOOKS_REASON="parse_template_error" ;;
+          4) _CV_HOOKS_OUTCOME="merge_failed"; _CV_HOOKS_REASON="write_failed" ;;
+          *) _CV_HOOKS_OUTCOME="merge_failed"; _CV_HOOKS_REASON="installer_exit_$INSTALLER_RC" ;;
+        esac
+        echo "⚠ Failed to install/merge CodeVibe hooks (rc=$INSTALLER_RC, reason=$_CV_HOOKS_REASON)"
+        log "ERROR: hooks installer failed (rc=$INSTALLER_RC, reason=$_CV_HOOKS_REASON)"
     fi
 }
 
 # Configure hooks before starting
 configure_hooks_if_needed
+cv_telem "hooks_install_outcome" "\"outcome\":\"$_CV_HOOKS_OUTCOME\",\"reason\":\"$_CV_HOOKS_REASON\""
+
+# If hook installation didn't land, there's no point starting the daemon —
+# Gemini events flow ONLY through hooks. Bail with a clear message so the
+# user can fix the underlying file/permission issue rather than running a
+# silent ghost session.
+case "$_CV_HOOKS_OUTCOME" in
+  fresh_install|merged|already_installed) ;;
+  *)
+    echo "Error: failed to install CodeVibe hooks ($_CV_HOOKS_OUTCOME)."
+    echo "       Without hooks installed, Gemini sessions cannot sync to mobile."
+    echo "       Check $LOG_FILE for the underlying error."
+    cv_failed "hooks_install_$_CV_HOOKS_OUTCOME"
+    sleep 1
+    exit 1
+    ;;
+esac
 
-# Configuration
-TMUX_SESSION_PREFIX="codevibe-gemini"
-LOG_FILE="${CODEVIBE_TMPDIR}/codevibe-gemini-wrapper.log"
-MCP_LOG_FILE="${CODEVIBE_TMPDIR}/codevibe-gemini-mcp.log"
-
-log() {
-    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" >> "$LOG_FILE"
-}
+# (TMUX_SESSION_PREFIX/LOG_FILE/MCP_LOG_FILE/log() were hoisted above
+# configure_hooks_if_needed.)
 
 # Cleanup function to kill MCP server when wrapper exits
 cleanup() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-gemini-plugin",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "description": "Control Gemini CLI from your iPhone and Android — real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
   "main": "dist/server.js",
   "bin": {
@@ -49,7 +49,7 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@quantiya/codevibe-core": "^1.0.17",
+    "@quantiya/codevibe-core": "^1.0.18",
     "chokidar": "^5.0.0",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",