feat(desktop,core): proxy footer, session delete, and log UX improvements

Desktop adds a global proxy base URL bar, per-vendor ingress copy, model name
copy with click/double-click gestures, and session deletion from the sessions
detail view (0.2.9).

Core filters invalid-path noise from logs, deletes sessions via debug API,
fixes Claude probe fallback to stay on provider ingress paths, and bumps dev
build to 0.1.75 for local proxy detection.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: joohw

core/internal/buildinfo/buildinfo.go

@@ -4,7 +4,7 @@ import "strings"
 
 // Set at link time via -ldflags (see .goreleaser.yaml).
 var (
-	Version = "dev0.1.73"
+	Version = "dev0.1.75"
 	Commit  = "none"
 	Date    = "unknown"
 )

core/internal/proxy/calllog.go

@@ -190,6 +190,20 @@ func (s *CallLogStore) Clear() {
 	_ = clearCallLogDB(s.db)
 }
 
+// DeleteSession removes all call log rows for a grouped session key (kind-sessionId).
+func (s *CallLogStore) DeleteSession(sessionKey string) (int64, error) {
+	if s == nil || s.db == nil {
+		return 0, errors.New("call log store unavailable")
+	}
+	kind, sessionID, ok := parseCallLogSessionKey(sessionKey)
+	if !ok {
+		return 0, errors.New("invalid session key")
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return deleteCallLogsBySession(s.db, kind, sessionID)
+}
+
 func shouldRecordCallLog(path string) bool {
 	p := strings.TrimSpace(path)
 	if p == "" {
@@ -214,9 +228,9 @@ func isProbeMethod(method string) bool {
 }
 
 // shouldUseCallLog decides whether a request gets a full call-log trace.
-// GET/HEAD probes (connectivity checks, invalid paths) go to system logs instead.
+// Invalid ingress paths and GET/HEAD probes (except GET /v1/models) are excluded.
 func shouldUseCallLog(r *http.Request, ingress provider.Ingress, pathOK bool) bool {
-	if r == nil {
+	if r == nil || !pathOK {
 		return false
 	}
 	path := r.URL.EscapedPath()
@@ -229,7 +243,7 @@ func shouldUseCallLog(r *http.Request, ingress provider.Ingress, pathOK bool) bo
 	if !isProbeMethod(r.Method) {
 		return true
 	}
-	return pathOK && isModelsPath(ingress.PathSuffix)
+	return isModelsPath(ingress.PathSuffix)
 }
 
 func startRequestTraceIfNeeded(store *CallLogStore, r *http.Request, ingress provider.Ingress, pathOK bool) *requestTrace {
@@ -239,11 +253,24 @@ func startRequestTraceIfNeeded(store *CallLogStore, r *http.Request, ingress pro
 	return startRequestTrace(store, r)
 }
 
-func logProxyProbeIfNeeded(r *http.Request, trace *requestTrace, status int, detail string) {
-	if trace != nil || r == nil || !isProbeMethod(r.Method) {
+func logProxyProbeIfNeeded(r *http.Request, trace *requestTrace, pathOK bool, status int, detail string) {
+	if trace != nil || r == nil || pathOK {
+		return
+	}
+	if isHostLevelLegacyV1Path(inboundRequestPath(r)) {
+		return
+	}
+	if !isProbeMethod(r.Method) {
 		return
 	}
-	syslog.LogProxyProbe(r.Method, inboundRequestURL(r), status, detail)
+	syslog.LogProxyProbe(r.Method, inboundRequestPath(r), status, detail)
+}
+
+// isHostLevelLegacyV1Path matches bare /v1/... requests (no /{providerId} prefix).
+// Connectivity fallbacks used to hit these against the local proxy; they are not logged.
+func isHostLevelLegacyV1Path(path string) bool {
+	parts := strings.Split(strings.Trim(strings.TrimSpace(path), "/"), "/")
+	return len(parts) >= 2 && strings.EqualFold(parts[0], "v1")
 }
 
 type requestTrace struct {
@@ -278,7 +305,7 @@ func startRequestTrace(store *CallLogStore, r *http.Request) *requestTrace {
 	}
 }
 
-func inboundRequestURL(r *http.Request) string {
+func inboundRequestPath(r *http.Request) string {
 	if r == nil || r.URL == nil {
 		return ""
 	}
@@ -287,8 +314,16 @@ func inboundRequestURL(r *http.Request) string {
 		path = r.URL.Path
 	}
 	if r.URL.RawQuery != "" {
-		path = path + "?" + r.URL.RawQuery
+		return path + "?" + r.URL.RawQuery
+	}
+	return path
+}
+
+func inboundRequestURL(r *http.Request) string {
+	if r == nil || r.URL == nil {
+		return ""
 	}
+	path := inboundRequestPath(r)
 	host := strings.TrimSpace(r.Host)
 	if host == "" {
 		host = strings.TrimSpace(r.URL.Host)

core/internal/proxy/calllog_session.go

@@ -116,6 +116,29 @@ func callLogSessionKey(kind, sessionID string) string {
 	return k + "-" + id
 }
 
+var callLogSessionKindPrefixes = []string{"claudecode", "codex", "opencode", "test"}
+
+// parseCallLogSessionKey splits a UI session key (kind-sessionId) back into DB fields.
+func parseCallLogSessionKey(session string) (kind, sessionID string, ok bool) {
+	session = strings.TrimSpace(session)
+	if session == "" {
+		return "", "", false
+	}
+	lower := strings.ToLower(session)
+	for _, prefix := range callLogSessionKindPrefixes {
+		marker := prefix + "-"
+		if !strings.HasPrefix(lower, marker) {
+			continue
+		}
+		id := strings.TrimSpace(session[len(marker):])
+		if id == "" {
+			return "", "", false
+		}
+		return prefix, id, true
+	}
+	return "", "", false
+}
+
 func sanitizeSessionFilename(sessionID string) string {
 	id := strings.TrimSpace(sessionID)
 	if id == "" {

core/internal/proxy/calllog_session_test.go

@@ -178,6 +178,42 @@ func TestListCallLogSessions(t *testing.T) {
 	}
 }
 
+func TestParseCallLogSessionKey(t *testing.T) {
+	kind, id, ok := parseCallLogSessionKey("codex-019e64f8-2705-7e43-8413-d2d823f16f50")
+	if !ok || kind != "codex" || id != "019e64f8-2705-7e43-8413-d2d823f16f50" {
+		t.Fatalf("parse codex session = %q %q ok=%v", kind, id, ok)
+	}
+	if _, _, ok := parseCallLogSessionKey("invalid"); ok {
+		t.Fatal("expected invalid session key to fail")
+	}
+}
+
+func TestDeleteCallLogSession(t *testing.T) {
+	store := openTestCallLogStore(t)
+	store.Push(CallLogEntry{
+		Request: CallLogRequest{
+			Method: "POST",
+			URL:    "/codex/gpt-5.4/openai-responses/v1/responses",
+			Headers: map[string]string{
+				"Originator": "codex-tui",
+				"Session-Id": "sess-delete-me",
+			},
+		},
+	})
+	store.Push(CallLogEntry{Request: CallLogRequest{Method: "POST", URL: "/other"}})
+
+	deleted, err := store.DeleteSession("codex-sess-delete-me")
+	if err != nil || deleted != 1 {
+		t.Fatalf("DeleteSession() = %d, %v", deleted, err)
+	}
+	if entries := store.ListRecent(0); len(entries) != 1 {
+		t.Fatalf("expected 1 remaining entry, got %d", len(entries))
+	}
+	if sessions := store.ListSessions(0); len(sessions) != 0 {
+		t.Fatalf("expected no session groups, got %#v", sessions)
+	}
+}
+
 func TestClearCallLogDB(t *testing.T) {
 	store := openTestCallLogStore(t)
 	store.Push(CallLogEntry{Request: CallLogRequest{Method: "POST", URL: "/a"}})

core/internal/proxy/calllog_sqlite.go

@@ -311,6 +311,26 @@ func clearCallLogDB(db *sql.DB) error {
 	return nil
 }
 
+func deleteCallLogsBySession(db *sql.DB, kind, sessionID string) (int64, error) {
+	if db == nil {
+		return 0, errors.New("call log db is nil")
+	}
+	kind = strings.TrimSpace(strings.ToLower(kind))
+	sessionID = strings.TrimSpace(sessionID)
+	if kind == "" || sessionID == "" {
+		return 0, errors.New("session kind and id are required")
+	}
+	result, err := db.Exec(
+		`DELETE FROM call_logs WHERE session_kind = ? AND session_id = ?`,
+		kind,
+		sessionID,
+	)
+	if err != nil {
+		return 0, err
+	}
+	return result.RowsAffected()
+}
+
 func exportCallLogDB(db *sql.DB, w io.Writer) (int, error) {
 	if db == nil {
 		return 0, errors.New("call log db is nil")

core/internal/proxy/calllog_test.go

@@ -94,6 +94,27 @@ func TestShouldUseCallLogRoutesProbesToSystemLog(t *testing.T) {
 	if !shouldUseCallLog(post, ingress, ok) {
 		t.Fatal("POST messages should stay in call log")
 	}
+
+	invalidPost, _ := http.NewRequest(http.MethodPost, "http://127.0.0.1:27483/v1/messages", nil)
+	invalidIngress, invalidOK := provider.ParseProxyIngressPath(invalidPost.URL.Path)
+	if invalidOK {
+		t.Fatal("host-level /v1/messages must not parse as ingress")
+	}
+	if shouldUseCallLog(invalidPost, invalidIngress, invalidOK) {
+		t.Fatal("POST on invalid host-level /v1 path should skip call log")
+	}
+}
+
+func TestIsHostLevelLegacyV1Path(t *testing.T) {
+	if !isHostLevelLegacyV1Path("/v1/messages") {
+		t.Fatal("expected host-level /v1/messages")
+	}
+	if !isHostLevelLegacyV1Path("/v1/chat/completions") {
+		t.Fatal("expected host-level /v1/chat/completions")
+	}
+	if isHostLevelLegacyV1Path("/claude-code/v1/messages") {
+		t.Fatal("provider ingress path must not match host-level /v1")
+	}
 }
 
 func TestCallLogPreservesFullBody(t *testing.T) {

core/internal/proxy/server.go

@@ -183,6 +183,24 @@ func (s *Server) handleDebugCallLog(w http.ResponseWriter, r *http.Request) {
 			"sessions": s.CallLogs.ListSessions(100),
 		})
 	case http.MethodDelete:
+		sessionKey := strings.TrimSpace(r.URL.Query().Get("session"))
+		if sessionKey != "" {
+			deleted, err := s.CallLogs.DeleteSession(sessionKey)
+			if err != nil {
+				status := http.StatusInternalServerError
+				if strings.Contains(strings.ToLower(err.Error()), "invalid session") {
+					status = http.StatusBadRequest
+				}
+				writeJSON(w, status, map[string]string{"error": err.Error()})
+				return
+			}
+			writeJSON(w, http.StatusOK, map[string]any{
+				"ok":      "deleted",
+				"deleted": deleted,
+				"session": sessionKey,
+			})
+			return
+		}
 		s.CallLogs.Clear()
 		writeJSON(w, http.StatusOK, map[string]string{"ok": "cleared"})
 	default:
@@ -465,7 +483,7 @@ func (s *Server) handleProxy(w http.ResponseWriter, r *http.Request) {
 	trace.setRequestBody(payload)
 	if bodyErr != nil {
 		trace.setError("read request body")
-		logProxyProbeIfNeeded(r, trace, http.StatusBadRequest, "read request body")
+		logProxyProbeIfNeeded(r, trace, pathOK, http.StatusBadRequest, "read request body")
 		writeJSON(w, http.StatusBadRequest, map[string]string{"error": "read request body"})
 		return
 	}
@@ -474,7 +492,7 @@ func (s *Server) handleProxy(w http.ResponseWriter, r *http.Request) {
 	if !pathOK {
 		msg := "invalid path; use /{providerId}/v1/messages, /{providerId}/v1/responses, or /{providerId}/v1/chat/completions"
 		trace.setError(msg)
-		logProxyProbeIfNeeded(r, trace, http.StatusNotFound, msg)
+		logProxyProbeIfNeeded(r, trace, pathOK, http.StatusNotFound, msg)
 		writeJSON(w, http.StatusNotFound, map[string]string{"error": msg})
 		return
 	}
@@ -494,7 +512,7 @@ func (s *Server) handleProxy(w http.ResponseWriter, r *http.Request) {
 	if !shouldTransformProxyMethod(r.Method) {
 		msg := "method not supported for proxy route"
 		trace.setError(msg)
-		logProxyProbeIfNeeded(r, trace, http.StatusMethodNotAllowed, msg)
+		logProxyProbeIfNeeded(r, trace, pathOK, http.StatusMethodNotAllowed, msg)
 		writeJSON(w, http.StatusMethodNotAllowed, map[string]string{"error": msg})
 		return
 	}

core/internal/testclient/testclient.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"net/url"
 	"strings"
 	"time"
 
@@ -86,7 +85,7 @@ func ProbeToolRoundTrip(openAIResponsesBaseURL, claudeMessagesBaseURL, apiKey, m
 	return nil
 }
 
-// probeClaudeWithFallback tries Anthropic Messages on base, then OpenAI chat on the same origin when Messages is 404.
+// probeClaudeWithFallback tries Anthropic Messages on base, then OpenAI chat on the same base when Messages is 404.
 func probeClaudeWithFallback(base, apiKey, model string) error {
 	mErr := probeAnthropicMessagesPOST(base, apiKey, model)
 	if mErr == nil {
@@ -95,12 +94,7 @@ func probeClaudeWithFallback(base, apiKey, model string) error {
 	if !errors.Is(mErr, errAnthropicMessagesNotFound) {
 		return mErr
 	}
-	u, perr := url.Parse(base)
-	if perr != nil || u.Host == "" {
-		return mErr
-	}
-	origin := u.Scheme + "://" + u.Host
-	return probeOpenAIChatPOST(origin, apiKey, model)
+	return probeOpenAIChatPOST(base, apiKey, model)
 }
 
 func probeAnthropicMessagesPOST(base, apiKey, model string) error {

core/internal/testclient/testclient_test.go

@@ -201,7 +201,7 @@ func TestProbeClaudeFallbackWhenMessages404(t *testing.T) {
 				return
 			}
 			http.NotFound(w, r)
-		case "/v1/chat/completions":
+		case "/anthropic/v1/chat/completions":
 			if r.Method != http.MethodPost || r.Header.Get("Authorization") != "Bearer sk-test" {
 				w.WriteHeader(http.StatusUnauthorized)
 				return

electron/call-logs-store.js

@@ -156,6 +156,18 @@ async function clearProxyDebugLogs(scope = "all", options = {}) {
   }
 }
 
+async function deleteCallLogSessionViaHTTP(session, options = {}) {
+  const key = String(session || "").trim();
+  if (!key) {
+    throw new Error("session is required");
+  }
+  return fetchProxyDebugJSON(
+    "/__debug/call-log",
+    { session: key },
+    { method: "DELETE", proxy: options.proxy },
+  );
+}
+
 module.exports = {
   logsDir,
   callLogsDBPath,
@@ -169,4 +181,5 @@ module.exports = {
   readSystemLogsViaHTTP,
   clearSystemLogsViaCLI,
   clearProxyDebugLogs,
+  deleteCallLogSessionViaHTTP,
 };