claude-smart 0.2.48 → 0.2.50

package/plugin/scripts/dashboard-service.sh

@@ -1,11 +1,11 @@
 #!/usr/bin/env bash
-# Auto-start the claude-smart Next.js dashboard (port 3001) if it's not
-# already running. Mirrors how claude-mem boots its worker on SessionStart:
+# Auto-start the claude-smart Next.js dashboard if it's not already running.
+# Mirrors how claude-mem boots its worker on SessionStart:
 # detached, returns immediately so the hook doesn't block the session.
 #
 # Subcommands:
-#   start         probe the port; spawn `npm run start` if our dashboard
-#                 isn't already answering. Never builds in foreground — if
+#   start         probe the port; spawn local `next start` if no claude-smart
+#                 dashboard is already answering. Never builds in foreground — if
 #                 .next is missing, logs and bails (Setup is responsible for
 #                 the build; rerun it or restart Claude Code to retry).
 #   stop          kill the recorded process group, and (if our dashboard
@@ -28,7 +28,10 @@ fi
 claude_smart_prepend_node_bins
 claude_smart_source_reflexio_env
 
-PORT=3001
+BACKEND_PORT="${BACKEND_PORT:-8071}"
+PORT="${DASHBOARD_PORT:-${PORT:-3001}}"
+export BACKEND_PORT
+claude_smart_derive_reflexio_url_from_backend_port
 
 PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
 claude_smart_reexec_stable_plugin_root_if_needed "$PLUGIN_ROOT" "dashboard-service.sh" "$@"
@@ -48,128 +51,98 @@ kill_group() {
   claude_smart_kill_tree "$1"
 }
 
+dashboard_pid_command_matches() {
+  pid="$1"
+  cmdline="$(claude_smart_pid_command "$pid" | tr '\n' ' ' || true)"
+  [ -n "$cmdline" ] || return 1
+  case "$cmdline" in
+    *"$DASHBOARD_DIR"*|*next-server*|*next*start*|*node*next*|*claude-smart*dashboard*) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+kill_recorded_dashboard() {
+  if [ -f "$PID_FILE" ]; then
+    pid="$(cat "$PID_FILE" 2>/dev/null || true)"
+    if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null && dashboard_pid_command_matches "$pid"; then
+      kill_group "$pid"
+    fi
+    rm -f "$PID_FILE"
+  fi
+}
+
 # True if the marker header served by app/api/health is present on the
 # port. Requires curl — absence is reported as false. This deliberately
 # accepts any claude-smart dashboard, including stale cache versions, so
 # stop/uninstall can safely reap them without touching foreign listeners.
 marker_responds() {
   command -v curl >/dev/null 2>&1 || return 1
-  curl -sfI "http://127.0.0.1:$PORT/api/health" 2>/dev/null \
+  curl -sfI --connect-timeout 1 --max-time 2 "http://127.0.0.1:$PORT/api/health" 2>/dev/null \
     | grep -qi '^x-claude-smart-dashboard:'
 }
 
-dashboard_health_headers() {
-  command -v curl >/dev/null 2>&1 || return 1
-  curl -sfI --connect-timeout 2 --max-time 5 "http://127.0.0.1:$PORT/api/health" 2>/dev/null
-}
-
-header_value_from() {
-  header_name="$1"
-  awk -v wanted="$header_name" '
-    BEGIN { wanted = tolower(wanted) ":" }
-    {
-      line = $0
-      sub(/\r$/, "", line)
-      lower = tolower(line)
-      if (index(lower, wanted) == 1) {
-        sub(/^[^:]*:[[:space:]]*/, "", line)
-        print line
-        exit
-      }
-    }
-  '
-}
-
-canonical_dir() {
-  dir="$1"
-  (cd "$dir" 2>/dev/null && pwd -P) || printf '%s\n' "$dir"
-}
-
-normalize_identity_path() {
-  path="$1"
-  if claude_smart_is_windows; then
-    if command -v cygpath >/dev/null 2>&1; then
-      path="$(cygpath -u "$path" 2>/dev/null || printf '%s\n' "$path")"
-    else
-      path="$(
-        printf '%s\n' "$path" | awk '{
-          gsub(/\\/, "/")
-          if ($0 ~ /^[A-Za-z]:/) {
-            drive = tolower(substr($0, 1, 1))
-            sub(/^[A-Za-z]:/, "/" drive)
-          }
-          print
-        }'
-      )"
-    fi
-  fi
-  while [ "${path%/}" != "$path" ] && [ "$path" != "/" ]; do
-    path="${path%/}"
-  done
-  printf '%s\n' "$path"
-}
-
-# True only if *this plugin root's* dashboard is on the port. The generic
-# x-claude-smart-dashboard marker is intentionally not enough: after an
-# install/update, an older cache can keep serving port 3001 until restarted.
-dashboard_matches_current_root() {
-  expected_root="$(normalize_identity_path "$(canonical_dir "$PLUGIN_ROOT")")"
-  headers="$(dashboard_health_headers)" || return 1
-  printf '%s\n' "$headers" | grep -qi '^x-claude-smart-dashboard:' || return 1
-  actual_root="$(printf '%s\n' "$headers" | header_value_from "x-claude-smart-plugin-root")"
-  [ -n "$actual_root" ] || return 1
-  actual_root="$(normalize_identity_path "$actual_root")"
-  [ "$actual_root" = "$expected_root" ]
-}
-
 # Kill a claude-smart dashboard listener currently holding the port. Gated by
-# marker_responds so a foreign app on 3001 is never killed.
+# marker_responds so a foreign listener on the dashboard port is never killed.
 stop_dashboard_listener() {
   marker_responds || return 0
-  command -v lsof >/dev/null 2>&1 || return 0
-  port_pid=$(lsof -t -i ":$PORT" -sTCP:LISTEN 2>/dev/null | head -n1)
-  [ -n "$port_pid" ] || return 0
-  kill -TERM "$port_pid" 2>/dev/null || true
-  for _ in 1 2 3 4 5; do
-    kill -0 "$port_pid" 2>/dev/null || return 0
-    sleep 0.2
-  done
-  kill -KILL "$port_pid" 2>/dev/null || true
-}
-
-# True only if *our* dashboard is on the port. Uses plugin-root identity so a
-# stale claude-smart listener doesn't cause us to silently skip starting.
-is_our_dashboard_running() {
-  if [ -f "$PID_FILE" ]; then
-    pid=$(cat "$PID_FILE" 2>/dev/null || echo "")
-    if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
-      # PID alive — still verify the port responds with our marker so we
-      # don't claim "running" when the server crashed but the group leader
-      # lingered.
-      if command -v curl >/dev/null 2>&1; then
-        dashboard_matches_current_root && return 0
-      else
-        # No curl — fall back to PID liveness alone.
-        return 0
-      fi
-    fi
-  fi
-  # No PID or dead PID — probe the port for our marker (recovers after a
-  # stale PID file from a crash).
-  dashboard_matches_current_root && return 0
-  return 1
+  kill_recorded_dashboard
+  claude_smart_reap_port_listeners_matching "$PORT" \
+    '*next-server*' \
+    '*next*start*' \
+    '*node*next*' \
+    '*claude-smart*dashboard*' || true
 }
 
 # True if *something* is listening on the port, regardless of marker.
 port_occupied() {
   if command -v curl >/dev/null 2>&1; then
-    curl -sf -o /dev/null "http://127.0.0.1:$PORT" 2>/dev/null && return 0
+    curl -sf --max-time 2 -o /dev/null "http://127.0.0.1:$PORT" 2>/dev/null && return 0
     # curl with -sfI against a 404/405 still indicates "something answered".
     # Use a connect-only probe as a secondary signal.
   fi
   (echo >"/dev/tcp/127.0.0.1/$PORT") 2>/dev/null
 }
 
+resolve_next_bin() {
+  if claude_smart_is_windows; then
+    for candidate in "$DASHBOARD_DIR/node_modules/.bin/next.cmd" "$DASHBOARD_DIR/node_modules/.bin/next"; do
+      [ -f "$candidate" ] && { printf '%s\n' "$candidate"; return 0; }
+    done
+  else
+    for candidate in "$DASHBOARD_DIR/node_modules/.bin/next" "$DASHBOARD_DIR/node_modules/.bin/next.cmd"; do
+      [ -f "$candidate" ] && { printf '%s\n' "$candidate"; return 0; }
+    done
+  fi
+  return 1
+}
+
+spawn_dashboard() {
+  NEXT_BIN="$(resolve_next_bin || true)"
+  if [ -z "$NEXT_BIN" ]; then
+    reason="local Next.js binary is missing; run claude-smart install/update to restore dashboard dependencies"
+    echo "[claude-smart] dashboard: $reason" >>"$LOG_FILE"
+    claude_smart_write_dashboard_unavailable "$reason"
+    return 1
+  fi
+  cd "$DASHBOARD_DIR"
+  export CLAUDE_SMART_DASHBOARD_WORKSPACE="$WORKSPACE_CWD"
+  # Invoke Next directly so custom DASHBOARD_PORT/PORT values are honored
+  # without relying on package.json's fixed start script.
+  CLAUDE_SMART_SPAWN_KEEP_OUTPUT=1 claude_smart_spawn_detached "$NEXT_BIN" start -p "$PORT" -H 127.0.0.1 >>"$LOG_FILE" 2>&1
+  dash_pid=$!
+  echo "$dash_pid" > "$PID_FILE"
+}
+
+wait_for_dashboard_marker() {
+  attempts="$1"
+  while [ "$attempts" -gt 0 ]; do
+    marker_responds && return 0
+    attempts=$((attempts - 1))
+    sleep 1
+  done
+  marker_responds
+}
+
 case "$CMD" in
   start)
     if claude_smart_is_internal_invocation_env; then
@@ -181,11 +154,19 @@ case "$CMD" in
       emit_ok; exit 0
     fi
     if [ ! -d "$DASHBOARD_DIR" ]; then emit_ok; exit 0; fi
-    if is_our_dashboard_running; then claude_smart_clear_dashboard_unavailable; emit_ok; exit 0; fi
-    if marker_responds; then
-      echo "[claude-smart] dashboard: stale claude-smart dashboard on port $PORT; restarting from $PLUGIN_ROOT" >>"$LOG_FILE"
-      stop_dashboard_listener
+    if marker_responds; then claude_smart_clear_dashboard_unavailable; emit_ok; exit 0; fi
+    if ! claude_smart_service_lock "dashboard"; then
+      for _ in 1 2 3 4 5; do
+        if marker_responds; then
+          claude_smart_clear_dashboard_unavailable
+          emit_ok; exit 0
+        fi
+        sleep 0.2
+      done
+      emit_ok; exit 0
     fi
+    trap 'claude_smart_service_unlock "dashboard"' EXIT
+    if marker_responds; then claude_smart_clear_dashboard_unavailable; emit_ok; exit 0; fi
     if port_occupied; then
       echo "[claude-smart] dashboard: port $PORT held by another process; skipping" >>"$LOG_FILE"
       emit_ok; exit 0
@@ -221,8 +202,6 @@ case "$CMD" in
       emit_ok; exit 0
     fi
 
-    cd "$DASHBOARD_DIR"
-
     # Detach so the hook returns immediately. claude_smart_spawn_detached
     # picks the strongest primitive available:
     #   - Linux: setsid (puts child in its own session/group, pid==pgid).
@@ -230,36 +209,41 @@ case "$CMD" in
     #   - Windows: nohup alone (no process groups; tree-kill via taskkill).
     # Caller-side `>>file 2>&1` redirection is honoured before the child
     # detaches, so per-OS log paths stay identical.
-    export CLAUDE_SMART_DASHBOARD_WORKSPACE="$WORKSPACE_CWD"
-    CLAUDE_SMART_SPAWN_KEEP_OUTPUT=1 claude_smart_spawn_detached "$NPM_BIN" run start >>"$LOG_FILE" 2>&1
-    dash_pid=$!
-    # Record the spawned pid, not a pgid sampled with ps. On POSIX,
-    # setsid/python os.setsid make this pid the new process group leader;
-    # sampling immediately can race and capture the caller's pgid instead.
-    # On Windows, claude_smart_kill_tree translates the MSYS pid to WINPID.
-    echo "$dash_pid" > "$PID_FILE"
-    dashboard_ready=0
-    for _ in 1 2 3 4 5; do
-      if dashboard_matches_current_root; then
-        dashboard_ready=1
-        claude_smart_clear_dashboard_unavailable
-        break
+    if ! spawn_dashboard; then
+      emit_ok; exit 0
+    fi
+    if wait_for_dashboard_marker 5; then
+      claude_smart_clear_dashboard_unavailable
+      emit_ok; exit 0
+    fi
+    if ! kill -0 "$dash_pid" 2>/dev/null; then
+      sleep 2
+      if port_occupied; then
+        if marker_responds; then
+          claude_smart_clear_dashboard_unavailable
+        else
+          claude_smart_write_dashboard_unavailable "dashboard process exited and port $PORT is now held by a non-claude-smart listener; see $LOG_FILE"
+        fi
+      else
+        echo "[claude-smart] dashboard: first start exited before readiness; retrying once" >>"$LOG_FILE"
+        if spawn_dashboard; then
+          if wait_for_dashboard_marker 5; then
+            claude_smart_clear_dashboard_unavailable
+          else
+            claude_smart_write_dashboard_unavailable "dashboard process spawned but did not respond on http://127.0.0.1:$PORT within 5s; see $LOG_FILE"
+          fi
+        fi
       fi
-      sleep 1
-    done
-    if [ "$dashboard_ready" != "1" ]; then
+    else
       claude_smart_write_dashboard_unavailable "dashboard process spawned but did not respond on http://127.0.0.1:$PORT within 5s; see $LOG_FILE"
     fi
     emit_ok
     ;;
   stop)
-    if [ -f "$PID_FILE" ]; then
-      kill_group "$(cat "$PID_FILE" 2>/dev/null)"
-      rm -f "$PID_FILE"
-    fi
+    kill_recorded_dashboard
     # Fallback: if a claude-smart dashboard is still responding on the port (e.g.,
     # was started outside this script, or the PGID kill missed because
-    # the process wasn't the group leader) kill whoever owns the port.
+    # the process wasn't the group leader) reap only dashboard-shaped listeners.
     # Gated on the marker header so we never touch a foreign listener.
     stop_dashboard_listener
     emit_ok
@@ -269,15 +253,12 @@ case "$CMD" in
     # interactions/playbooks between sessions. Opt in to teardown by setting
     # CLAUDE_SMART_DASHBOARD_STOP_ON_END=1 in the environment.
     if [ "${CLAUDE_SMART_DASHBOARD_STOP_ON_END:-0}" = "1" ]; then
-      if [ -f "$PID_FILE" ]; then
-        kill_group "$(cat "$PID_FILE" 2>/dev/null)"
-        rm -f "$PID_FILE"
-      fi
+      kill_recorded_dashboard
     fi
     emit_ok
     ;;
   status)
-    if is_our_dashboard_running; then echo "running on http://localhost:$PORT"; else echo "not running"; fi
+    if marker_responds; then echo "running on http://localhost:$PORT"; else echo "not running"; fi
     ;;
   *)
     emit_ok

package/plugin/scripts/ensure-plugin-root.sh

@@ -8,6 +8,61 @@
 #            invalid target
 set -eu
 
+HERE="$(cd "$(dirname "$0")" && pwd)"
+if [ -f "$HERE/_lib.sh" ]; then
+    # shellcheck source=_lib.sh
+    . "$HERE/_lib.sh"
+fi
+
+# This script can be invoked without plugin/scripts/_lib.sh; keep these fallbacks
+# in sync with the shared helpers there.
+if ! command -v claude_smart_is_windows >/dev/null 2>&1; then
+    claude_smart_is_windows() {
+        case "$(uname -s 2>/dev/null)" in
+            MINGW*|MSYS*|CYGWIN*) return 0 ;;
+            *) return 1 ;;
+        esac
+    }
+fi
+
+if ! command -v claude_smart_to_windows_path >/dev/null 2>&1; then
+    claude_smart_to_windows_path() {
+        path="$1"
+        if command -v cygpath >/dev/null 2>&1; then
+            cygpath -w "$path"
+            return $?
+        fi
+        printf '%s\n' "$path" | awk '
+        function slash_to_backslash(value) {
+            gsub(/\//, "\\", value)
+            return value
+        }
+        function drive_path(drive, rest) {
+            drive = toupper(drive)
+            sub(/^\//, "", rest)
+            if (rest == "") {
+                return drive ":\\"
+            }
+            return drive ":\\" slash_to_backslash(rest)
+        }
+        {
+            normalized = $0
+            gsub(/\\/, "/", normalized)
+            if (normalized ~ /^[A-Za-z]:($|\/)/) {
+                print drive_path(substr(normalized, 1, 1), substr(normalized, 3))
+            } else if (normalized ~ /^\/cygdrive\/[A-Za-z]($|\/)/) {
+                print drive_path(substr(normalized, 11, 1), substr(normalized, 12))
+            } else if (normalized ~ /^\/mnt\/[A-Za-z]($|\/)/) {
+                print drive_path(substr(normalized, 6, 1), substr(normalized, 7))
+            } else if (normalized ~ /^\/[A-Za-z]($|\/)/) {
+                print drive_path(substr(normalized, 2, 1), substr(normalized, 3))
+            } else {
+                print slash_to_backslash(normalized)
+            }
+        }'
+    }
+fi
+
 TARGET="${1:-}"
 FORCE="${2:-}"
 
@@ -25,9 +80,46 @@ TARGET="$(cd "$TARGET" && pwd -P)"
 LINK="$HOME/.reflexio/plugin-root"
 mkdir -p "$(dirname "$LINK")"
 
-if [ "$FORCE" = "--force" ]; then
+write_plugin_root_metadata() {
+    printf '%s\n' "$TARGET" >"$HOME/.reflexio/plugin-root.txt"
+}
+
+write_plugin_root_link() {
+    reason="$1"
+    if claude_smart_is_windows; then
+        link_win="$(claude_smart_to_windows_path "$LINK")"
+        target_win="$(claude_smart_to_windows_path "$TARGET")"
+        if [ -L "$LINK" ] || [ -f "$LINK" ]; then
+            rm -f "$LINK"
+        elif [ -e "$LINK" ]; then
+            # Intentionally avoid rmdir //S //Q here: if this is a real
+            # directory rather than a junction, preserve it and use metadata
+            # fallback instead of recursively deleting user-owned contents.
+            if ! cmd.exe //C rmdir "$link_win" >/dev/null 2>&1; then
+                echo "[claude-smart] ensure-plugin-root: could not remove existing Windows junction/path at $LINK" >&2
+            fi
+        fi
+        if [ ! -e "$LINK" ] && cmd.exe //C mklink //J "$link_win" "$target_win" >/dev/null 2>&1; then
+            write_plugin_root_metadata
+            echo "[claude-smart] plugin-root → $TARGET${reason:+ ($reason)}" >&2
+            return 0
+        fi
+        write_plugin_root_metadata
+        if [ -e "$LINK" ]; then
+            echo "[claude-smart] ensure-plugin-root: $LINK blocks Windows junction; preserving occupied path and wrote plugin-root.txt fallback" >&2
+        else
+            echo "[claude-smart] ensure-plugin-root: mklink //J failed; wrote plugin-root.txt fallback" >&2
+        fi
+        echo "[claude-smart] plugin-root.txt → $TARGET${reason:+ ($reason; junction unavailable)}" >&2
+        return 0
+    fi
+
     ln -sfn "$TARGET" "$LINK"
-    echo "[claude-smart] plugin-root → $TARGET (forced)" >&2
+    echo "[claude-smart] plugin-root → $TARGET${reason:+ ($reason)}" >&2
+}
+
+if [ "$FORCE" = "--force" ]; then
+    write_plugin_root_link "forced"
     exit 0
 fi
 
@@ -43,8 +135,7 @@ if [ -z "$FOLLOW" ] && [ -f "$HOME/.claude-smart/.env" ]; then
     FOLLOW="${FOLLOW#\'}"; FOLLOW="${FOLLOW%\'}"
 fi
 if [ "$FOLLOW" = "1" ]; then
-    ln -sfn "$TARGET" "$LINK"
-    echo "[claude-smart] plugin-root → $TARGET (follow-session)" >&2
+    write_plugin_root_link "follow-session"
     exit 0
 fi
 
@@ -53,16 +144,24 @@ fi
 # always retarget it to $TARGET. Plugin updates leave old version
 # directories behind, so a valid pyproject.toml at the stale target is
 # not proof the link is fresh.
+CURRENT=""
 if [ -L "$LINK" ]; then
     # Literal target string, not realpath: we compare against what was written by ln -s.
     CURRENT="$(readlink "$LINK" 2>/dev/null || true)"
+elif claude_smart_is_windows && [ -e "$LINK" ] && [ -f "$HOME/.reflexio/plugin-root.txt" ]; then
+    # Windows junctions are not reported as symlinks by Git Bash, so use the
+    # metadata written alongside successful junction creation.
+    CURRENT="$(cat "$HOME/.reflexio/plugin-root.txt" 2>/dev/null || true)"
+elif claude_smart_is_windows && [ -e "$LINK" ]; then
+    echo "[claude-smart] ensure-plugin-root: $LINK is not a symlink and plugin-root.txt is missing; cannot determine whether the Windows plugin-root tracks the active plugin. Run ensure-plugin-root.sh with --force or delete the occupied path to recreate it." >&2
+fi
+if [ -n "$CURRENT" ]; then
     case "$CURRENT" in
         "$HOME/.claude/plugins/cache/"*|"$HOME/.codex/plugins/cache/"*)
             CURRENT_NORM="${CURRENT%/}"
             TARGET_NORM="${TARGET%/}"
             if [ "$CURRENT_NORM" != "$TARGET_NORM" ]; then
-                ln -sfn "$TARGET" "$LINK"
-                echo "[claude-smart] plugin-root → $TARGET (cache-tracking, was $CURRENT)" >&2
+                write_plugin_root_link "cache-tracking, was $CURRENT"
             fi
             exit 0
             ;;
@@ -75,5 +174,4 @@ if [ -f "$LINK/pyproject.toml" ]; then
     exit 0
 fi
 
-ln -sfn "$TARGET" "$LINK"
-echo "[claude-smart] plugin-root → $TARGET" >&2
+write_plugin_root_link ""

package/plugin/scripts/hook_entry.sh

@@ -44,10 +44,13 @@ claude_smart_source_login_path
 # Explicit fallback for the astral.sh installer's default paths, in case
 # the user's login-shell rc hasn't yet been re-sourced to pick them up.
 claude_smart_prepend_astral_bins
+BACKEND_PORT="${BACKEND_PORT:-8071}"
+export BACKEND_PORT
 claude_smart_source_reflexio_env
 
 PLUGIN_ROOT="$(cd "$HERE/.." && pwd)"
 claude_smart_reexec_stable_plugin_root_if_needed "$PLUGIN_ROOT" "hook_entry.sh" "$@"
+claude_smart_derive_reflexio_url_from_backend_port
 
 FAILURE_MARKER="$HOME/.claude-smart/install-failed"
 STATE_DIR="$HOME/.claude-smart"

package/plugin/scripts/opencode-claude-compat.js

@@ -193,7 +193,14 @@ function parseOpenCodeJson(stdout) {
       chunks.push(event.result);
     }
   }
-  return chunks.join("").trim();
+  return stripOuterMarkdownFence(chunks.join("").trim());
+}
+
+function stripOuterMarkdownFence(content) {
+  // OpenCode can wrap one-shot JSON in a whole-response markdown fence.
+  // Strip only that outer fence so streamed and one-shot output normalize alike.
+  const match = String(content || "").match(/^```[^\r\n]*\r?\n([\s\S]*?)\r?\n```[ \t]*$/);
+  return match ? match[1].trim() : content;
 }
 
 function timeoutMs() {