qcode/ui/workspace/

tab.rs

//! One tab of the workspace screen: what it opens, where it stands, and the session it draws.

use std::path::{Path, PathBuf};
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};

use qframe::runtime::TaskId;
use qframe::widgets::{LogBuffer, LogLevel, LogLine, TerminalSession};

use crate::base::apps::Quiet;
use crate::bridge;
use crate::desktop::callback::{Ending, Stop};
use crate::ui::stalling;

use super::bridge::{Letter, Pasted, Undelivered};
use super::plan::LaunchFailure;

/// How many lines of an image build a tab keeps: a build prints thousands, and the ones that
/// matter when it fails are the last.
const BUILD_LINES: usize = 2000;

/// A tab's identity, which stays the same while tabs are closed and dragged around it.
///
/// Work started for a tab comes back as a message long after the tab may have moved, so the
/// answer names the tab rather than its position.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct TabKey(pub u64);

/// What a tab opens.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TabKind {
    /// A shell in the workspace's own container, with no harness in it.
    Shell,
    /// A harness in the container of the profile of this name.
    Profile(String),
    /// A blank tab asking what it should open. It has no container and never starts one; the
    /// choice turns it into one of the others in place.
    New,
    /// A picture of the workspace, drawn by chafa in the workspace's own container. The text is the
    /// file's key in the file tree: its path inside `Work/`, written with `/`.
    Image(String),
    /// A Markdown document of the workspace, read from the disk and shown by QCode itself, with no
    /// container at all.
    Markdown(String),
    /// A file of the workspace, open in the chosen editor in the workspace's own container.
    Editor(String),
    /// A PDF of the workspace: its text, taken out in the workspace's own container and shown by
    /// QCode, or one of its pages drawn there as a picture.
    Pdf(String),
    /// A word processor's document of the workspace: its text, taken out in the workspace's own
    /// container and shown by QCode.
    Office(String),
    /// A sound of the workspace: played in a container of its own made for it, or, when it
    /// cannot or should not play, described.
    Sound(String),
    /// `bash` as root in the container of the profile of this name, asked for by the person to
    /// install what the system of that container lacks. What it changes stays in this workspace.
    Admin(String),
    /// A window of the desktop harness of the profile of this name, open on the person's own
    /// screen from a container of its own. The tab has no terminal: it says where the window
    /// stands and offers the two things that can be done to it.
    Desktop(String),
}

impl TabKind {
    /// The key of the workspace's file the tab opens, when it opens one.
    #[must_use]
    pub fn file(&self) -> Option<&str> {
        match self {
            Self::Image(file)
            | Self::Markdown(file)
            | Self::Editor(file)
            | Self::Pdf(file)
            | Self::Office(file)
            | Self::Sound(file) => Some(file),
            Self::Shell | Self::Profile(_) | Self::New | Self::Desktop(_) | Self::Admin(_) => None,
        }
    }

    /// Whether an agent works in a tab of this kind: a harness in a terminal, or the window of a
    /// desktop harness. Quitting and closing a tab ask about the same tabs through this.
    #[must_use]
    pub fn runs_agent(&self) -> bool {
        matches!(self, Self::Profile(_) | Self::Desktop(_))
    }

    /// The profile the tab belongs to, when it belongs to one: a harness in a terminal or a
    /// window on the screen.
    #[must_use]
    pub fn profile(&self) -> Option<&str> {
        match self {
            Self::Profile(name) | Self::Desktop(name) => Some(name),
            Self::Shell
            | Self::New
            | Self::Admin(_)
            | Self::Image(_)
            | Self::Markdown(_)
            | Self::Editor(_)
            | Self::Pdf(_)
            | Self::Office(_)
            | Self::Sound(_) => None,
        }
    }
}

/// Where a PDF tab stands among its pages.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Pages {
    /// How many pages the document has, as its text counted them.
    pub count: usize,
    /// The page drawn, or the one that is drawn next; counted from 1.
    pub page: usize,
    /// Whether the tab draws the page rather than showing the text.
    pub drawn: bool,
}

impl Default for Pages {
    fn default() -> Self {
        Self { count: 1, page: 1, drawn: false }
    }
}

/// Where the page a window asked to have opened was shown.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Shown {
    /// In the person's own browser. Whether its sign-in is carried back is the tab's [`Back`].
    InBrowser,
    /// In the sign-in window inside the window's own container, which the person chose instead;
    /// a sign-in comes back from there by itself, where Google lets it.
    InWindow,
    /// Not shown, because the sign-in could not come back from it: its port is taken. The tab's
    /// [`Back`] says why.
    Held,
    /// The person asked for the sign-in window, and the profile's image has none.
    NoWindow,
    /// Nowhere: the person is given the address to read.
    Nowhere,
}

/// Where the way back of a window's sign-in stands: QCode listening on this machine for the
/// browser to be sent back, and carrying what arrives to the application.
#[derive(Debug)]
pub enum Back {
    /// Listening; dropping the stop gives the port up.
    Listening(Stop),
    /// The application answered the request for the way back.
    Returned,
    /// Nothing came back within the wait.
    TimedOut,
    /// Another program of this machine holds the port.
    Taken,
    /// The system refused to listen on the port, in its own words.
    Refused(String),
}

/// Where a tab stands.
///
/// Nothing here is a guess: a tab is `Running` only once a session is really attached to a
/// container, and every way of failing carries what to do next.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TabState {
    /// Not started yet. A tab brought back from the last session waits like a background tab of
    /// a browser: it starts its container the first time it is shown, so bringing back a dozen
    /// tabs does not start a dozen containers at once. A blank tab waits for its choice.
    Waiting,
    /// The container is being created or started; nothing is attached yet.
    Starting,
    /// A session is attached to the running container; for a Markdown tab, which has neither,
    /// the document is read and shown.
    Running,
    /// The program inside the container ended, and the container is still up.
    Ended {
        /// Its exit code, or `None` when the engine did not report one.
        code: Option<u32>,
    },
    /// The container is not running any more, so the tab lost its ground rather than its
    /// program. This is the case the design asks to be named and offered a restart.
    Stopped,
    /// The engine refused, and said why.
    Failed(LaunchFailure),
    /// The engine does not have the image of the tab's profile, so nothing was made; the tab
    /// offers to build it.
    NoImage,
    /// The profile's image is being built by this task, for the tab to open once it is there.
    Building(TaskId),
    /// The file the tab opens is not in the workspace any more.
    Missing,
    /// The file the tab opens could not be read, for this reason.
    Unreadable(String),
}

impl TabState {
    /// Whether the tab is waiting for its container.
    #[must_use]
    pub fn is_starting(&self) -> bool {
        matches!(self, Self::Starting)
    }

    /// Whether the tab can be started again. A tab that is starting or running has nothing to
    /// restart, so its restart is never offered.
    #[must_use]
    pub fn can_restart(&self) -> bool {
        matches!(
            self,
            Self::Ended { .. } | Self::Stopped | Self::Failed(_) | Self::NoImage | Self::Missing | Self::Unreadable(_)
        )
    }
}

/// One tab: a container to enter, the state it is in and the session it draws while it runs.
#[derive(Debug)]
pub struct Tab {
    key: TabKey,
    /// The tab's id inside its workspace, the one agents know it by: 1 for the workspace's first
    /// tab, then 2 and on. Given by the workspace when the tab joins it and never given again
    /// while the workspace is open, so the id of a closed tab never lands on another. 0 until
    /// then.
    number: u32,
    /// The name the person gave the tab, which the strip, the list agents read and the header of
    /// every message the tab sends show in place of the automatic one.
    name: Option<String>,
    kind: TabKind,
    state: TabState,
    /// When the tab was opened, in seconds since the Unix epoch.
    opened: u64,
    /// The harness conversation the tab shows, when it is known.
    conversation: Option<String>,
    session: Option<TerminalSession>,
    /// The text of a Markdown tab's file, as it was last read, or the text taken out of a PDF.
    document: Option<String>,
    /// Whether that text was cut short, being too long to show whole.
    partial: bool,
    /// Where a PDF tab stands among its pages.
    pages: Pages,
    /// Why a sound tab shows the sound's details rather than playing it, once it is known.
    quiet: Option<Quiet>,
    /// The sound server's socket on this machine, once a sound tab found one to play through.
    socket: Option<PathBuf>,
    /// Whether a sound tab waits to be asked before it plays: a tab brought back from the last
    /// session does, because opening QCode again is not asking to hear the sound again.
    held: bool,
    /// The web address the window asked to have opened, and where it was shown — `None` while
    /// the opening is still on its way. A window tab only.
    sign_in: Option<(String, Option<Shown>)>,
    /// The port that sign-in comes back to, and where its way back stands. A window tab only.
    back: Option<(u16, Back)>,
    /// Counts the sessions this tab has started, so the watch of a session that was replaced by
    /// a restart is recognised and ignored.
    run: u64,
    /// What a harness tab's agent hands QCode's bridge to say which tab it is in.
    token: String,
    /// Messages other tabs' agents sent this tab that wait in it, oldest first.
    letters: Vec<Letter>,
    /// Whether the waiting letters are shown.
    letters_shown: bool,
    /// Why the oldest waiting message could not be typed into the harness, when an attempt was
    /// made and failed. Cleared as soon as one is typed in.
    undelivered: Option<Undelivered>,
    /// A message written into this tab's prompt whose Return has not gone yet, and when it went
    /// in. The tab owes that Return until it is written; nothing is owed to a tab that owes
    /// nothing.
    owed: Option<Pasted>,
    /// The session's last input that was not the person's: when it started, or the Return QCode
    /// wrote after the last message it typed in. Input later than this is the person typing.
    own_input: Option<std::time::Instant>,
    /// The other tab of an exchange of messages the loop limit ended, named as the person knows
    /// it, until the person has read the line that says so.
    stopped: Option<String>,
    /// What the build of the profile's image said, when this tab built it.
    build_log: LogBuffer,
    /// When the build last said something, or when it started: what the silence the page warns
    /// about is measured from.
    build_said: Instant,
    /// Whether that silence has lasted as long as the rule asks, which is what the page says
    /// beside the build. Never true of a build that has ended.
    build_stuck: bool,
}

impl Tab {
    /// A tab of `kind` opened now, waiting for its container.
    #[must_use]
    pub fn new(key: TabKey, kind: TabKind) -> Self {
        let now = SystemTime::now().duration_since(UNIX_EPOCH).map_or(0, |since| since.as_secs());
        Self {
            key,
            number: 0,
            name: None,
            kind,
            state: TabState::Starting,
            opened: now,
            conversation: None,
            session: None,
            document: None,
            partial: false,
            pages: Pages::default(),
            quiet: None,
            sign_in: None,
            back: None,
            socket: None,
            held: false,
            run: 0,
            token: bridge::token(),
            letters: Vec::new(),
            letters_shown: false,
            undelivered: None,
            owed: None,
            own_input: None,
            stopped: None,
            build_log: LogBuffer::new(BUILD_LINES),
            build_said: Instant::now(),
            build_stuck: false,
        }
    }

    /// A blank tab opened now, waiting for the person to choose what it opens.
    #[must_use]
    pub fn blank(key: TabKey) -> Self {
        Self { state: TabState::Waiting, ..Self::new(key, TabKind::New) }
    }

    /// A tab of `kind` opened now that waits to be started, which the screen does as soon as it
    /// is shown. A tab of one of the workspace's files is opened this way, so it starts exactly
    /// the way a tab brought back from the last session does.
    #[must_use]
    pub fn waiting(key: TabKey, kind: TabKind) -> Self {
        Self { state: TabState::Waiting, ..Self::new(key, kind) }
    }

    /// A tab of `kind` brought back from the last session, as it was recorded: opened at
    /// `opened` and showing `conversation`. It waits to be shown before it starts anything.
    #[must_use]
    pub fn restored(key: TabKey, kind: TabKind, opened: u64, conversation: Option<String>) -> Self {
        Self { opened, conversation, ..Self::waiting(key, kind) }
    }

    /// The tab's identity.
    #[must_use]
    pub fn key(&self) -> TabKey {
        self.key
    }

    /// The tab's id inside its workspace, which agents send to; 0 before it joined one.
    #[must_use]
    pub fn number(&self) -> u32 {
        self.number
    }

    /// Gives the tab its id inside its workspace. Only the workspace does this, as the tab joins it.
    pub(super) fn numbered(&mut self, number: u32) {
        self.number = number;
    }

    /// The name the person gave the tab, when they gave it one.
    #[must_use]
    pub fn name(&self) -> Option<&str> {
        self.name.as_deref()
    }

    /// Gives the tab the person's `name`, or with `None` takes it away, after which the tab reads
    /// its automatic name again.
    pub fn rename(&mut self, name: Option<String>) {
        self.name = name;
    }

    /// What the tab opens.
    #[must_use]
    pub fn kind(&self) -> &TabKind {
        &self.kind
    }

    /// Where the tab stands.
    #[must_use]
    pub fn state(&self) -> &TabState {
        &self.state
    }

    /// When the tab was opened, in seconds since the Unix epoch.
    #[must_use]
    pub fn opened(&self) -> u64 {
        self.opened
    }

    /// The harness conversation the tab shows, when it is known.
    #[must_use]
    pub fn conversation(&self) -> Option<&str> {
        self.conversation.as_deref()
    }

    /// The session drawn in the middle, while there is one.
    #[must_use]
    pub fn session(&self) -> Option<&TerminalSession> {
        self.session.as_ref()
    }

    /// The text of a Markdown tab's file, once it has been read.
    #[must_use]
    pub fn document(&self) -> Option<&str> {
        self.document.as_deref()
    }

    /// Whether the text the tab shows was cut short.
    #[must_use]
    pub fn is_partial(&self) -> bool {
        self.partial
    }

    /// Where a PDF tab stands among its pages.
    #[must_use]
    pub fn pages(&self) -> Pages {
        self.pages
    }

    /// Moves a PDF tab to `pages`.
    pub fn turn(&mut self, pages: Pages) {
        self.pages = pages;
    }

    /// Why a sound tab shows the sound's details rather than playing it.
    #[must_use]
    pub fn quiet(&self) -> Option<Quiet> {
        self.quiet
    }

    /// Records why a sound tab shows the sound's details.
    pub fn keep_quiet(&mut self, why: Quiet) {
        self.quiet = Some(why);
    }

    /// The sound server's socket a sound tab plays through.
    #[must_use]
    pub fn socket(&self) -> Option<&Path> {
        self.socket.as_deref()
    }

    /// Records the socket a sound tab plays through, and that it plays rather than describes.
    pub fn play_through(&mut self, socket: PathBuf) {
        self.socket = Some(socket);
        self.quiet = None;
    }

    /// Whether a sound tab waits to be asked before it plays.
    #[must_use]
    pub fn is_held(&self) -> bool {
        self.held
    }

    /// Makes a sound tab wait to be asked before it plays, or lets it play.
    pub fn hold(&mut self, held: bool) {
        self.held = held;
    }

    /// The web address the window asked to have opened, with where it was shown; that is `None`
    /// until the opening answers.
    #[must_use]
    pub fn sign_in(&self) -> Option<(&str, Option<Shown>)> {
        self.sign_in.as_ref().map(|(address, opened)| (address.as_str(), *opened))
    }

    /// Records the address the window asked to have opened. The address is shown at once, before
    /// anything is known about the browser, because reading it is what the person needs most.
    pub fn asked_to_open(&mut self, address: String) {
        self.sign_in = Some((address, None));
    }

    /// Records how the opening of that address went, if it is still the address being opened.
    pub fn opened_here(&mut self, address: &str, opened: Shown) {
        if let Some((waiting, how)) = self.sign_in.as_mut()
            && waiting == address
        {
            *how = Some(opened);
        }
    }

    /// The port the window's sign-in comes back to, and where its way back stands.
    #[must_use]
    pub fn back(&self) -> Option<(u16, &Back)> {
        self.back.as_ref().map(|(port, back)| (*port, back))
    }

    /// Whether the tab listens for a sign-in coming back to `port` right now.
    #[must_use]
    pub fn listens_on(&self, port: u16) -> bool {
        matches!(self.back, Some((listening, Back::Listening(_))) if listening == port)
    }

    /// Records where the way back to `port` stands; a listening that was going on is stopped by
    /// being replaced.
    pub fn back_to(&mut self, port: u16, back: Back) {
        self.back = Some((port, back));
    }

    /// Takes the end of the listening `id`, if it is still the tab's.
    pub fn came_back(&mut self, id: u64, ending: Ending) {
        let Some((port, Back::Listening(stop))) = &self.back else { return };
        if stop.id() != id {
            return;
        }
        let port = *port;
        match ending {
            Ending::Returned => self.back = Some((port, Back::Returned)),
            Ending::TimedOut => self.back = Some((port, Back::TimedOut)),
            // Only the tab stops a listening, and it has moved on already.
            Ending::Stopped => {}
        }
    }

    /// Stops listening for the way back, when the tab was.
    pub fn stop_listening(&mut self) {
        if matches!(self.back, Some((_, Back::Listening(_)))) {
            self.back = None;
        }
    }

    /// Which session of this tab is the current one.
    #[must_use]
    pub fn run(&self) -> u64 {
        self.run
    }

    /// The token a harness tab is started with, by which the bridge knows it.
    #[must_use]
    pub fn token(&self) -> &str {
        &self.token
    }

    /// The messages that wait in this tab, oldest first.
    #[must_use]
    pub fn letters(&self) -> &[Letter] {
        &self.letters
    }

    /// Whether the waiting messages are shown.
    #[must_use]
    pub fn letters_shown(&self) -> bool {
        self.letters_shown
    }

    /// Leaves `letter` waiting in the tab.
    pub fn receive(&mut self, letter: Letter) {
        self.letters.push(letter);
    }

    /// Why the waiting messages have not been typed into the harness, when something stops them.
    #[must_use]
    pub fn undelivered(&self) -> Option<Undelivered> {
        self.undelivered
    }

    /// Records that the oldest waiting message could not be typed in, and why. The message stays
    /// where it is: dropping it would let the sender believe its work was handed over.
    pub fn not_delivered(&mut self, why: Undelivered) {
        self.undelivered = Some(why);
    }

    /// Records that `pasted` went into this tab's prompt and that the tab owes its Return until
    /// [`Tab::returned`] says it has gone. A tab takes no further message in the meantime: two
    /// messages in one prompt line are one message to the harness.
    pub fn pasted(&mut self, pasted: Pasted) {
        self.owed = Some(pasted);
    }

    /// The message whose Return this tab still owes, when it owes one: the paste that went in, the
    /// harness's last output before it, and when it went, which is what the Return's own wait is
    /// counted from.
    #[must_use]
    pub fn owed(&self) -> Option<&Pasted> {
        self.owed.as_ref()
    }

    /// Records that the Return this tab owed has been written, and that the newest thing in the
    /// terminal is QCode's own: what the person types after it is theirs, as before.
    pub fn returned(&mut self) {
        if let Some(session) = &self.session {
            self.own_input = Some(session.last_input());
        }
        self.owed = None;
    }

    /// Puts `letter` back at the head of the waiting messages, as the oldest of them, and says why
    /// it is waiting again: its Return could not be written, so the harness that would have read
    /// it is gone and the message waits for the tab's own next start rather than being lost.
    pub fn put_back(&mut self, letter: Letter) {
        self.letters.insert(0, letter);
        self.undelivered = Some(Undelivered::NotRunning);
    }

    /// Whether the person has typed into the session since it started and since QCode last wrote
    /// into it: a message pasted in is QCode's own, and so is the Return that sends it, so neither
    /// counts as the person typing while the Return is still owed.
    #[must_use]
    pub fn person_typed(&self) -> bool {
        self.session.as_ref().is_some_and(|session| self.own_input.is_none_or(|own| session.last_input() > own))
    }

    /// Takes the oldest waiting message away, once it has been typed into the harness. The
    /// session's own last input is left to the Return that sends it, which is written later than
    /// this paste.
    pub fn delivered(&mut self) {
        if !self.letters.is_empty() {
            self.letters.remove(0);
        }
        self.undelivered = None;
        if self.letters.is_empty() {
            self.letters_shown = false;
        }
    }

    /// Shows the waiting messages, or hides them.
    pub fn show_letters(&mut self, shown: bool) {
        self.letters_shown = shown;
    }

    /// Takes every waiting message out of the tab, oldest first, because its agent asked for them
    /// from its inbox: they are delivered by being handed over, and none of them is typed in.
    pub fn take_letters(&mut self) -> Vec<Letter> {
        self.letters_shown = false;
        self.undelivered = None;
        std::mem::take(&mut self.letters)
    }

    /// Throws the waiting messages away.
    pub fn discard_letters(&mut self) {
        self.letters.clear();
        self.letters_shown = false;
        self.undelivered = None;
    }

    /// The other tab of the exchange the loop limit ended, while the tab still says so.
    #[must_use]
    pub fn stopped(&self) -> Option<&str> {
        self.stopped.as_deref()
    }

    /// Records that the loop limit ended this tab's exchange with the tab named `other`.
    pub fn stop(&mut self, other: String) {
        self.stopped = Some(other);
    }

    /// Stops saying that an exchange was ended, once the person has read it.
    pub fn unstop(&mut self) {
        self.stopped = None;
    }

    /// Turns a blank tab into a tab of `kind` showing `conversation`, opened now and waiting for
    /// its container. The key stays, so the tab keeps its place in the strip.
    pub fn choose(&mut self, kind: TabKind, conversation: Option<String>) {
        // The tab stays the same tab to the agents and the person: its id and its name go with it.
        let (key, number, name) = (self.key, self.number, self.name.take());
        *self = Self { conversation, number, name, ..Self::new(key, kind) };
    }

    /// Records that the tab shows `conversation`, once that is known, so the session file keeps
    /// it and the tab opens it again next time.
    pub fn show_conversation(&mut self, conversation: String) {
        self.conversation = Some(conversation);
    }

    /// Puts the tab back to waiting for its container and gives up the session it had, which
    /// ends the program still attached to it.
    pub fn restarting(&mut self) {
        self.close_session();
        self.stop_listening();
        self.state = TabState::Starting;
        self.run += 1;
    }

    /// The tab builds its profile's image in `task`; the log starts empty and the silence starts
    /// now, since a build that has just begun has said something.
    pub fn building(&mut self, task: TaskId) {
        self.build_log.clear();
        self.state = TabState::Building(task);
        self.spoke();
    }

    /// Adds a line the image build said to the tab's log, which is also what ends the silence: a
    /// build that is saying things is not one to warn about.
    pub fn build_line(&mut self, text: &str, failed: bool) {
        let level = if failed { LogLevel::Error } else { LogLevel::Info };
        self.build_log.push(LogLine::new(level, text));
        self.spoke();
    }

    /// What the image build said so far.
    #[must_use]
    pub fn build_log(&self) -> &LogBuffer {
        &self.build_log
    }

    /// Whether the tab is building its profile's image.
    #[must_use]
    pub fn is_building(&self) -> bool {
        matches!(self.state, TabState::Building(_))
    }

    /// Whether the build has said nothing for longer than `quiet` as of `now`, which is what the
    /// page says beside it. A tab that is not building says no whatever its silence is: there is
    /// no build to be stuck.
    pub fn build_looked(&mut self, now: Instant, quiet: Duration) {
        self.build_stuck = self.is_building() && stalling::quiet_for(self.build_said, now, quiet);
    }

    /// Whether the build has been quiet long enough to be said to be stuck.
    #[must_use]
    pub fn is_stuck(&self) -> bool {
        self.build_stuck
    }

    /// Notes that the build has said something, so that the silence is counted from this moment and
    /// the warning beside it goes away.
    fn spoke(&mut self) {
        self.build_said = Instant::now();
        self.build_stuck = false;
    }

    /// Starts a tab that was waiting to be shown: it now waits for its container instead.
    pub fn wake(&mut self) {
        self.state = TabState::Starting;
    }

    /// Attaches `session` and marks the tab as running.
    pub fn attached(&mut self, session: TerminalSession) {
        self.own_input = Some(session.last_input());
        self.session = Some(session);
        self.state = TabState::Running;
    }

    /// Takes the text of a Markdown tab's file, or of a PDF, and shows it; `partial` says it
    /// was cut short.
    pub fn read(&mut self, text: String, partial: bool) {
        self.document = Some(text);
        self.partial = partial;
        self.state = TabState::Running;
    }

    /// Moves the tab to `state`, keeping the session so its last screen stays readable: a tab
    /// that says the container stopped still shows what the harness printed before it did.
    pub fn settled(&mut self, state: TabState) {
        // A window that is not open has nobody to carry a sign-in to.
        if state != TabState::Running {
            self.stop_listening();
        }
        self.state = state;
    }

    /// Ends the tab's session, which is what closing a tab or restarting it does. The container
    /// itself is left alone: other tabs and other workspaces may be using it.
    ///
    /// A Return owed to the program that is ending is given up with it: what is left in a prompt
    /// nobody will read is not a message the tab still holds, so a message whose Return could not
    /// be written is the only one that comes back, and it has come back by then.
    pub fn close_session(&mut self) {
        self.owed = None;
        if let Some(session) = self.session.take() {
            session.kill();
        }
    }
}