ai-agent-session-center 1.0.0

package/hooks/dashboard-hook-gemini.sh

@@ -0,0 +1,102 @@
+#!/bin/bash
+# AI Agent Session Center - Gemini CLI hook relay (macOS / Linux)
+# Receives Gemini event name as $1, reads hook JSON from stdin.
+# Maps Gemini events to dashboard-compatible format, enriches with env info,
+# and delivers to the dashboard server via file-based MQ or HTTP.
+#
+# Key difference from Claude hook:
+# - Gemini hooks are SYNCHRONOUS — must print response to stdout immediately
+# - Event name comes as $1 argument (registered per-event in settings.json)
+# - Session ID from GEMINI_SESSION_ID env var
+# - CWD from GEMINI_CWD env var
+
+GEMINI_EVENT="${1:-unknown}"
+SENT_AT=$(date +%s)
+INPUT=$(cat)
+
+# Gemini hooks are blocking — respond immediately to allow execution
+echo '{"decision":"allow"}'
+
+# --- Everything below runs in background so the hook returns instantly ---
+{
+
+# ── Map Gemini events to dashboard-compatible event names ──
+case "$GEMINI_EVENT" in
+  SessionStart)   MAPPED_EVENT="SessionStart" ;;
+  BeforeAgent)    MAPPED_EVENT="UserPromptSubmit" ;;
+  BeforeTool)     MAPPED_EVENT="PreToolUse" ;;
+  AfterTool)      MAPPED_EVENT="PostToolUse" ;;
+  AfterAgent)     MAPPED_EVENT="Stop" ;;
+  SessionEnd)     MAPPED_EVENT="SessionEnd" ;;
+  Notification)   MAPPED_EVENT="Notification" ;;
+  *)              MAPPED_EVENT="$GEMINI_EVENT" ;;
+esac
+
+# ── Session/CWD from Gemini env vars ──
+SESSION_ID="${GEMINI_SESSION_ID:-}"
+CWD="${GEMINI_CWD:-$(pwd)}"
+
+# ── TTY detection (cached per PID) ──
+HOOK_TTY=""
+if [ -n "$PPID" ] && [ "$PPID" != "0" ]; then
+  TTY_CACHE="/tmp/gemini-tty-cache"
+  TTY_CACHE_FILE="$TTY_CACHE/$PPID"
+  if [ -f "$TTY_CACHE_FILE" ]; then
+    HOOK_TTY=$(cat "$TTY_CACHE_FILE" 2>/dev/null)
+  else
+    RAW_TTY=$(ps -o tty= -p "$PPID" 2>/dev/null | tr -d ' ')
+    if [ -n "$RAW_TTY" ] && [ "$RAW_TTY" != "??" ] && [ "$RAW_TTY" != "?" ]; then
+      HOOK_TTY="/dev/${RAW_TTY}"
+      mkdir -p "$TTY_CACHE" 2>/dev/null
+      echo "$HOOK_TTY" > "$TTY_CACHE_FILE" 2>/dev/null
+    fi
+  fi
+fi
+
+# ── Single jq pass: build enriched JSON ──
+ENRICHED=$(echo "$INPUT" | jq -c \
+  --arg event "$MAPPED_EVENT" \
+  --arg session_id "$SESSION_ID" \
+  --arg cwd "$CWD" \
+  --arg pid "$PPID" \
+  --arg tty "$HOOK_TTY" \
+  --arg sent_at "$SENT_AT" \
+  --arg agent_terminal_id "${AGENT_MANAGER_TERMINAL_ID:-}" \
+  --arg gemini_event "$GEMINI_EVENT" \
+  '
+  {
+    hook_event_name: $event,
+    session_id: (if $session_id != "" then $session_id else (.session_id // null) end),
+    cwd: (if $cwd != "" then $cwd else (.cwd // null) end),
+    claude_pid: ($pid | tonumber),
+    hook_sent_at: (($sent_at | tonumber) * 1000),
+    tty_path: (if $tty != "" then $tty else null end),
+    agent_terminal_id: (if $agent_terminal_id != "" then $agent_terminal_id else null end),
+    tool_name: (.tool_name // null),
+    tool_input: (.tool_input // null),
+    prompt: (.prompt // .llm_request // null),
+    response: (.response // .llm_response // .prompt_response // null),
+    model: (.model // null),
+    source: "gemini",
+    gemini_event: $gemini_event
+  }
+  ' 2>/dev/null)
+
+[ -z "$ENRICHED" ] && ENRICHED="{\"hook_event_name\":\"$MAPPED_EVENT\",\"session_id\":\"$SESSION_ID\",\"cwd\":\"$CWD\",\"source\":\"gemini\"}"
+
+# ── Deliver to dashboard via file-based MQ (primary) or HTTP (fallback) ──
+MQ_DIR="/tmp/claude-session-center"
+MQ_FILE="$MQ_DIR/queue.jsonl"
+
+if [ -d "$MQ_DIR" ]; then
+  echo "$ENRICHED" >> "$MQ_FILE" 2>/dev/null
+else
+  echo "$ENRICHED" | curl -s --connect-timeout 1 -m 3 -X POST \
+    -H "Content-Type: application/json" \
+    --data-binary @- \
+    http://localhost:3333/api/hooks &>/dev/null
+fi
+
+} &>/dev/null &
+disown
+exit 0

package/hooks/dashboard-hook.ps1

@@ -0,0 +1,147 @@
+# AI Agent Session Center - Hook relay (Windows)
+# Reads hook JSON from stdin, enriches with process/env info, POSTs to dashboard server
+# Runs in background, fails silently if server is not running
+
+$ErrorActionPreference = 'SilentlyContinue'
+$input_json = [Console]::In.ReadToEnd()
+
+if (-not $input_json) { exit 0 }
+
+# Gather environment info
+$claude_pid = (Get-Process -Id $PID).Parent.Id  # Parent of PowerShell = Claude process
+$vscode_pid = $env:VSCODE_PID
+$term_program = $env:TERM_PROGRAM
+$wt_session = $env:WT_SESSION           # Windows Terminal session GUID
+$wt_profile = $env:WT_PROFILE_ID        # Windows Terminal profile ID
+$conemu_pid = $env:ConEmuPID            # ConEmu/Cmder PID
+$term = $env:TERM
+
+# Build enrichment object
+$enrich = @{
+    claude_pid = if ($claude_pid) { [int]$claude_pid } else { $null }
+    term_program = if ($term_program) { $term_program } else { $null }
+    vscode_pid = if ($vscode_pid) { [int]$vscode_pid } else { $null }
+    term = if ($term) { $term } else { $null }
+    tab_id = if ($wt_session) { "wt:$wt_session" } elseif ($conemu_pid) { "conemu:$conemu_pid" } else { $null }
+    wt_profile = if ($wt_profile) { $wt_profile } else { $null }
+}
+
+# Merge enrichment into the hook JSON
+try {
+    $data = $input_json | ConvertFrom-Json
+    foreach ($key in $enrich.Keys) {
+        if ($null -ne $enrich[$key]) {
+            $data | Add-Member -NotePropertyName $key -NotePropertyValue $enrich[$key] -Force
+        }
+    }
+    $enriched = $data | ConvertTo-Json -Compress -Depth 10
+} catch {
+    $enriched = $input_json
+}
+
+# ---- Tab title management ----
+# Keep the terminal tab/window title set to "Claude: <project>" so the dashboard can find it.
+# On SessionStart: resolve project name and cache to temp file.
+# On every other event: read cache and refresh the title.
+# Uses console title (works on Windows Terminal, ConEmu, cmd, PowerShell, VS Code, JetBrains).
+# Works in all terminals including VS Code and JetBrains integrated terminals.
+try {
+    $hookEvent = ($input_json | ConvertFrom-Json).hook_event_name
+    $sessionId = ($input_json | ConvertFrom-Json).session_id
+} catch {
+    $hookEvent = $null
+    $sessionId = $null
+}
+
+$cacheDir = "$env:TEMP\claude-tab-titles"
+if ($sessionId) {
+    $cacheFile = "$cacheDir\$sessionId"
+
+    if ($hookEvent -eq 'SessionStart') {
+        # Resolve project name from cwd in JSON or from Claude process cwd
+        $project = $null
+        try {
+            $cwd = ($input_json | ConvertFrom-Json).cwd
+            if ($cwd) { $project = Split-Path $cwd -Leaf }
+        } catch {}
+        if (-not $project -and $claude_pid) {
+            try {
+                $proc = Get-Process -Id $claude_pid -ErrorAction Stop
+                $project = Split-Path $proc.Path -Leaf
+                # Try to get actual working directory via CIM
+                $wmiProc = Get-CimInstance Win32_Process -Filter "ProcessId=$claude_pid" -ErrorAction Stop
+                if ($wmiProc.CommandLine -match '([A-Z]:\\[^\s"]+)') {
+                    $possiblePath = $Matches[1]
+                    if (Test-Path $possiblePath -PathType Container) {
+                        $project = Split-Path $possiblePath -Leaf
+                    }
+                }
+            } catch {}
+        }
+        if ($project) {
+            if (-not (Test-Path $cacheDir)) { New-Item -ItemType Directory -Path $cacheDir -Force | Out-Null }
+            $project | Out-File -FilePath $cacheFile -Encoding utf8 -NoNewline
+        }
+    } elseif ($hookEvent -eq 'SessionEnd') {
+        # Clean up
+        if (Test-Path $cacheFile) { Remove-Item $cacheFile -Force }
+    } else {
+        # Read cached project name
+        $project = $null
+        if (Test-Path $cacheFile) { $project = Get-Content $cacheFile -Raw -ErrorAction SilentlyContinue }
+    }
+
+    # Set/refresh the console window title on every event (except SessionEnd)
+    if ($hookEvent -ne 'SessionEnd' -and $project) {
+        $Host.UI.RawUI.WindowTitle = "Claude: $project"
+    }
+}
+
+# Deliver to dashboard via file-based MQ (primary) or HTTP (fallback)
+$mqDir = "$env:TEMP\claude-session-center"
+$mqFile = "$mqDir\queue.jsonl"
+
+if (Test-Path $mqDir -PathType Container) {
+    # File-based MQ: atomic append via .NET StreamWriter (no process spawn)
+    try {
+        $fs = [System.IO.File]::Open($mqFile,
+            [System.IO.FileMode]::Append,
+            [System.IO.FileAccess]::Write,
+            [System.IO.FileShare]::ReadWrite)
+        $writer = New-Object System.IO.StreamWriter($fs)
+        $writer.WriteLine($enriched)
+        $writer.Flush()
+        $writer.Close()
+        $fs.Close()
+    } catch {
+        # Fall through to HTTP on file error
+        try {
+            $job = Start-Job -ScriptBlock {
+                param($body)
+                try {
+                    Invoke-RestMethod -Uri 'http://localhost:3333/api/hooks' `
+                        -Method POST `
+                        -ContentType 'application/json' `
+                        -Body $body `
+                        -TimeoutSec 5 | Out-Null
+                } catch {}
+            } -ArgumentList $enriched
+        } catch {}
+    }
+} else {
+    # Fallback: HTTP POST when MQ dir doesn't exist (server not started yet)
+    try {
+        $job = Start-Job -ScriptBlock {
+            param($body)
+            try {
+                Invoke-RestMethod -Uri 'http://localhost:3333/api/hooks' `
+                    -Method POST `
+                    -ContentType 'application/json' `
+                    -Body $body `
+                    -TimeoutSec 5 | Out-Null
+            } catch {}
+        } -ArgumentList $enriched
+    } catch {}
+}
+
+exit 0

package/hooks/dashboard-hook.sh

@@ -0,0 +1,142 @@
+#!/bin/bash
+# AI Agent Session Center - Hook relay (macOS / Linux)
+# Reads hook JSON from stdin, enriches with process/env info, POSTs to dashboard server
+#
+# Performance notes:
+# - stdin read (cat) is synchronous; everything else runs in a background subshell
+# - Single jq invocation for all JSON parsing + enrichment
+# - TTY lookup cached per PID in /tmp to avoid `ps` on every event
+# - Tab title only refreshed on state-changing events, not rapid tool calls
+# - curl fails fast (1s connect timeout) so dead server doesn't pile up processes
+# - hook_sent_at timestamp lets the server measure delivery latency
+
+SENT_AT=$(date +%s)
+INPUT=$(cat)
+
+# --- Everything below runs in background so the hook returns instantly ---
+{
+
+# ── TTY detection (cached per Claude PID) ──
+HOOK_TTY=""
+if [ -n "$PPID" ] && [ "$PPID" != "0" ]; then
+  TTY_CACHE="/tmp/claude-tty-cache"
+  TTY_CACHE_FILE="$TTY_CACHE/$PPID"
+  if [ -f "$TTY_CACHE_FILE" ]; then
+    HOOK_TTY=$(cat "$TTY_CACHE_FILE" 2>/dev/null)
+  else
+    RAW_TTY=$(ps -o tty= -p "$PPID" 2>/dev/null | tr -d ' ')
+    if [ -n "$RAW_TTY" ] && [ "$RAW_TTY" != "??" ] && [ "$RAW_TTY" != "?" ]; then
+      HOOK_TTY="/dev/${RAW_TTY}"
+      mkdir -p "$TTY_CACHE" 2>/dev/null
+      echo "$HOOK_TTY" > "$TTY_CACHE_FILE" 2>/dev/null
+    fi
+  fi
+fi
+
+# ── Single jq pass: enrich JSON + extract event/session_id/cwd ──
+JQ_OUT=$(echo "$INPUT" | jq -c \
+  --arg pid "$PPID" \
+  --arg tty "$HOOK_TTY" \
+  --arg sent_at "$SENT_AT" \
+  --arg term_program "${TERM_PROGRAM:-}" \
+  --arg term_program_version "${TERM_PROGRAM_VERSION:-}" \
+  --arg vscode_pid "${VSCODE_PID:-}" \
+  --arg term "${TERM:-}" \
+  --arg iterm_session "${ITERM_SESSION_ID:-}" \
+  --arg term_session "${TERM_SESSION_ID:-}" \
+  --arg kitty_window "${KITTY_WINDOW_ID:-}" \
+  --arg kitty_pid "${KITTY_PID:-}" \
+  --arg warp_session "${WARP_SESSION_ID:-}" \
+  --arg windowid "${WINDOWID:-}" \
+  --arg ghostty_resources "${GHOSTTY_RESOURCES_DIR:-}" \
+  --arg wezterm_pane "${WEZTERM_PANE:-}" \
+  --arg tmux "${TMUX:-}" \
+  --arg tmux_pane "${TMUX_PANE:-}" \
+  --arg agent_terminal_id "${AGENT_MANAGER_TERMINAL_ID:-}" \
+  --arg claude_project_dir "${CLAUDE_PROJECT_DIR:-}" \
+  '
+  (. + {
+    claude_pid: ($pid | tonumber),
+    hook_sent_at: (($sent_at | tonumber) * 1000),
+    tty_path: (if $tty != "" then $tty else null end),
+    term_program: (if $term_program != "" then $term_program else null end),
+    term_program_version: (if $term_program_version != "" then $term_program_version else null end),
+    vscode_pid: (if $vscode_pid != "" then ($vscode_pid | tonumber) else null end),
+    term: (if $term != "" then $term else null end),
+    tab_id: (
+      if $iterm_session != "" then $iterm_session
+      elif $kitty_window != "" then ("kitty:" + $kitty_window)
+      elif $warp_session != "" then ("warp:" + $warp_session)
+      elif $wezterm_pane != "" then ("wezterm:" + $wezterm_pane)
+      elif $term_session != "" then $term_session
+      else null end
+    ),
+    window_id: (if $windowid != "" then ($windowid | tonumber) else null end),
+    tmux: (if $tmux != "" then {session: $tmux, pane: $tmux_pane} else null end),
+    is_ghostty: (if $ghostty_resources != "" then true else null end),
+    kitty_pid: (if $kitty_pid != "" then ($kitty_pid | tonumber) else null end),
+    agent_terminal_id: (if $agent_terminal_id != "" then $agent_terminal_id else null end),
+    claude_project_dir: (if $claude_project_dir != "" then $claude_project_dir else null end)
+  }),
+  "\(.hook_event_name // "")",
+  "\(.session_id // "")",
+  "\(.cwd // "")"
+  ' 2>/dev/null)
+
+ENRICHED=$(echo "$JQ_OUT" | head -1)
+EVENT=$(echo "$JQ_OUT" | sed -n '2p' | tr -d '"')
+SESSION_ID=$(echo "$JQ_OUT" | sed -n '3p' | tr -d '"')
+CWD=$(echo "$JQ_OUT" | sed -n '4p' | tr -d '"')
+
+[ -z "$ENRICHED" ] && ENRICHED="$INPUT"
+
+# ── Tab title management ──
+# Only refresh on state-changing events — skip rapid PreToolUse/PostToolUse
+CACHE_DIR="/tmp/claude-tab-titles"
+
+if [ -n "$HOOK_TTY" ] && [ -n "$SESSION_ID" ]; then
+  CACHE_FILE="$CACHE_DIR/$SESSION_ID"
+
+  case "$EVENT" in
+    SessionStart)
+      PROJECT=""
+      [ -n "$CWD" ] && PROJECT=$(basename "$CWD" 2>/dev/null)
+      if [ -z "$PROJECT" ] && [ -n "$PPID" ]; then
+        PROJECT=$(lsof -a -d cwd -p "$PPID" -Fn 2>/dev/null | grep '^n/' | head -1 | sed 's|^n||' | xargs basename 2>/dev/null)
+      fi
+      if [ -n "$PROJECT" ]; then
+        mkdir -p "$CACHE_DIR" 2>/dev/null
+        echo "$PROJECT" > "$CACHE_FILE" 2>/dev/null
+        printf '\033]0;Claude: %s\007' "$PROJECT" > "$HOOK_TTY" 2>/dev/null
+      fi
+      ;;
+    SessionEnd)
+      rm -f "$CACHE_FILE" 2>/dev/null
+      ;;
+    UserPromptSubmit|PermissionRequest|Stop|Notification)
+      PROJECT=""
+      [ -f "$CACHE_FILE" ] && PROJECT=$(cat "$CACHE_FILE" 2>/dev/null)
+      [ -n "$PROJECT" ] && printf '\033]0;Claude: %s\007' "$PROJECT" > "$HOOK_TTY" 2>/dev/null
+      ;;
+  esac
+fi
+
+# ── Deliver to dashboard via file-based MQ (primary) or HTTP (fallback) ──
+MQ_DIR="/tmp/claude-session-center"
+MQ_FILE="$MQ_DIR/queue.jsonl"
+
+if [ -d "$MQ_DIR" ]; then
+  # Atomic append: POSIX guarantees atomicity for writes <= PIPE_BUF (4096 bytes).
+  # Our enriched JSON is typically 300-800 bytes — no process spawn, ~0.1ms.
+  echo "$ENRICHED" >> "$MQ_FILE" 2>/dev/null
+else
+  # Fallback: HTTP POST when MQ dir doesn't exist (server not started yet)
+  echo "$ENRICHED" | curl -s --connect-timeout 1 -m 3 -X POST \
+    -H "Content-Type: application/json" \
+    --data-binary @- \
+    http://localhost:3333/api/hooks &>/dev/null
+fi
+
+} &>/dev/null &
+disown
+exit 0

package/hooks/dashboard-hooks-backup.json

@@ -0,0 +1,103 @@
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/dashboard-hook.sh",
+            "async": true
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/dashboard-hook.sh",
+            "async": true
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/dashboard-hook.sh",
+            "async": true
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/dashboard-hook.sh",
+            "async": true
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/dashboard-hook.sh",
+            "async": true
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/dashboard-hook.sh",
+            "async": true
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/dashboard-hook.sh",
+            "async": true
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/dashboard-hook.sh",
+            "async": true
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/hooks/dashboard-hook.sh",
+            "async": true
+          }
+        ]
+      }
+    ]
+  }
+}