Simplify: remove TTL/expiry, keep session alive while bridge connected

- Remove SESSION_TTL and expiresAt — session stays alive as long
  as bridge is connected (heartbeat updates lastActivity)
- Remove file upload/download API and WebSocket protocol
- Remove file_read/file_write from bridge
- Show connect URL (https://connectyouragent.com/c/CODE) in bridge
  terminal output
- Simplify frontend: remove expiry display, just show connected/waiting
- Clean up tests: remove file/expiry tests that no longer apply
- Keep heartbeat/pong for connection health detection

Author: bgwastu

bridge/main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"bytes"
-	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -27,7 +26,6 @@ const (
 	reconnectBaseDelay = 1 * time.Second
 	reconnectMaxDelay  = 30 * time.Second
 	pongWait           = 60 * time.Second
-	maxFileSize        = 50 * 1024 * 1024
 )
 
 var sessionCodePattern = regexp.MustCompile(`^[0-9a-f]{12}$`)
@@ -84,6 +82,12 @@ func main() {
 		fatal("Usage: cya-bridge <session code>")
 	}
 
+	// Derive HTTP base URL from WebSocket URL for the connect link
+	baseURL := strings.Replace(wsURL, "ws://", "http://", 1)
+	baseURL = strings.Replace(baseURL, "wss://", "https://", 1)
+	baseURL = strings.TrimSuffix(baseURL, "/ws")
+	connectURL := baseURL + "/c/" + code
+
 	quit := make(chan struct{})
 	sig := make(chan os.Signal, 1)
 	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
@@ -105,7 +109,7 @@ func main() {
 		default:
 		}
 
-		_, reconnect := dialAndRun(wsURL, code, quit)
+		_, reconnect := dialAndRun(wsURL, code, connectURL, quit)
 		if !reconnect {
 			return
 		}
@@ -311,134 +315,14 @@ func readCommands(wsc *wsConn, dot string) bool {
 				"exit_code": code,
 				"truncated": truncated,
 			})
-		case "file_read":
-			var msg struct {
-				ID       string `json:"id"`
-				Path     string `json:"path"`
-				Encoding string `json:"encoding"`
-			}
-			_ = json.Unmarshal(data, &msg)
-			if msg.ID == "" {
-				continue
-			}
-			handleFileRead(wsc, msg.ID, msg.Path)
-		case "file_write":
-			var msg struct {
-				ID       string `json:"id"`
-				Path     string `json:"path"`
-				Data     string `json:"data"`
-				Encoding string `json:"encoding"`
-			}
-			_ = json.Unmarshal(data, &msg)
-			if msg.ID == "" {
-				continue
-			}
-			handleFileWrite(wsc, msg.ID, msg.Path, msg.Data, msg.Encoding)
 		case "bye":
 			wsc.close()
 			return false
 		}
 	}
 }
 
-func handleFileRead(wsc *wsConn, id, path string) {
-	printLine(ansiCyan+"📖"+ansiReset, " ", ansiBold, "File read:", ansiReset, " ", path)
-	data, size, err := readFile(path)
-	if err != nil {
-		wsc.sendJSON(map[string]any{
-			"type":    "file_read_result",
-			"id":      id,
-			"path":    path,
-			"error":   err.Error(),
-			"size":    0,
-			"data":    "",
-			"encoding": "base64",
-		})
-		return
-	}
-	wsc.sendJSON(map[string]any{
-		"type":     "file_read_result",
-		"id":       id,
-		"path":     path,
-		"data":     data,
-		"size":     size,
-		"encoding": "base64",
-	})
-}
-
-func handleFileWrite(wsc *wsConn, id, path, data, encoding string) {
-	printLine(ansiCyan+"📝"+ansiReset, " ", ansiBold, "File write:", ansiReset, " ", path)
-	bytesWritten, err := writeFile(path, data, encoding)
-	if err != nil {
-		wsc.sendJSON(map[string]any{
-			"type":         "file_write_result",
-			"id":           id,
-			"path":         path,
-			"error":        err.Error(),
-			"bytes_written": 0,
-		})
-		return
-	}
-	wsc.sendJSON(map[string]any{
-		"type":          "file_write_result",
-		"id":            id,
-		"path":          path,
-		"bytes_written": bytesWritten,
-	})
-}
-
-func readFile(path string) (string, int64, error) {
-	fi, err := os.Stat(path)
-	if err != nil {
-		return "", 0, fmt.Errorf("cannot access %s: %w", path, err)
-	}
-	if fi.Size() > maxFileSize {
-		return "", 0, fmt.Errorf("file too large: %d bytes (max %d)", fi.Size(), maxFileSize)
-	}
-
-	f, err := os.Open(path)
-	if err != nil {
-		return "", 0, fmt.Errorf("cannot open %s: %w", path, err)
-	}
-	defer f.Close()
-
-	data, err := io.ReadAll(f)
-	if err != nil {
-		return "", 0, fmt.Errorf("cannot read %s: %w", path, err)
-	}
-
-	encoded := base64.StdEncoding.EncodeToString(data)
-	return encoded, fi.Size(), nil
-}
-
-func writeFile(path, data, encoding string) (int, error) {
-	var raw []byte
-	switch encoding {
-	case "base64", "":
-		var err error
-		raw, err = base64.StdEncoding.DecodeString(data)
-		if err != nil {
-			// Try base64url
-			raw, err = base64.URLEncoding.DecodeString(data)
-			if err != nil {
-				return 0, fmt.Errorf("invalid base64 data: %w", err)
-			}
-		}
-	default:
-		return 0, fmt.Errorf("unsupported encoding: %s", encoding)
-	}
-
-	if len(raw) > maxFileSize {
-		return 0, fmt.Errorf("data too large: %d bytes (max %d)", len(raw), maxFileSize)
-	}
-
-	if err := os.WriteFile(path, raw, 0644); err != nil {
-		return 0, fmt.Errorf("cannot write %s: %w", path, err)
-	}
-	return len(raw), nil
-}
-
-func dialAndRun(wsURL, code string, quit <-chan struct{}) (string, bool) {
+func dialAndRun(wsURL, code, connectURL string, quit <-chan struct{}) (string, bool) {
 	dialer := websocket.Dialer{HandshakeTimeout: 15 * time.Second}
 	conn, resp, err := dialer.Dial(wsURL, http.Header{})
 	if err != nil {
@@ -459,6 +343,7 @@ func dialAndRun(wsURL, code string, quit <-chan struct{}) (string, bool) {
 	setCurrentBridge(bridge)
 
 	dot := ansiCyan + "●" + ansiReset
+	printLine(dot, " ", connectURL, ansiReset)
 	printLine(dot, " ", ansiBold, code, ansiReset, "  —  Ctrl+C to disconnect")
 
 	// Set up heartbeat: expect pong within pongWait