fix: address PR #429 review findings and security hardening

F1: Gate approvals/watcher/input keys to table view only by
    restructuring keyMsgHandler — move per-mode dispatch above
    approvals routing so A/W/: keys don't fire in incident/log/docs
    views or under the approvals overlay.

F2: Fix setext heading corruption by rendering watcher buffer entries
    individually through glamour then joining with Unicode separator
    (───) instead of rendering the full buffer joined with \n---\n.

F3: Remove agent result double-rendering — store raw text in the
    watcher buffer and let updateWatcherViewport handle the single
    glamour render pass.

F4: Sanitize IncidentTitle with stripControl() in buildAskFromVerdict
    to prevent terminal injection from attacker-influenced PD data.

F5: Clamp approvals pane content to WatcherHeight lines so long
    approval bodies don't overflow the terminal.

F6: Cache the glamour TermRenderer on the model keyed by viewport
    width, avoiding per-token renderer recreation during streaming.

SEC-001: Apply url.PathEscape to clusterID and reportID in backplane
         client URL construction to prevent path traversal.

SEC-002: Reject non-localhost HTTP endpoints when an API key is set
         in the OpenAI-compatible provider to prevent credential
         leakage over plaintext.

SEC-003: Add .gitignore patterns for .env, *.pem, *.key, credentials,
         and secrets files.

SEC-004b: Sanitize all PagerDuty data (incident titles, service names,
          note content, alert fields, team/assignee summaries) with
          stripControl() at the summarize boundary and table row
          construction to prevent terminal injection.

Also removes dead code: prefixLines function (replaced by
prefixMessage), duplicate input.Focused() case in key handler switch.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: clcollins

.gitignore

@@ -16,3 +16,11 @@ coverage.out
 
 # Claude Code local settings (personal permissions, not committed)
 .claude/settings.local.json
+
+# Sensitive files
+.env
+.env.*
+*.pem
+*.key
+credentials.*
+secrets.*

pkg/ai/http_safety_test.go

@@ -0,0 +1,66 @@
+package ai
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewOpenAICompatProvider_RejectsHTTPWithAPIKey(t *testing.T) {
+	_, err := newOpenAICompatProvider(Config{
+		Endpoint: "http://remote-server.example.com:8080",
+		Model:    "gpt-4",
+	}, "sk-secret-key")
+
+	require.Error(t, err,
+		"must reject non-localhost http:// endpoint when API key is set")
+	assert.Contains(t, err.Error(), "HTTPS",
+		"error message should mention HTTPS requirement")
+}
+
+func TestNewOpenAICompatProvider_AllowsHTTPLocalhost(t *testing.T) {
+	tests := []struct {
+		name     string
+		endpoint string
+	}{
+		{"localhost", "http://localhost:8080"},
+		{"127.0.0.1", "http://127.0.0.1:11434"},
+		{"[::1]", "http://[::1]:8080"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			provider, err := newOpenAICompatProvider(Config{
+				Endpoint: tt.endpoint,
+				Model:    "m",
+			}, "sk-secret-key")
+
+			assert.NoError(t, err,
+				"localhost http:// with API key should be allowed")
+			assert.NotNil(t, provider)
+		})
+	}
+}
+
+func TestNewOpenAICompatProvider_AllowsHTTPSWithAPIKey(t *testing.T) {
+	provider, err := newOpenAICompatProvider(Config{
+		Endpoint: "https://api.openai.com",
+		Model:    "gpt-4",
+	}, "sk-secret-key")
+
+	assert.NoError(t, err,
+		"https:// endpoint with API key should be allowed")
+	assert.NotNil(t, provider)
+}
+
+func TestNewOpenAICompatProvider_AllowsHTTPWithoutAPIKey(t *testing.T) {
+	provider, err := newOpenAICompatProvider(Config{
+		Endpoint: "http://remote-server.example.com:8080",
+		Model:    "llama",
+	}, "")
+
+	assert.NoError(t, err,
+		"http:// without API key should be allowed (e.g., ollama)")
+	assert.NotNil(t, provider)
+}

pkg/ai/openai_compat.go

@@ -7,12 +7,27 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"net/url"
 	"strings"
 	"time"
 
 	"github.com/charmbracelet/log"
 )
 
+func validateEndpointSecurity(endpoint string) error {
+	parsed, err := url.Parse(endpoint)
+	if err != nil {
+		return fmt.Errorf("openai: invalid endpoint URL: %w", err)
+	}
+	if parsed.Scheme == "http" {
+		host := parsed.Hostname()
+		if host != "localhost" && host != "127.0.0.1" && host != "::1" {
+			return fmt.Errorf("openai: refusing to send API key over HTTP to non-localhost host %q; use HTTPS for remote endpoints", host)
+		}
+	}
+	return nil
+}
+
 type openaiCompatProvider struct {
 	endpoint       string
 	model          string
@@ -26,6 +41,12 @@ func newOpenAICompatProvider(cfg Config, apiKey string) (*openaiCompatProvider,
 		return nil, fmt.Errorf("openai: endpoint is required")
 	}
 
+	if apiKey != "" {
+		if err := validateEndpointSecurity(cfg.Endpoint); err != nil {
+			return nil, err
+		}
+	}
+
 	return &openaiCompatProvider{
 		endpoint:       strings.TrimRight(cfg.Endpoint, "/"),
 		model:          cfg.Model,

pkg/backplane/client.go

@@ -60,7 +60,7 @@ func NewClient(cfg *Config, tokenFunc func() (string, error)) BackplaneClient {
 }
 
 func (c *Client) ListReports(ctx context.Context, clusterID string) ([]ReportSummary, error) {
-	endpoint := fmt.Sprintf("%s/backplane/cluster/%s/reports?last=10", c.config.URL, clusterID)
+	endpoint := fmt.Sprintf("%s/backplane/cluster/%s/reports?last=10", c.config.URL, url.PathEscape(clusterID))
 	log.Debug("backplane.ListReports", "cluster_id", clusterID)
 
 	body, err := c.doRequest(ctx, endpoint)
@@ -80,7 +80,7 @@ func (c *Client) ListReports(ctx context.Context, clusterID string) ([]ReportSum
 }
 
 func (c *Client) GetReport(ctx context.Context, clusterID, reportID string) (*Report, error) {
-	endpoint := fmt.Sprintf("%s/backplane/cluster/%s/reports/%s", c.config.URL, clusterID, reportID)
+	endpoint := fmt.Sprintf("%s/backplane/cluster/%s/reports/%s", c.config.URL, url.PathEscape(clusterID), url.PathEscape(reportID))
 	log.Debug("backplane.GetReport", "cluster_id", clusterID, "report_id", reportID)
 
 	body, err := c.doRequest(ctx, endpoint)

pkg/backplane/path_escape_test.go

@@ -0,0 +1,69 @@
+package backplane
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestClient_ListReports_PathEscapesClusterID(t *testing.T) {
+	var receivedPath string
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		receivedPath = r.URL.EscapedPath()
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(listReportsResponse{Reports: []ReportSummary{}})
+	}))
+	defer server.Close()
+
+	cfg := &Config{URL: server.URL}
+	client := NewClient(cfg, func() (string, error) { return "test-token", nil })
+
+	_, err := client.ListReports(context.Background(), "../../admin/endpoint")
+	require.NoError(t, err)
+
+	assert.Equal(t, "/backplane/cluster/..%2F..%2Fadmin%2Fendpoint/reports", receivedPath,
+		"clusterID with path traversal must be URL-escaped in the request path")
+}
+
+func TestClient_GetReport_PathEscapesClusterIDAndReportID(t *testing.T) {
+	var receivedPath string
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		receivedPath = r.URL.EscapedPath()
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(Report{ReportID: "rpt-1"})
+	}))
+	defer server.Close()
+
+	cfg := &Config{URL: server.URL}
+	client := NewClient(cfg, func() (string, error) { return "test-token", nil })
+
+	_, err := client.GetReport(context.Background(), "../admin", "../../secret")
+	require.NoError(t, err)
+
+	assert.Equal(t, "/backplane/cluster/..%2Fadmin/reports/..%2F..%2Fsecret", receivedPath,
+		"both clusterID and reportID with path traversal must be URL-escaped")
+}
+
+func TestClient_ListReports_NormalClusterIDUnchanged(t *testing.T) {
+	var receivedPath string
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		receivedPath = r.URL.Path
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(listReportsResponse{Reports: []ReportSummary{}})
+	}))
+	defer server.Close()
+
+	cfg := &Config{URL: server.URL}
+	client := NewClient(cfg, func() (string, error) { return "test-token", nil })
+
+	_, err := client.ListReports(context.Background(), "abc-123-def")
+	require.NoError(t, err)
+
+	assert.Equal(t, "/backplane/cluster/abc-123-def/reports", receivedPath,
+		"normal clusterID should pass through unchanged")
+}

pkg/tui/claude.go

@@ -279,15 +279,7 @@ func (m model) handleAgentSessionEvent(msg agentSessionEventMsg) (tea.Model, tea
 				return errMsg{fmt.Errorf("agent error: %s", ev.Text)}
 			}
 		}
-		// Render final result through glamour if available
-		if ev.Text != "" && m.markdownRenderer != nil {
-			rendered, err := m.markdownRenderer.Render(ev.Text)
-			if err == nil {
-				m.watcherBuffer.SetLast(prefixMessage(m.agentMarker, strings.TrimSpace(rendered)))
-			} else {
-				m.watcherBuffer.SetLast(prefixMessage(m.agentMarker, ev.Text))
-			}
-		} else if ev.Text != "" {
+		if ev.Text != "" {
 			m.watcherBuffer.SetLast(prefixMessage(m.agentMarker, ev.Text))
 		}
 		m.updateWatcherViewport()