Merge branch 'master' into nojima/HOTPOT-next-670-clean

# Conflicts:
#	rnmodules/react-native-kb/ios/Kb.mm
#	shared/constants/init/index.native.tsx
#	shared/ios/Keybase/AppDelegate.swift
#	shared/router-v2/hooks.native.tsx
#	shared/router-v2/router.native.tsx
#	shared/stores/daemon.tsx

Author: chrisnojima-zoom

go/bind/keybase.go

@@ -524,6 +524,7 @@ func ReadArr() (data []byte, err error) {
 // ensureConnection establishes the loopback connection if not already connected.
 // Must be called with connMutex held.
 func ensureConnection() error {
+	start := time.Now()
 	if !isInited() {
 		return errors.New("keybase not initialized")
 	}
@@ -536,7 +537,7 @@ func ensureConnection() error {
 	if err != nil {
 		return fmt.Errorf("Failed to dial loopback listener: %s", err)
 	}
-	log("Go: Established loopback connection")
+	log("Go: Established loopback connection in %v", time.Since(start))
 	return nil
 }
 
@@ -590,6 +591,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 +646,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

@@ -1110,10 +1110,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:
@@ -1214,14 +1217,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() {

go/chat/utils/utils_test.go

@@ -1086,6 +1086,36 @@ func TestSearchableRemoteConversationName(t *testing.T) {
 		searchableRemoteConversationNameFromStr("joshblum,zoommikem,mikem,zoomua,mikem", "mikem"))
 }
 
+func TestGetMsgSnippetEphemeralError(t *testing.T) {
+	ctx := context.Background()
+	conv := chat1.ConversationLocal{}
+	errMsg := "This exploding message is not available because this device was created after the message was sent"
+
+	// Non-expired ephemeral error: should surface the error message with EXPLODING_MESSAGE decoration.
+	msg := chat1.NewMessageUnboxedWithError(chat1.MessageUnboxedError{
+		ErrType:     chat1.MessageUnboxedErrorType_EPHEMERAL,
+		ErrMsg:      errMsg,
+		IsEphemeral: true,
+		Etime:       gregor1.ToTime(time.Now().Add(time.Hour)),
+		MessageType: chat1.MessageType_TEXT,
+	})
+	decoration, snippet, _ := GetMsgSnippet(ctx, nil, gregor1.UID{}, msg, conv, "alice")
+	require.Equal(t, chat1.SnippetDecoration_EXPLODING_MESSAGE, decoration)
+	require.Equal(t, errMsg, snippet)
+
+	// Expired ephemeral error: should show "Message exploded." with EXPLODED_MESSAGE decoration.
+	msg = chat1.NewMessageUnboxedWithError(chat1.MessageUnboxedError{
+		ErrType:     chat1.MessageUnboxedErrorType_EPHEMERAL,
+		ErrMsg:      errMsg,
+		IsEphemeral: true,
+		Etime:       gregor1.ToTime(time.Now().Add(-time.Hour)),
+		MessageType: chat1.MessageType_TEXT,
+	})
+	decoration, snippet, _ = GetMsgSnippet(ctx, nil, gregor1.UID{}, msg, conv, "alice")
+	require.Equal(t, chat1.SnippetDecoration_EXPLODED_MESSAGE, decoration)
+	require.Equal(t, "Message exploded.", snippet)
+}
+
 func TestStripUsernameFromConvName(t *testing.T) {
 	// Only the username as a complete segment is removed; "mikem" inside "zoommikem" must not be stripped
 	require.Equal(t, "joshblum,zoommikem,zoomua",

go/ephemeral/common_test.go

@@ -132,7 +132,10 @@ func TestEphemeralPluralization(t *testing.T) {
 	require.Equal(t, humanMsg, pluralized)
 
 	pluralized = PluralizeErrorMessage(humanMsg, 2)
-	require.Equal(t, "2 exploding messages are not available, because this device was created after it was sent", pluralized)
+	require.Equal(t, "2 exploding messages are not available because this device was created after the messages were sent", pluralized)
+
+	pluralized = PluralizeErrorMessage(humanMsgWithPrefix(MemberAfterEKErrMsg), 3)
+	require.Equal(t, "3 exploding messages are not available because you joined the team after the messages were sent", pluralized)
 
 	pluralized = PluralizeErrorMessage(DefaultHumanErrMsg, 2)
 	require.Equal(t, "2 exploding messages are not available", pluralized)

go/ephemeral/errors.go

@@ -82,10 +82,10 @@ func newTransientEphemeralKeyError(err EphemeralKeyError) EphemeralKeyError {
 const (
 	DefaultHumanErrMsg           = "This exploding message is not available"
 	DefaultPluralHumanErrMsg     = "%d exploding messages are not available"
-	DeviceCloneErrMsg            = "cloned devices do not support exploding messages"
-	DeviceCloneWithOneshotErrMsg = "to support exploding messages in `oneshot` mode, you need a separate paper key for each running instance"
-	DeviceAfterEKErrMsg          = "because this device was created after it was sent"
-	MemberAfterEKErrMsg          = "because you joined the team after it was sent"
+	DeviceCloneErrMsg            = "because this device has been cloned"
+	DeviceCloneWithOneshotErrMsg = "because this device is running in `oneshot` mode; to support exploding messages in `oneshot` mode, you need a separate paper key for each running instance"
+	DeviceAfterEKErrMsg          = "because this device was created after the message was sent"
+	MemberAfterEKErrMsg          = "because you joined the team after the message was sent"
 	DeviceStaleErrMsg            = "because this device wasn't online to generate an exploding key"
 	UserStaleErrMsg              = "because you weren't online to generate new exploding keys"
 )
@@ -159,7 +159,7 @@ func humanMsgWithPrefix(humanMsg string) string {
 	if humanMsg == "" {
 		humanMsg = DefaultHumanErrMsg
 	} else if !strings.Contains(humanMsg, DefaultHumanErrMsg) {
-		humanMsg = fmt.Sprintf("%s, %s", DefaultHumanErrMsg, humanMsg)
+		humanMsg = fmt.Sprintf("%s %s", DefaultHumanErrMsg, humanMsg)
 	}
 	return humanMsg
 }

go/kbfs/kbfsgit/runner.go

@@ -679,6 +679,21 @@ func (r *runner) waitForJournal(ctx context.Context) error {
 		r.printStageEndIfNeeded)
 }
 
+// bestBranchFromCandidates selects the best branch for HEAD from a set of
+// candidate branch names (prefer main > master > alphabetically first).
+func bestBranchFromCandidates(best plumbing.ReferenceName, candidate plumbing.ReferenceName) plumbing.ReferenceName {
+	switch {
+	case candidate == "refs/heads/main":
+		return candidate
+	case candidate == "refs/heads/master" && best != "refs/heads/main":
+		return candidate
+	case best == "" || (best != "refs/heads/main" && best != "refs/heads/master" && candidate < best):
+		return candidate
+	default:
+		return best
+	}
+}
+
 // handleList: From https://git-scm.com/docs/git-remote-helpers
 //
 // Lists the refs, one per line, in the format "<value> <name> [<attr>
@@ -705,9 +720,18 @@ func (r *runner) handleList(ctx context.Context, args []string) (err error) {
 	if err != nil {
 		return err
 	}
+	defer refs.Close()
 
-	var symRefs []string
+	type symRefInfo struct {
+		name   plumbing.ReferenceName
+		target plumbing.ReferenceName
+	}
+	var symRefs []symRefInfo
+	hashRefNames := make(map[plumbing.ReferenceName]bool)
 	hashesSeen := false
+	// Track the best fallback branch for HEAD in case its target
+	// doesn't exist (prefer main > master > alphabetically first).
+	var bestBranch plumbing.ReferenceName
 	for {
 		ref, err := refs.Next()
 		if errors.Cause(err) == io.EOF {
@@ -722,6 +746,11 @@ func (r *runner) handleList(ctx context.Context, args []string) (err error) {
 		case plumbing.HashReference:
 			value = ref.Hash().String()
 			hashesSeen = true
+			hashRefNames[ref.Name()] = true
+			// Track best branch for fallback HEAD.
+			if strings.HasPrefix(ref.Name().String(), "refs/heads/") {
+				bestBranch = bestBranchFromCandidates(bestBranch, ref.Name())
+			}
 		case plumbing.SymbolicReference:
 			value = "@" + ref.Target().String()
 		default:
@@ -734,7 +763,10 @@ func (r *runner) handleList(ctx context.Context, args []string) (err error) {
 			// cloning an empty repo will result in an error because
 			// the HEAD symbolic ref points to a ref that doesn't
 			// exist.
-			symRefs = append(symRefs, refStr)
+			symRefs = append(symRefs, symRefInfo{
+				name:   ref.Name(),
+				target: ref.Target(),
+			})
 			continue
 		}
 		r.log.CDebugf(ctx, "Listing ref %s", refStr)
@@ -745,7 +777,30 @@ func (r *runner) handleList(ctx context.Context, args []string) (err error) {
 	}
 
 	if hashesSeen && !forPush {
-		for _, refStr := range symRefs {
+		for _, sr := range symRefs {
+			target := sr.target
+			// If the symref target doesn't exist among hash refs,
+			// rewrite it to point to the best available branch,
+			// but only for HEAD. Other symrefs are emitted as-is.
+			if !hashRefNames[target] {
+				if sr.name == plumbing.HEAD {
+					if bestBranch == "" {
+						r.log.CDebugf(ctx,
+							"Skipping HEAD symref %s -> %s (no branches available)",
+							sr.name, target)
+						continue
+					}
+					r.log.CDebugf(ctx,
+						"Rewriting HEAD symref from %s to %s",
+						target, bestBranch)
+					target = bestBranch
+				} else {
+					r.log.CDebugf(ctx,
+						"Emitting non-HEAD symref %s -> %s with unknown target",
+						sr.name, target)
+				}
+			}
+			refStr := "@" + target.String() + " " + sr.name.String() + "\n"
 			r.log.CDebugf(ctx, "Listing symbolic ref %s", refStr)
 			_, err = r.output.Write([]byte(refStr))
 			if err != nil {
@@ -1827,6 +1882,53 @@ func (r *runner) handlePushBatch(ctx context.Context, args [][]string) (
 		return nil, err
 	}
 
+	// If HEAD points to a nonexistent ref, update it to point to the
+	// best available branch in the repo (prefer main > master > alphabetical).
+	// We intentionally repair HEAD even when the target was explicitly
+	// deleted in this batch, because a broken HEAD causes clone failures.
+	// This must happen before waitForJournal so the HEAD update is
+	// included in the same flush.
+	head, headErr := repo.Storer.Reference(plumbing.HEAD)
+	if headErr == nil && head.Type() == plumbing.SymbolicReference {
+		_, targetErr := repo.Storer.Reference(head.Target())
+		var bestBranch plumbing.ReferenceName
+		if targetErr == plumbing.ErrReferenceNotFound {
+			allRefs, refsErr := repo.References()
+			if refsErr == nil {
+				defer allRefs.Close()
+				for {
+					ref, nextErr := allRefs.Next()
+					if errors.Cause(nextErr) == io.EOF {
+						break
+					}
+					if nextErr != nil {
+						break
+					}
+					if ref.Type() != plumbing.HashReference {
+						continue
+					}
+					if !strings.HasPrefix(ref.Name().String(), "refs/heads/") {
+						continue
+					}
+					bestBranch = bestBranchFromCandidates(bestBranch, ref.Name())
+				}
+			}
+		}
+		if bestBranch != "" {
+			newHead := plumbing.NewSymbolicReference(
+				plumbing.HEAD, bestBranch)
+			if setErr := repo.Storer.SetReference(
+				newHead); setErr != nil {
+				r.log.CDebugf(ctx,
+					"Error updating HEAD to %s: %+v",
+					bestBranch, setErr)
+			} else {
+				r.log.CDebugf(ctx,
+					"Updated HEAD to point to %s", bestBranch)
+			}
+		}
+	}
+
 	err = r.waitForJournal(ctx)
 	if err != nil {
 		return nil, err