fix(session): keep read-surface cutover scoped

Author: LichKing-2234

ae-cli/cmd/hook.go

@@ -3,9 +3,11 @@ package cmd
 import (
 	"context"
 	"os"
+	"time"
 
 	"github.com/ai-efficiency/ae-cli/internal/attributionlocal"
 	"github.com/ai-efficiency/ae-cli/internal/hooks"
+	"github.com/ai-efficiency/ae-cli/internal/proxy"
 	"github.com/spf13/cobra"
 )
 
@@ -47,6 +49,30 @@ var hookPostRewriteCmd = &cobra.Command{
 	},
 }
 
+var hookSessionEventCmd = &cobra.Command{
+	Use:    "session-event",
+	Short:  "Forward tool hook events to the local proxy (hidden)",
+	Hidden: true,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		tool, err := cmd.Flags().GetString("tool")
+		if err != nil {
+			return err
+		}
+		err = proxy.ForwardHookEvent(context.Background(), os.Stdin, proxy.HookForwardRequest{
+			Tool:            tool,
+			LocalProxyURL:   os.Getenv("AE_LOCAL_PROXY_URL"),
+			LocalProxyToken: os.Getenv("AE_LOCAL_PROXY_TOKEN"),
+			SessionID:       os.Getenv("AE_SESSION_ID"),
+			WorkspaceID:     os.Getenv("AE_WORKSPACE_ID"),
+			CapturedAt:      time.Now().UTC(),
+		})
+		if err != nil {
+			return nil
+		}
+		return nil
+	},
+}
+
 var hookAttributionSyncCmd = &cobra.Command{
 	Use:    "attribution-sync",
 	Short:  "Run local attribution sync (hidden)",
@@ -61,6 +87,8 @@ var hookAttributionSyncCmd = &cobra.Command{
 func init() {
 	hookCmd.AddCommand(hookPostCommitCmd)
 	hookCmd.AddCommand(hookPostRewriteCmd)
+	hookSessionEventCmd.Flags().String("tool", "", "originating tool name")
+	hookCmd.AddCommand(hookSessionEventCmd)
 	hookCmd.AddCommand(hookAttributionSyncCmd)
 	rootCmd.AddCommand(hookCmd)
 }

ae-cli/cmd/hook_test.go

@@ -23,6 +23,21 @@ func TestHookCommandHasPostRewriteSubcommand(t *testing.T) {
 	}
 }
 
+func TestHookCommandHasSessionEventSubcommand(t *testing.T) {
+	var found bool
+	for _, c := range hookCmd.Commands() {
+		if c.Name() == "session-event" {
+			found = true
+			if !c.Hidden {
+				t.Fatalf("expected hook session-event to be hidden")
+			}
+		}
+	}
+	if !found {
+		t.Fatalf("expected hidden subcommand 'ae-cli hook session-event' to exist")
+	}
+}
+
 func TestHookPostCommitCommandQueuesWhenUploaderUnsupported(t *testing.T) {
 	repo := initRepoWithCommitForCmdTests(t)
 

ae-cli/internal/hooks/handler.go

@@ -16,6 +16,7 @@ import (
 
 	"github.com/ai-efficiency/ae-cli/internal/attributionlocal"
 	"github.com/ai-efficiency/ae-cli/internal/collector"
+	"github.com/ai-efficiency/ae-cli/internal/proxy"
 	"github.com/ai-efficiency/ae-cli/internal/session"
 )
 
@@ -235,6 +236,16 @@ func (h *Handler) PostCommit(ctx context.Context, cwd string) error {
 		CapturedAt:     time.Now().UTC().Format(time.RFC3339),
 	}
 
+	if rt, err := session.ReadRuntimeBundle(sessionID); err == nil && rt != nil && rt.Proxy != nil {
+		if err := proxy.PostEvent(ctx, rt.Proxy.ListenAddr, rt.Proxy.AuthToken, proxy.EventEnvelope{
+			EventType: "post_commit",
+			SessionID: sessionID,
+			Payload:   ev,
+		}); err == nil {
+			return nil
+		}
+	}
+
 	if h == nil || h.uploader == nil {
 		// No uploader wired; behave like upload failure (queue best-effort).
 		q, err := NewLocalQueue(sessionID)
@@ -355,6 +366,16 @@ func (h *Handler) PostRewrite(ctx context.Context, cwd string, rewriteType strin
 			CapturedAt:    time.Now().UTC().Format(time.RFC3339),
 		}
 
+		if rt, err := session.ReadRuntimeBundle(sessionID); err == nil && rt != nil && rt.Proxy != nil {
+			if err := proxy.PostEvent(ctx, rt.Proxy.ListenAddr, rt.Proxy.AuthToken, proxy.EventEnvelope{
+				EventType: "post_rewrite",
+				SessionID: sessionID,
+				Payload:   ev,
+			}); err == nil {
+				continue
+			}
+		}
+
 		if h == nil || h.uploader == nil {
 			if q != nil {
 				_ = q.Enqueue(ev)

ae-cli/internal/hooks/handler_test.go

@@ -1,6 +1,7 @@
 package hooks
 
 import (
+	"bufio"
 	"bytes"
 	"context"
 	"encoding/json"
@@ -12,6 +13,7 @@ import (
 	"testing"
 
 	"github.com/ai-efficiency/ae-cli/internal/collector"
+	"github.com/ai-efficiency/ae-cli/internal/proxy"
 	"github.com/ai-efficiency/ae-cli/internal/session"
 )
 
@@ -29,13 +31,81 @@ func (f *fakeUploader) UploadHookEvent(ctx context.Context, ev HookEvent) error
 	return f.err
 }
 
+func startRealProxy(t *testing.T, sessionID string) (listenAddr, authToken string) {
+	t.Helper()
+
+	cfg := proxy.RuntimeConfig{
+		SessionID:  sessionID,
+		ListenAddr: "127.0.0.1:0",
+		AuthToken:  "proxy-token",
+	}
+	result, err := proxy.Spawn(cfg)
+	if err != nil {
+		t.Fatalf("proxy.Spawn: %v", err)
+	}
+	t.Cleanup(func() {
+		if err := proxy.Stop(proxy.StopRequest{
+			PID:        result.PID,
+			ListenAddr: result.ListenAddr,
+			AuthToken:  cfg.AuthToken,
+			ConfigPath: result.ConfigPath,
+		}); err != nil {
+			t.Fatalf("proxy.Stop: %v", err)
+		}
+	})
+
+	return result.ListenAddr, cfg.AuthToken
+}
+
+func writeRuntimeWithProxy(t *testing.T, sessionID, listenAddr, authToken string) {
+	t.Helper()
+	if err := session.WriteRuntimeBundle(&session.RuntimeBundle{
+		SessionID: sessionID,
+		Proxy: &session.ProxyRuntime{
+			ListenAddr: listenAddr,
+			AuthToken:  authToken,
+		},
+	}); err != nil {
+		t.Fatalf("WriteRuntimeBundle: %v", err)
+	}
+}
+
 func writeMarker(t *testing.T, repo, sessionID string) {
 	t.Helper()
 	if err := session.WriteMarker(repo, &session.Marker{SessionID: sessionID, RepoFullName: "origin"}); err != nil {
 		t.Fatalf("WriteMarker: %v", err)
 	}
 }
 
+func readProxySpoolEvents(t *testing.T, sessionID string) []proxy.EventEnvelope {
+	t.Helper()
+
+	path := proxy.EventSpoolPath(sessionID)
+	f, err := os.Open(path)
+	if err != nil {
+		t.Fatalf("open proxy spool: %v", err)
+	}
+	defer f.Close()
+
+	var out []proxy.EventEnvelope
+	sc := bufio.NewScanner(f)
+	for sc.Scan() {
+		line := strings.TrimSpace(sc.Text())
+		if line == "" {
+			continue
+		}
+		var ev proxy.EventEnvelope
+		if err := json.Unmarshal([]byte(line), &ev); err != nil {
+			t.Fatalf("unmarshal proxy spool line: %v", err)
+		}
+		out = append(out, ev)
+	}
+	if err := sc.Err(); err != nil {
+		t.Fatalf("scan proxy spool: %v", err)
+	}
+	return out
+}
+
 func git2(t *testing.T, dir string, args ...string) string {
 	t.Helper()
 	cmd := exec.Command("git", args...)
@@ -133,6 +203,128 @@ func TestPostCommitBootstrapsMarkerFromEnv(t *testing.T) {
 	}
 }
 
+func TestPostCommitSendsEventToLocalProxyBeforeQueueFallback(t *testing.T) {
+	repo := initRepoWithCommit2(t)
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+
+	listenAddr, authToken := startRealProxy(t, "sess-1")
+	writeRuntimeWithProxy(t, "sess-1", listenAddr, authToken)
+	writeMarker(t, repo, "sess-1")
+
+	h := NewHandler(nil)
+	if err := h.PostCommit(context.Background(), repo); err != nil {
+		t.Fatalf("PostCommit: %v", err)
+	}
+
+	q, err := NewLocalQueue("sess-1")
+	if err != nil {
+		t.Fatalf("NewLocalQueue: %v", err)
+	}
+	items, err := q.List()
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+	if len(items) != 0 {
+		t.Fatalf("queued items = %d, want 0 (expected local proxy ingress to accept event)", len(items))
+	}
+
+	events := readProxySpoolEvents(t, "sess-1")
+	if len(events) != 1 {
+		t.Fatalf("proxy spool events = %d, want 1", len(events))
+	}
+	if got := events[0].EventType; got != "post_commit" {
+		t.Fatalf("event_type = %q, want %q", got, "post_commit")
+	}
+	if got := events[0].SessionID; got != "sess-1" {
+		t.Fatalf("session_id = %q, want %q", got, "sess-1")
+	}
+}
+
+func TestPostCommitFallsBackToQueueWhenProxyTokenInvalid(t *testing.T) {
+	repo := initRepoWithCommit2(t)
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+
+	listenAddr, _ := startRealProxy(t, "sess-1")
+	writeRuntimeWithProxy(t, "sess-1", listenAddr, "wrong-token")
+	writeMarker(t, repo, "sess-1")
+
+	h := NewHandler(nil)
+	if err := h.PostCommit(context.Background(), repo); err != nil {
+		t.Fatalf("PostCommit: %v", err)
+	}
+
+	q, err := NewLocalQueue("sess-1")
+	if err != nil {
+		t.Fatalf("NewLocalQueue: %v", err)
+	}
+	items, err := q.List()
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+	if len(items) != 1 {
+		t.Fatalf("queued items = %d, want 1", len(items))
+	}
+}
+
+func TestPostRewriteSendsEventToLocalProxyBeforeQueueFallback(t *testing.T) {
+	repo := initRepoWithCommit2(t)
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+
+	listenAddr, authToken := startRealProxy(t, "sess-1")
+	writeRuntimeWithProxy(t, "sess-1", listenAddr, authToken)
+	writeMarker(t, repo, "sess-1")
+
+	h := NewHandler(nil)
+	if err := h.PostRewrite(context.Background(), repo, "amend", strings.NewReader("oldsha1 newsha1\n")); err != nil {
+		t.Fatalf("PostRewrite: %v", err)
+	}
+
+	q, err := NewLocalQueue("sess-1")
+	if err != nil {
+		t.Fatalf("NewLocalQueue: %v", err)
+	}
+	items, err := q.List()
+	if err != nil {
+		t.Fatalf("List: %v", err)
+	}
+	if len(items) != 0 {
+		t.Fatalf("queued items = %d, want 0 (expected local proxy ingress to accept event)", len(items))
+	}
+
+	events := readProxySpoolEvents(t, "sess-1")
+	if len(events) != 1 {
+		t.Fatalf("proxy spool events = %d, want 1", len(events))
+	}
+	if got := events[0].EventType; got != "post_rewrite" {
+		t.Fatalf("event_type = %q, want %q", got, "post_rewrite")
+	}
+}
+
+func TestProxyIngressStampsSessionID(t *testing.T) {
+	home := t.TempDir()
+	t.Setenv("HOME", home)
+
+	listenAddr, authToken := startRealProxy(t, "sess-1")
+	if err := proxy.PostEvent(context.Background(), listenAddr, authToken, proxy.EventEnvelope{
+		EventType: "post_commit",
+		SessionID: "different-session",
+		Payload:   map[string]any{"x": "y"},
+	}); err != nil {
+		t.Fatalf("PostEvent: %v", err)
+	}
+
+	events := readProxySpoolEvents(t, "sess-1")
+	if len(events) != 1 {
+		t.Fatalf("proxy spool events = %d, want 1", len(events))
+	}
+	if got := events[0].SessionID; got != "sess-1" {
+		t.Fatalf("session_id = %q, want proxy session %q", got, "sess-1")
+	}
+}
+
 func TestPostCommitQueuesEventWhenUploadFails(t *testing.T) {
 	repo := initRepoWithCommit2(t)
 

backend/internal/handler/router.go

@@ -162,6 +162,9 @@ func SetupRouter(
 	// Sessions (ae-cli)
 	sessionGroup := protected.Group("/sessions")
 	{
+		sessionGroup.GET("", sessionHandler.List)
+		sessionGroup.GET("/:id", sessionHandler.Get)
+		sessionGroup.GET("/:id/provider-credentials", sessionHandler.ProviderCredential)
 		sessionGroup.POST("/bootstrap", sessionHandler.Bootstrap)
 		sessionGroup.POST("", sessionHandler.Create)
 		sessionGroup.PUT("/:id", sessionHandler.Update)