NOMERGE 6.6.2 hotfix

Jenkinsfile

@@ -203,6 +203,7 @@ helpers.rootLinuxNode(env, {
                   sh "go install mvdan.cc/gofumpt"
                 }
                 dir ('protocol') {
+                  sh "yarn cache clean avdl-compiler"
                   sh "yarn --frozen-lockfile"
                   sh "make clean"
                   sh "make"

go/bind/keybase.go

@@ -59,13 +59,29 @@ var (
 	connMutex   sync.Mutex // Protects conn operations
 )
 
-// log writes to kbCtx.Log if available, otherwise falls back to fmt.Printf
+func describeConn(c net.Conn) string {
+	if c == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("%T@%p", c, c)
+}
+
+func appStateForLog() string {
+	if kbCtx == nil || kbCtx.MobileAppState == nil {
+		return "<unknown>"
+	}
+	return fmt.Sprintf("%v", kbCtx.MobileAppState.State())
+}
+
+// log writes to kbCtx.Log if available, otherwise falls back to stderr.
+// Stderr is captured in crash logs and the Xcode console, making early Init
+// messages (before kbCtx.Log is set up by Configure) visible in diagnostics.
 func log(format string, args ...interface{}) {
 	msg := fmt.Sprintf(format, args...)
 	if kbCtx != nil && kbCtx.Log != nil {
 		kbCtx.Log.Info(msg)
 	} else {
-		fmt.Printf("%s\n", msg)
+		fmt.Fprintf(os.Stderr, "keybase: %s\n", msg)
 	}
 }
 
@@ -469,9 +485,13 @@ func WriteArr(b []byte) (err error) {
 
 	n, err := currentConn.Write(bytes)
 	if err != nil {
+		log("Go: WriteArr error conn=%s len=%d appState=%s err=%v",
+			describeConn(currentConn), len(bytes), appStateForLog(), err)
 		return fmt.Errorf("Write error: %s", err)
 	}
 	if n != len(bytes) {
+		log("Go: WriteArr short write conn=%s wrote=%d expected=%d appState=%s",
+			describeConn(currentConn), n, len(bytes), appStateForLog())
 		return errors.New("Did not write all the data")
 	}
 	return nil
@@ -525,18 +545,37 @@ func ReadArr() (data []byte, err error) {
 // Must be called with connMutex held.
 func ensureConnection() error {
 	if !isInited() {
+		log("ensureConnection: keybase not initialized")
 		return errors.New("keybase not initialized")
 	}
 	if kbCtx == nil || kbCtx.LoopbackListener == nil {
+		log("ensureConnection: loopback listener not initialized (kbCtx nil: %v)", kbCtx == nil)
 		return errors.New("loopback listener not initialized")
 	}
 
 	var err error
 	conn, err = kbCtx.LoopbackListener.Dial()
 	if err != nil {
-		return fmt.Errorf("Failed to dial loopback listener: %s", err)
+		// The listener was closed (isClosed=true, returns syscall.EINVAL). Recreate it and
+		// start a new ListenLoop goroutine, then retry the dial once.
+		log("ensureConnection: Dial failed (%v), restarting loopback server", err)
+		l, rerr := kbCtx.MakeLoopbackServer()
+		if rerr != nil {
+			log("ensureConnection: MakeLoopbackServer failed: %v", rerr)
+			return fmt.Errorf("failed to restart loopback server: %s", rerr)
+		}
+		go func() { _ = kbSvc.ListenLoop(l) }()
+		conn, err = kbCtx.LoopbackListener.Dial()
+		if err != nil {
+			log("ensureConnection: Dial failed after restart: %v", err)
+			return fmt.Errorf("failed to dial after loopback restart: %s", err)
+		}
+		log("ensureConnection: loopback server restarted successfully conn=%s appState=%s",
+			describeConn(conn), appStateForLog())
+		return nil
 	}
-	log("Go: Established loopback connection")
+	log("Go: Established loopback connection conn=%s appState=%s",
+		describeConn(conn), appStateForLog())
 	return nil
 }
 
@@ -545,24 +584,28 @@ func Reset() error {
 	connMutex.Lock()
 	defer connMutex.Unlock()
 
+	log("Go: Reset start conn=%s appState=%s", describeConn(conn), appStateForLog())
 	if conn != nil {
 		conn.Close()
 		conn = nil
 	}
 	if kbCtx == nil || kbCtx.LoopbackListener == nil {
+		log("Go: Reset complete without listener appState=%s", appStateForLog())
 		return nil
 	}
 
 	// Connection will be re-established lazily on next read/write
-	log("Go: Connection reset, will reconnect on next operation")
+	log("Go: Connection reset, will reconnect on next operation appState=%s", appStateForLog())
 	return nil
 }
 
 // NotifyJSReady signals that the JavaScript side is ready to send/receive RPCs.
 // This unblocks the ReadArr loop and allows bidirectional communication.
+// jsReadyCh is closed once and stays closed — repeated calls from engine resets are no-ops.
 func NotifyJSReady() {
 	jsReadyOnce.Do(func() {
-		log("Go: JS signaled ready, unblocking RPC communication")
+		log("Go: JS signaled ready, unblocking RPC communication appState=%s conn=%s",
+			appStateForLog(), describeConn(conn))
 		close(jsReadyCh)
 	})
 }
@@ -590,6 +633,12 @@ func IsAppStateForeground() bool {
 	return kbCtx.MobileAppState.State() == keybase1.MobileAppState_FOREGROUND
 }
 
+// FlushLogs synchronously flushes any buffered log data to disk. Call this
+// before background suspension and after foreground resume to prevent log loss.
+func FlushLogs() {
+	logger.FlushLogFile()
+}
+
 func SetAppStateForeground() {
 	if !isInited() {
 		return
@@ -639,36 +688,39 @@ func waitForInit(maxDur time.Duration) error {
 	}
 }
 
-func BackgroundSync() {
+// BackgroundSync runs a short background sync pulse. Returns a non-empty status
+// string on early exit or error so Swift can log it via NSLog.
+func BackgroundSync() string {
 	// On Android there is a race where this function can be called before Init when starting up in the
 	// background. Let's wait a little bit here for Init to get run, and bail out if it never does.
 	if err := waitForInit(5 * time.Second); err != nil {
-		return
+		return fmt.Sprintf("waitForInit timeout: %v", err)
 	}
 	defer kbCtx.Trace("BackgroundSync", nil)()
 
 	// Skip the sync if we aren't in the background
 	if state := kbCtx.MobileAppState.State(); state != keybase1.MobileAppState_BACKGROUND {
-		kbCtx.Log.Debug("BackgroundSync: skipping, app not in background state: %v", state)
-		return
+		msg := fmt.Sprintf("skipping, app not in background state: %v", state)
+		kbCtx.Log.Debug("BackgroundSync: %s", msg)
+		return msg
 	}
 
 	nextState := keybase1.MobileAppState_BACKGROUNDACTIVE
 	kbCtx.MobileAppState.Update(nextState)
-	doneCh := make(chan struct{})
+	resultCh := make(chan string, 1)
 	go func() {
-		defer func() { close(doneCh) }()
 		select {
 		case state := <-kbCtx.MobileAppState.NextUpdate(&nextState):
 			// if literally anything happens, let's get out of here
-			kbCtx.Log.Debug("BackgroundSync: bailing out early, appstate change: %v", state)
-			return
+			msg := fmt.Sprintf("bailing out early, appstate change: %v", state)
+			kbCtx.Log.Debug("BackgroundSync: %s", msg)
+			resultCh <- msg
 		case <-time.After(10 * time.Second):
 			kbCtx.MobileAppState.Update(keybase1.MobileAppState_BACKGROUND)
-			return
+			resultCh <- "completed 10s window"
 		}
 	}()
-	<-doneCh
+	return <-resultCh
 }
 
 // pushPendingMessageFailure sends at most one notification that a message

go/chat/localizer.go

@@ -845,8 +845,9 @@ func (s *localizerPipeline) localizeConversation(ctx context.Context, uid gregor
 	var maxValidID chat1.MessageID
 	s.Debug(ctx, "localizing %d max msgs", len(maxMsgs))
 	for _, mm := range maxMsgs {
-		if mm.IsValid() &&
-			utils.IsSnippetChatMessageType(mm.GetMessageType()) &&
+		isValidSnippet := mm.IsValid() && utils.IsSnippetChatMessageType(mm.GetMessageType())
+		isEphemeralErr := mm.IsError() && mm.Error().IsEphemeral
+		if (isValidSnippet || isEphemeralErr) &&
 			(conversationLocal.Info.SnippetMsg == nil ||
 				conversationLocal.Info.SnippetMsg.GetMessageID() < mm.GetMessageID()) {
 			conversationLocal.Info.SnippetMsg = new(chat1.MessageUnboxed)

go/chat/utils/utils.go

@@ -1116,10 +1116,13 @@ func formatDuration(dur time.Duration) string {
 
 func getMsgSnippetDecoration(msg chat1.MessageUnboxed) chat1.SnippetDecoration {
 	var msgBody chat1.MessageBody
-	if msg.IsValid() {
+	switch {
+	case msg.IsValid():
 		msgBody = msg.Valid().MessageBody
-	} else {
+	case msg.IsOutbox():
 		msgBody = msg.Outbox().Msg.MessageBody
+	default:
+		return chat1.SnippetDecoration_NONE
 	}
 	switch msg.GetMessageType() {
 	case chat1.MessageType_ATTACHMENT:
@@ -1220,14 +1223,20 @@ func GetMsgSnippetBody(ctx context.Context, g *globals.Context, uid gregor1.UID,
 func GetMsgSnippet(ctx context.Context, g *globals.Context, uid gregor1.UID, msg chat1.MessageUnboxed,
 	conv chat1.ConversationLocal, currentUsername string,
 ) (decoration chat1.SnippetDecoration, snippet string, snippetDecorated string) {
-	if !msg.IsValid() && !msg.IsOutbox() {
-		return chat1.SnippetDecoration_NONE, "", ""
-	}
 	defer func() {
 		if len(snippetDecorated) == 0 {
 			snippetDecorated = snippet
 		}
 	}()
+	if !msg.IsValid() && !msg.IsOutbox() {
+		if msg.IsError() && msg.Error().IsEphemeral {
+			if msg.Error().IsEphemeralExpired(time.Now()) {
+				return chat1.SnippetDecoration_EXPLODED_MESSAGE, "Message exploded.", ""
+			}
+			return chat1.SnippetDecoration_EXPLODING_MESSAGE, msg.Error().ErrMsg, ""
+		}
+		return chat1.SnippetDecoration_NONE, "", ""
+	}
 
 	var senderUsername string
 	if msg.IsValid() {