add auto-away

conventional.yaml

         # "disabled", "opt-in", "opt-out", or "mandatory".
         always-on: "disabled"
 
+        # whether to mark always-on clients away when they have no active connections:
+        auto-away: "opt-out"
+
     # vhosts controls the assignment of vhosts (strings displayed in place of the user's
     # hostname/IP) by the HostServ service
     vhosts:

irc/accounts.go

 	AlwaysOn         PersistentStatus
 	AutoreplayMissed bool
 	DMHistory        HistoryStatus
+	AutoAway         PersistentStatus
 }
 
 // ClientAccount represents a user account.

irc/client.go

 	accountRegDate     time.Time
 	accountSettings    AccountSettings
 	away               bool
+	autoAway           bool
 	awayMessage        string
 	brbTimer           BrbTimer
 	channels           ChannelSet
 
 	client.resizeHistory(config)
 
-	_, err := server.clients.SetNick(client, nil, account.Name)
+	_, err, _ := server.clients.SetNick(client, nil, account.Name)
 	if err != nil {
 		server.logger.Error("internal", "could not establish always-on client", account.Name, err.Error())
 		return
 		// this is *probably* ok as long as the persisted memberships are accurate
 		server.channels.Join(client, chname, "", true, nil)
 	}
+
+	if persistenceEnabled(config.Accounts.Multiclient.AutoAway, client.accountSettings.AutoAway) {
+		client.autoAway = true
+		client.away = true
+		client.awayMessage = client.t("User is currently disconnected")
+	}
 }
 
 func (client *Client) resizeHistory(config *Config) {
 // otherwise, destroys one specific session, only destroying the client if it
 // has no more sessions.
 func (client *Client) destroy(session *Session) {
+	config := client.server.Config()
 	var sessionsToDestroy []*Session
 
 	client.stateMutex.Lock()
 		client.dirtyBits |= IncludeLastSeen
 	}
 	exitedSnomaskSent := client.exitedSnomaskSent
+
+	autoAway := false
+	var awayMessage string
+	if alwaysOn && remainingSessions == 0 && persistenceEnabled(config.Accounts.Multiclient.AutoAway, client.accountSettings.AutoAway) {
+		autoAway = true
+		client.autoAway = true
+		client.away = true
+		awayMessage = config.languageManager.Translate(client.languages, `Disconnected from the server`)
+		client.awayMessage = awayMessage
+	}
+
 	client.stateMutex.Unlock()
 
 	// XXX there is no particular reason to persist this state here rather than
 		client.server.stats.Remove(registered, invisible, operator)
 	}
 
+	if autoAway {
+		dispatchAwayNotify(client, true, awayMessage)
+	}
+
 	if !shouldDestroy {
 		return
 	}

irc/client_lookup_set.go

 		return errNickMissing
 	}
 
-	success, _, _ := oldClient.AddSession(session)
+	success, _, _, _ := oldClient.AddSession(session)
 	if !success {
 		return errNickMissing
 	}
 }
 
 // SetNick sets a client's nickname, validating it against nicknames in use
-func (clients *ClientManager) SetNick(client *Client, session *Session, newNick string) (setNick string, err error) {
+func (clients *ClientManager) SetNick(client *Client, session *Session, newNick string) (setNick string, err error, returnedFromAway bool) {
 	config := client.server.Config()
 
 	var newCfNick, newSkeleton string
 
 	if useAccountName {
 		if registered && newNick != accountName && newNick != "" {
-			return "", errNickAccountMismatch
+			return "", errNickAccountMismatch, false
 		}
 		newNick = accountName
 		newCfNick = account
 		newSkeleton, err = Skeleton(newNick)
 		if err != nil {
-			return "", errNicknameInvalid
+			return "", errNicknameInvalid, false
 		}
 	} else {
 		newNick = strings.TrimSpace(newNick)
 		if len(newNick) == 0 {
-			return "", errNickMissing
+			return "", errNickMissing, false
 		}
 
 		if account == "" && config.Accounts.NickReservation.ForceGuestFormat {
 			newCfNick, err = CasefoldName(newNick)
 			if err != nil {
-				return "", errNicknameInvalid
+				return "", errNicknameInvalid, false
 			}
 			if !config.Accounts.NickReservation.guestRegexpFolded.MatchString(newCfNick) {
 				newNick = strings.Replace(config.Accounts.NickReservation.GuestFormat, "*", newNick, 1)
 			newCfNick, err = CasefoldName(newNick)
 		}
 		if err != nil {
-			return "", errNicknameInvalid
+			return "", errNicknameInvalid, false
 		}
 		if len(newNick) > config.Limits.NickLen || len(newCfNick) > config.Limits.NickLen {
-			return "", errNicknameInvalid
+			return "", errNicknameInvalid, false
 		}
 		newSkeleton, err = Skeleton(newNick)
 		if err != nil {
-			return "", errNicknameInvalid
+			return "", errNicknameInvalid, false
 		}
 
 		if restrictedCasefoldedNicks[newCfNick] || restrictedSkeletons[newSkeleton] {
-			return "", errNicknameInvalid
+			return "", errNicknameInvalid, false
 		}
 
 		reservedAccount, method := client.server.accounts.EnforcementStatus(newCfNick, newSkeleton)
 		if method == NickEnforcementStrict && reservedAccount != "" && reservedAccount != account {
-			return "", errNicknameReserved
+			return "", errNicknameReserved, false
 		}
 	}
 
 	if currentClient != nil && currentClient != client && session != nil {
 		// these conditions forbid reattaching to an existing session:
 		if registered || !bouncerAllowed || account == "" || account != currentClient.Account() {
-			return "", errNicknameInUse
+			return "", errNicknameInUse, false
 		}
 		// check TLS modes
 		if client.HasMode(modes.TLS) != currentClient.HasMode(modes.TLS) {
 			if useAccountName {
 				// #955: this is fatal because they can't fix it by trying a different nick
-				return "", errInsecureReattach
+				return "", errInsecureReattach, false
 			} else {
-				return "", errNicknameInUse
+				return "", errNicknameInUse, false
 			}
 		}
-		reattachSuccessful, numSessions, lastSeen := currentClient.AddSession(session)
+		reattachSuccessful, numSessions, lastSeen, back := currentClient.AddSession(session)
 		if !reattachSuccessful {
-			return "", errNicknameInUse
+			return "", errNicknameInUse, false
 		}
 		if numSessions == 1 {
 			invisible := currentClient.HasMode(modes.Invisible)
 		// for performance reasons
 		currentClient.SetNames("user", realname, true)
 		// successful reattach!
-		return newNick, nil
+		return newNick, nil, back
 	} else if currentClient == client && currentClient.Nick() == newNick {
 		// see #1019: normally no-op nick changes are caught earlier, by performNickChange,
 		// but they are not detected there when force-guest-format is enabled (because
 		// the proposed nickname is e.g. alice and the current nickname is Guest-alice)
-		return "", errNoop
+		return "", errNoop, false
 	}
 	// analogous checks for skeletons
 	skeletonHolder := clients.bySkeleton[newSkeleton]
 	if skeletonHolder != nil && skeletonHolder != client {
-		return "", errNicknameInUse
+		return "", errNicknameInUse, false
 	}
 
 	clients.removeInternal(client)
 	clients.byNick[newCfNick] = client
 	clients.bySkeleton[newSkeleton] = client
 	client.updateNick(newNick, newCfNick, newSkeleton)
-	return newNick, nil
+	return newNick, nil, false
 }
 
 func (clients *ClientManager) AllClients() (result []*Client) {

irc/config.go

 	Enabled          bool
 	AllowedByDefault bool             `yaml:"allowed-by-default"`
 	AlwaysOn         PersistentStatus `yaml:"always-on"`
+	AutoAway         PersistentStatus `yaml:"auto-away"`
 }
 
 type throttleConfig struct {

irc/getters.go

 	return
 }
 
-func (client *Client) AddSession(session *Session) (success bool, numSessions int, lastSeen time.Time) {
+func (client *Client) AddSession(session *Session) (success bool, numSessions int, lastSeen time.Time, back bool) {
 	client.stateMutex.Lock()
 	defer client.stateMutex.Unlock()
 
 		lastSeen = client.lastSeen
 	}
 	client.sessions = newSessions
-	return true, len(client.sessions), lastSeen
+	if client.autoAway {
+		back = true
+		client.autoAway = false
+		client.away = false
+		client.awayMessage = ""
+	}
+	return true, len(client.sessions), lastSeen, back
 }
 
 func (client *Client) removeSession(session *Session) (success bool, length int) {

irc/handlers.go

 		rb.Add(nil, server.name, RPL_UNAWAY, client.nick, client.t("You are no longer marked as being away"))
 	}
 
+	dispatchAwayNotify(client, isAway, awayMessage)
+	return false
+}
+
+func dispatchAwayNotify(client *Client, isAway bool, awayMessage string) {
 	// dispatch away-notify
 	details := client.Details()
 	for session := range client.Friends(caps.AwayNotify) {
 			session.sendFromClientInternal(false, time.Time{}, "", details.nickMask, details.account, nil, "AWAY")
 		}
 	}
-
-	return false
 }
 
 // BATCH {+,-}reference-tag type [params...]

irc/nickname.go

 	hadNick := details.nick != "*"
 	origNickMask := details.nickMask
 
-	assignedNickname, err := client.server.clients.SetNick(target, session, nickname)
+	assignedNickname, err, back := client.server.clients.SetNick(target, session, nickname)
 	if err == errNicknameInUse {
 		rb.Add(nil, server.name, ERR_NICKNAMEINUSE, currentNick, utils.SafeErrorParam(nickname), client.t("Nickname is already in use"))
 	} else if err == errNicknameReserved {
 		}
 	}
 
+	if back {
+		dispatchAwayNotify(session.client, false, "")
+	}
+
 	for _, channel := range client.Channels() {
 		channel.AddHistoryItem(histItem, details.account)
 	}

irc/nickserv.go

 2. 'ephemeral'  [a limited amount of temporary history, not stored on disk]
 3. 'on'         [history stored in a permanent database, if available]
 4. 'default'    [use the server default]`,
+				`$bAUTO-AWAY$b
+'auto-away' is only effective for always-on clients. If enabled, you will
+automatically be marked away when all your sessions are disconnected, and
+automatically return from away when you connect again.`,
 			},
 			authRequired: true,
 			enabled:      servCmdRequiresAuthEnabled,
 		} else {
 			nsNotice(rb, client.t("Your account is not configured to receive autoreplayed missed messages"))
 		}
+	case "auto-away":
+		stored := settings.AutoAway
+		alwaysOn := persistenceEnabled(config.Accounts.Multiclient.AlwaysOn, settings.AlwaysOn)
+		actual := persistenceEnabled(config.Accounts.Multiclient.AutoAway, settings.AutoAway)
+		nsNotice(rb, fmt.Sprintf(client.t("Your stored auto-away setting is: %s"), persistentStatusToString(stored)))
+		if actual && alwaysOn {
+			nsNotice(rb, client.t("Given current server settings, auto-away is enabled for your client"))
+		} else if actual && !alwaysOn {
+			nsNotice(rb, client.t("Because your client is not always-on, auto-away is disabled"))
+		} else if !actual {
+			nsNotice(rb, client.t("Given current server settings, auto-away is disabled for your client"))
+		}
 	case "dm-history":
 		effectiveValue := historyEnabled(config.History.Persistent.DirectMessages, settings.DMHistory)
 		csNotice(rb, fmt.Sprintf(client.t("Your stored direct message history setting is: %s"), historyStatusToString(settings.DMHistory)))
 				return
 			}
 		}
+	case "auto-away":
+		var newValue PersistentStatus
+		newValue, err = persistentStatusFromString(params[1])
+		// "opt-in" and "opt-out" don't make sense as user preferences
+		if err == nil && newValue != PersistentOptIn && newValue != PersistentOptOut {
+			munger = func(in AccountSettings) (out AccountSettings, err error) {
+				out = in
+				out.AutoAway = newValue
+				return
+			}
+		}
 	case "dm-history":
 		var newValue HistoryStatus
 		newValue, err = historyStatusFromString(params[1])

oragono.yaml

         # "disabled", "opt-in", "opt-out", or "mandatory".
         always-on: "opt-in"
 
+        # whether to mark always-on clients away when they have no active connections:
+        auto-away: "opt-out"
+
     # vhosts controls the assignment of vhosts (strings displayed in place of the user's
     # hostname/IP) by the HostServ service
     vhosts: