@softov/ahpc 0.1.0

package/dist/src/state.js

@@ -0,0 +1,531 @@
+import { byUrgency, decodeStatus } from './ahp/status.js';
+/**
+ * Where the conversation lives, and how the host's actions get there.
+ *
+ * The store is the only state. Everything the host says is folded in here, and
+ * every screen reads it back out - so the transcript, the sessions list, the
+ * status bar and the composer are all looking at one answer to "what is
+ * happening", and a turn that finishes updates all four without any of them
+ * knowing the others exist.
+ *
+ * Nothing in this file renders. That is the whole point of it being a file.
+ */
+export const HOST = '$/chat/host';
+export const SESSIONS = '$/chat/sessions';
+/** The open conversation. One at a time, so it is not keyed by session. */
+export const TURNS = '$/chat/conv/turns';
+export const INPUT = '$/chat/conv/input';
+export const CHANGES = '$/chat/conv/changes';
+/**
+ * What the host handed the open session: plugins, skills, MCP servers.
+ *
+ * On the conversation rather than the catalogue, because that is where the
+ * protocol puts it - two sessions on the same host, opened in different
+ * directories, are given different skills, so there is no host-wide answer to
+ * cache. Read when a panel that shows them opens.
+ */
+export const CUSTOMIZATIONS = '$/chat/conv/customizations';
+/**
+ * Who else is in the open session.
+ *
+ * Host-kept membership from `SessionState.activeClients`, including this
+ * client, which adds itself on opening the view. A session nobody else is in
+ * is the ordinary case and shows nothing.
+ */
+export const PRESENT = '$/chat/conv/present';
+/** Which file of the changeset is open, by uri. Null is the list. */
+export const OPEN_FILE = '$/chat/conv/file';
+/**
+ * Which changesets this session offers, and which one is on screen.
+ *
+ * The session advertises several - what the conversation changed, what one
+ * turn changed, what the working tree has - and drawing the first that needs
+ * no filling in was drawing one and hiding the rest. `CHANGE_AT` is the
+ * chosen changeset's own URI, or empty for "whichever the host would pick".
+ */
+export const CHANGE_SCOPES = '$/chat/conv/scopes';
+export const CHANGE_AT = '$/chat/conv/scope';
+/** The row the cursor is on, so a key can act on it. */
+export const CHANGE_ROW = '$/chat/conv/row';
+/**
+ * Where the file browser is looking, and what it found.
+ *
+ * The host's filesystem, not this machine's. `FILES_AT` is a `file://`
+ * directory URI on the host; empty means the session's own workspace, which is
+ * the only directory a client can name without having listed something first.
+ */
+export const FILES_AT = '$/chat/files/at';
+export const FILES_ENTRIES = '$/chat/files/entries';
+export const FILES_OPEN = '$/chat/files/open';
+/**
+ * The automations screen: what the host holds, and which row the cursor is on.
+ *
+ * The host's, not a session's - an automation outlives every session it
+ * starts, and belongs to the host the way the catalogue does.
+ */
+export const AUTOMATIONS = '$/chat/automations/all';
+export const AUTOMATION_ROW = '$/chat/automations/row';
+export const STATUS = '$/chat/conv/status';
+/**
+ * Is there a turn to stop, as a `when` clause can ask it.
+ *
+ * The status is a bitset carrying client flags as well as activity - an idle
+ * session that has been read is 33 - so "status > 1" is not "something is
+ * happening", it is "something is happening, or somebody looked at it". The
+ * decoding belongs in one place, and a clause cannot call it, so the answer is
+ * written beside the number.
+ */
+export const RUNNING = '$/chat/conv/running';
+/**
+ * What the next message will be sent as.
+ *
+ * Not a session's state, and deliberately not keyed by session: it is the
+ * composer's own row of choices, which exists before there is a session to
+ * hang them on. Sending is what turns them into one - a `createSession` with
+ * the harness and the workspace, and a `chat/turnStarted` carrying the model,
+ * because AHP hangs the model on the message rather than on the session.
+ */
+export const PROVIDER = '$/chat/compose/provider';
+export const MODEL = '$/chat/compose/model';
+/**
+ * The answers to the chosen model's own questions.
+ *
+ * A model carries a `configSchema` and the protocol says a client presents it
+ * as a form and returns the resolved values in `ModelSelection.config`. Kept
+ * beside the model rather than in `SETTINGS`, because they are two different
+ * documents answered separately: the session's schema is the host's, this one
+ * is the model's, and a model that changes takes its answers with it.
+ */
+export const MODEL_CONFIG = '$/chat/compose/modelConfig';
+/**
+ * The chat the open session dispatches to.
+ *
+ * A session is not a conversation - it holds chats - and the uri of the one
+ * being read is what gets pasted into a shell or a bug report. Held because
+ * only `detail` knows it, and asking again to draw a caption is a round trip
+ * for something that does not change.
+ */
+export const CHAT_URI = '$/chat/conv/chat';
+/**
+ * The open session's chats.
+ *
+ * A session is a container: it holds chats, and which of them is being read
+ * is `CHAT_URI`. One chat is the ordinary case and the row that shows this is
+ * hidden then - a list of one is a list nobody needs.
+ */
+export const CHATS = '$/chat/conv/chats';
+/**
+ * Whether the open session's agent can hold another chat.
+ *
+ * A path rather than a check, because that is what gates a command: `when`
+ * reads the store, and a host that does not advertise `multipleChats` is one
+ * where `createChat` MUST NOT be called - so the command is not offered.
+ */
+/** The terminals the host is running. The host's list, not any session's. */
+export const TERMINALS = '$/chat/term/all';
+/** Which of them is being read. */
+export const OPEN_TERMINAL = '$/chat/term/open';
+/** Its state. Null while nothing has been read yet, which is not the same as empty. */
+export const TERMINAL = '$/chat/term/state';
+export const CAN_ADD_CHAT = '$/chat/conv/canAddChat';
+/**
+ * Whether this session's agent can fork a chat, and whether it can hold a side
+ * chat.
+ *
+ * Two paths rather than one, because `capabilities.multipleChats` carries the
+ * two separately and a host may advertise one without the other. A command
+ * offered where the host will refuse it is worse than one that is not there.
+ */
+export const CAN_FORK = '$/chat/conv/canFork';
+export const CAN_SIDE_CHAT = '$/chat/conv/canSideChat';
+/** Whether the open session has more than one chat to move between. */
+export const HAS_CHATS = '$/chat/conv/hasChats';
+export const WORKSPACE = '$/chat/compose/workspace';
+/**
+ * Everything else the host asks about, keyed by the host's own keys.
+ *
+ * Not one path per setting: the settings are whatever the harness advertises,
+ * and this client had a `permissions` path because the *fixture* called its
+ * key `permissionMode`. A real host's keys are `isolation`, `autoApprove` and
+ * `mode`, so the row of chips read every one of them as absent - a control
+ * naming a key is a control that works against one host.
+ */
+export const SETTINGS = '$/chat/compose/settings';
+/** What the host last refused, in the host's own words. Cleared by success. */
+export const HOST_ERROR = '$/chat/host/error';
+/**
+ * What became of the answer just given, on the row above the composer.
+ *
+ * Not `HOST_ERROR`, which is the application's last refusal and lives in the
+ * footer: this is about the block that is waiting on a person, and it only
+ * ever says anything between pressing a button on that block and the host
+ * letting go of the question. Both, for a refusal of *this* - the footer is
+ * twenty rows from the button that was pressed, and a person who pressed
+ * Approve and was told nothing has no reason to look down there.
+ */
+export const INPUT_STATUS = '$/chat/conv/inputStatus';
+export const OPEN = '$/chat/ui/open';
+/** Which of the bood this run got. One animal, wherever one is drawn. */
+export const BOOD = '$/chat/ui/bood';
+/**
+ * How many rows the bottom of the screen is keeping, which is the creature's
+ * floor.
+ *
+ * Published by whatever is down there rather than assumed, because it moves:
+ * the composer grows a slash menu upward, grows again with a multi-line draft,
+ * and is not on every screen at all. A constant was wrong the moment a menu
+ * opened - the figure stood at the height the composer used to be, which is
+ * inside the menu.
+ */
+export const BOOD_FLOOR = '$/chat/ui/boodFloor';
+/**
+ * The top row of one thing standing at the bottom, under its own name.
+ *
+ * A row and not a height, because a height has to be right and a row only has
+ * to be where the thing is. Adding up heights meant trusting each measurement
+ * and a guess at the chrome underneath them - and the block that asks about a
+ * tool reported seven rows while drawing ten, which put the creature inside
+ * the question it was supposed to be standing on.
+ *
+ * A subtree because there is more than one of them: the composer is down
+ * there, and the block that asks is a sibling above it rather than a part of
+ * it, so neither one knows the whole answer.
+ */
+export const boodFloorFor = (key) => `${BOOD_FLOOR}/${key}`;
+/** The highest thing standing at the bottom, or nothing standing there. */
+export function boodFloor(store) {
+    const rows = Object.values(store.get(BOOD_FLOOR) ?? {})
+        .filter((row) => typeof row === 'number' && row > 0);
+    return rows.length > 0 ? Math.min(...rows) : undefined;
+}
+/** Whether the creature roams the whole application rather than one screen. */
+export const BOOD_FLOAT = '$/chat/ui/boodFloat';
+/** Whether the header trades its own name for a seven-cell creature. */
+export const BOOD_INLINE = '$/chat/ui/boodInline';
+/** The catalogue's highlight. What a session command acts on when none is open. */
+export const SELECTED = '$/chat/ui/selected';
+export const DRAFT = '$/chat/ui/draft';
+export const QUEUE = '$/chat/ui/queue';
+export const HISTORY = '$/chat/ui/history';
+export const FILTER = '$/chat/ui/filter';
+export const ARCHIVED = '$/chat/ui/archived';
+export const EXPANDED = '$/chat/ui/expanded';
+/** What is being looked for in the open conversation. Empty means nothing is. */
+export const FIND = '$/chat/ui/find';
+/** Whether the find box is up. It stays up on an empty query, which is how it is typed into. */
+export const FINDING = '$/chat/ui/finding';
+/** Which of the matches the cursor is on, counted from zero. */
+export const FIND_AT = '$/chat/ui/findAt';
+/**
+ * Which block the transcript cursor is on.
+ *
+ * In the chat screen's own scope, so it survives a trip to the changes list
+ * and dies with the screen. Named here because the find commands move it and
+ * they do not live in the screen.
+ */
+export const CURSOR = '$/screen.chat/cursor';
+/**
+ * Whether what the agent said is drawn as markdown, or as what it typed.
+ *
+ * On, because an agent writes markdown and reading `**this**` is reading the
+ * punctuation instead of the sentence. Off is for the times the punctuation is
+ * the point: copying a fenced block out with the fence, seeing whether a table
+ * is a table or four lines that happen to have pipes in them, and reading a
+ * link's target rather than its label.
+ */
+export const MARKDOWN = '$/chat/ui/markdown';
+/**
+ * Whether the catalogue's detail pane is out, or `null` for "whatever the
+ * terminal is wide enough for".
+ *
+ * Three states rather than two, because "nobody has said" and "somebody said
+ * no" are different: the first still follows the window as it is resized, and
+ * the second has to survive a resize or the key that closed the pane would be
+ * undone by dragging the corner.
+ */
+export const SIDEBAR = '$/chat/ui/sidebar';
+/**
+ * The width at which the detail pane is out to begin with.
+ *
+ * Under it the two panes are each other's problem: forty cells of detail take
+ * the session list down to a column that cuts every title, and the detail
+ * pane they were taken for is itself too narrow to hold the URIs it exists to
+ * show. So below this the catalogue is one pane, and the detail is something
+ * you open.
+ */
+export const SPLIT_AT = '$/chat/ui/splitAt';
+export const SPLIT_DEFAULT = 140;
+/**
+ * The runtime's own state, read rather than asked for.
+ *
+ * `screens.current()` and `focus.focused()` are method calls: correct at the
+ * moment they run and attached to nothing. A surface that survives navigating -
+ * which is the whole point of a surface - has to subscribe instead, or it
+ * keeps the chrome of the screen you left.
+ */
+export const SCREEN = '$/layout/screen/current';
+export const FOCUS = '$/focus/id';
+// -------------------------------------------------------------------- writing
+/**
+ * Fold one thing the host said into the store.
+ *
+ * A delta is a word, so this runs per word during a turn. It writes the whole
+ * turn list because the store is addressed by path and a mutation in place is
+ * a change nothing can see - a real client debounces the write, which is a
+ * change here and nowhere above.
+ */
+export function applyEvent(store, event, model) {
+    switch (event.type) {
+        case 'snapshot': {
+            const next = [...event.turns, ...(event.active ? [event.active] : [])];
+            writeTurns(store, next);
+            store.set(INPUT, event.input ?? null);
+            store.set(QUEUE, event.queued);
+            writeStatus(store, event.status);
+            /*
+             * The host's draft, taken only when this client has nothing typed.
+             *
+             * `chat-channel.md` says a client SHOULD use any `draft` to initialise
+             * its input state - initialise, not follow: every keystroke here
+             * produces a debounced dispatch, and every dispatch comes back as a
+             * snapshot a moment later, so taking it always would put the cursor
+             * back where the round trip started. What is empty here has nothing to
+             * lose, which is the case the specification is describing.
+             */
+            if (event.draft !== '' && !(store.get(DRAFT) ?? ''))
+                store.set(DRAFT, event.draft);
+            // A snapshot arrived, so whatever the host last refused is not what is
+            // on screen any more.
+            store.set(HOST_ERROR, null);
+            store.set(INPUT_STATUS, null);
+            return next;
+        }
+        case 'turnStarted': {
+            const next = [...model.filter((t) => t.id !== event.turn.id), event.turn];
+            writeTurns(store, next);
+            return next;
+        }
+        case 'delta':
+        case 'toolCall':
+            // The part was mutated on the turn the model already holds; the write is
+            // what makes it visible. Rebuilding the list is what changes identity.
+            writeTurns(store, model);
+            return model;
+        case 'turnComplete': {
+            const next = model.map((turn) => (turn.id === event.turn.id ? event.turn : turn));
+            writeTurns(store, next);
+            return next;
+        }
+        case 'queued':
+            // The host's list, replacing whatever this client thought it was. Two
+            // clients queueing into the same chat is the ordinary case, not the
+            // exotic one, and the only list that is right is the one the host has.
+            store.set(QUEUE, event.messages);
+            return model;
+        case 'inputNeeded':
+            store.set(INPUT, event.input);
+            // A new question, about which nothing has been said yet. Left alone it
+            // would arrive under the last one's "Approving..." - or, worse, under
+            // the refusal that is the reason this one is being asked again.
+            store.set(INPUT_STATUS, null);
+            return model;
+        case 'inputResolved':
+            store.set(INPUT, null);
+            // The host has let go of the question, which is the answer to whatever
+            // this row was waiting to hear.
+            store.set(INPUT_STATUS, null);
+            return model;
+        case 'chats':
+            store.set(CHATS, event.items);
+            // Switching and closing need somewhere to go, which one chat is not.
+            store.set(HAS_CHATS, event.items.length > 1);
+            return model;
+        case 'customizations':
+            // The host's list, replacing whatever this client last read. It is the
+            // authority: a switch is answered there, and a server signs in there.
+            store.set(CUSTOMIZATIONS, event.items);
+            return model;
+        case 'present':
+            store.set(PRESENT, event.clients);
+            return model;
+        case 'status':
+            writeStatus(store, event.status);
+            return model;
+        case 'error':
+            // Through `reportHostError`, not straight at the path: when this is the
+            // host's answer to an answer just given, the row above the composer is
+            // where the person who gave it is looking. The footer alone left
+            // "Approving..." sitting there over a session that had stopped
+            // listening, with the reason twenty rows below it.
+            reportHostError(store, event.message);
+            return model;
+        case 'changes':
+            store.set(CHANGES, event.changes);
+            return model;
+        default:
+            return model;
+    }
+}
+/** The answer has gone to the host, which has not said anything about it yet. */
+export function sendingInput(store, text) {
+    store.set(INPUT_STATUS, { state: 'sending', text });
+}
+/** It is not going, and this is why. */
+export function inputRefused(store, text) {
+    store.set(INPUT_STATUS, { state: 'failed', text });
+}
+/**
+ * The host refused something, wherever it was asked from.
+ *
+ * The footer says so always. The block waiting on a person says so too when
+ * it was that block's answer being refused, and only then - a refusal earned
+ * by some other command has no business turning the row above the composer
+ * red, which is exactly what reading `HOST_ERROR` from there would do.
+ */
+export function reportHostError(store, message) {
+    store.set(HOST_ERROR, message);
+    if (store.get(INPUT_STATUS)?.state === 'sending')
+        inputRefused(store, message);
+}
+/** The number, and the one question everything else asks of it. */
+export function writeStatus(store, status) {
+    const activity = decodeStatus(status).activity;
+    store.set(STATUS, status);
+    store.set(RUNNING, activity === 'running' || activity === 'input');
+}
+/** A new array every time, and new part arrays inside it, or nothing redraws. */
+function writeTurns(store, turns) {
+    store.set(TURNS, turns.map((turn) => ({ ...turn, parts: [...turn.parts] })));
+}
+export function writeSessions(store, sessions) {
+    const byUri = {};
+    for (const session of sessions)
+        byUri[session.resource] = session;
+    store.set(SESSIONS, byUri);
+}
+// -------------------------------------------------------------------- reading
+export function sessions(store) {
+    const byUri = store.get(SESSIONS) ?? {};
+    return Object.values(byUri);
+}
+/**
+ * The catalogue as the list shows it.
+ *
+ * Archived is hidden rather than filtered out of existence: a session somebody
+ * put away is still a session, and the count of what is hidden is what tells
+ * the reader the list is not everything.
+ */
+export function visibleSessions(store) {
+    const query = (store.get(FILTER) ?? '').trim().toLowerCase();
+    const showArchived = store.get(ARCHIVED) ?? false;
+    return sessions(store)
+        .filter((session) => showArchived || !decodeStatus(session.status).archived)
+        .filter((session) => query === ''
+        || session.title.toLowerCase().includes(query)
+        || session.provider.includes(query)
+        || session.workingDirectories.some((dir) => dir.toLowerCase().includes(query)))
+        .sort(byUrgency);
+}
+/**
+ * How many sessions the archived switch is keeping out of the list.
+ *
+ * Zero while the switch is on, because then it is keeping none out. What it
+ * counts is the difference the switch would make: a row offering to show
+ * archived sessions where there are none to show is a row that does nothing.
+ */
+export function hiddenSessions(store) {
+    if (store.get(ARCHIVED) ?? false)
+        return 0;
+    return sessions(store).filter((session) => decodeStatus(session.status).archived).length;
+}
+export function openSession(store) {
+    const uri = store.get(OPEN);
+    if (!uri)
+        return null;
+    return (store.get(SESSIONS) ?? {})[uri] ?? null;
+}
+export function turns(store) {
+    return store.get(TURNS) ?? [];
+}
+export function pendingInput(store) {
+    return store.get(INPUT) ?? null;
+}
+export function changes(store) {
+    return store.get(CHANGES) ?? { status: 'complete', files: [] };
+}
+/** The running turn, if there is one. Never in the history until it finishes. */
+export function activeTurn(store) {
+    return turns(store).find((turn) => turn.state === 'running') ?? null;
+}
+export function queue(store) {
+    return store.get(QUEUE) ?? [];
+}
+/** A short name for a `file://` working directory. */
+export function workspaceName(uri) {
+    if (!uri)
+        return 'no workspace';
+    return uri.replace(/^file:\/\//, '').split('/').filter(Boolean).pop() ?? '/';
+}
+/**
+ * What to call the project a session is in.
+ *
+ * The host's own name when it gives one, and the last segment of the working
+ * directory when it does not - which is the same answer for most hosts and the
+ * right one for a host that names projects itself.
+ */
+export function projectName(session) {
+    return session.project?.displayName || workspaceName(session.workingDirectories[0]);
+}
+/**
+ * What a host said about git, under the well-known key in `_meta`.
+ *
+ * `_meta` is an open map, so every step down is checked: a host may put
+ * anything here, including a `git` that is not an object.
+ */
+function git(session) {
+    const found = session._meta?.git;
+    return typeof found === 'object' && found !== null && !Array.isArray(found)
+        ? found
+        : {};
+}
+function count(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+/**
+ * The branch a session's directory is on, if its host says.
+ *
+ * Two spellings, because there are two vocabularies and only one of them is
+ * written down anywhere. `branchName` is what the reference host sends and is
+ * the one to prefer; `branch` is what one other host sent until it adopted the
+ * reference's names. Neither is in the specification - `git` is a well-known
+ * key in an open map and its contents are convention - so reading only the
+ * name this client happened to meet first is how the branch row came to say
+ * "the host does not say" against a host that was saying it all along.
+ */
+export function branchName(session) {
+    const found = git(session);
+    for (const key of ['branchName', 'branch']) {
+        const name = found[key];
+        if (typeof name === 'string' && name !== '')
+            return name;
+    }
+    return undefined;
+}
+/**
+ * How far the branch has drifted, where the host counted.
+ *
+ * Ahead, behind and uncommitted, in the arrows a person reads without a
+ * legend. Zeroes are left out rather than drawn as zeroes: the interesting
+ * state is the one that is not clean, and three noughts beside every branch is
+ * three columns of nothing.
+ */
+export function branchDrift(session) {
+    const found = git(session);
+    const marks = [
+        ['\u2191', count(found.outgoingChanges)],
+        ['\u2193', count(found.incomingChanges)],
+        ['\u2022', count(found.uncommittedChanges)],
+    ];
+    const said = marks.filter(([, n]) => n > 0).map(([mark, n]) => `${mark}${n}`);
+    return said.length > 0 ? said.join(' ') : undefined;
+}

package/dist/src/terminal.d.ts

@@ -0,0 +1,44 @@
+import type { TextUIApp } from '@textui/core';
+import type { HostConnection } from './ahp/connection.js';
+/**
+ * Terminals, as operations rather than as a screen.
+ *
+ * The split is doop's: what a terminal *is* - which ones exist, which is
+ * open, what it has said, what happens when you type - lives here, and the
+ * view only draws it. The two change for different reasons, and a view that
+ * held the subscription would lose the terminal every time it was unmounted.
+ *
+ * A terminal belongs to the *host*, not to a session: it outlives the turn
+ * that opened it, several clients watch one, and the protocol lists them on
+ * the root channel. So this is the host's list and not any session's.
+ */
+export interface Terminals {
+    /** Re-read the host's list. */
+    refresh(): Promise<void>;
+    /** Open one, and read it. */
+    open(options?: {
+        cwd?: string;
+    }): Promise<void>;
+    /** Read one that already exists. */
+    read(uri: string): void;
+    /** Send what was typed. Nothing comes back but what the shell says. */
+    write(data: string): void;
+    /**
+     * Say how big the terminal is being drawn.
+     *
+     * Sent on opening one and whenever the size changes. A host that is never
+     * told wraps its output at its own default, so a wide terminal shows lines
+     * broken at eighty columns and a narrow one shows them running off.
+     * Repeats are dropped: a resize event per frame is a dispatch per frame.
+     */
+    resize(cols: number, rows: number): void;
+    /** Empty the scrollback of the open one. */
+    clear(): void;
+    /** Rename the open one. */
+    rename(title: string): void;
+    /** Kill the open one and read whatever is left. */
+    close(): Promise<void>;
+    /** Let go of the subscription. */
+    dispose(): void;
+}
+export declare function createTerminals(app: TextUIApp, host: HostConnection, report: (error: unknown) => void): Terminals;

package/dist/src/terminal.js

@@ -0,0 +1,101 @@
+import { OPEN_TERMINAL, TERMINAL, TERMINALS } from './state.js';
+export function createTerminals(app, host, report) {
+    /** The one being read. Closed and replaced, never two at once. */
+    let watching;
+    /** The last size reported, so an unchanged one is not reported again. */
+    let sized = '';
+    const list = async () => {
+        try {
+            const found = await host.terminals();
+            app.store.set(TERMINALS, found);
+            return found;
+        }
+        catch (error) {
+            report(error);
+            return [];
+        }
+    };
+    const terminals = {
+        refresh: async () => { await list(); },
+        read: (uri) => {
+            if (watching?.uri === uri)
+                return;
+            watching?.close();
+            app.store.set(OPEN_TERMINAL, uri);
+            // Null rather than an empty terminal: nothing has been read yet, and a
+            // blank screen that says "no output" is a claim rather than a wait.
+            app.store.set(TERMINAL, null);
+            const held = host.watchTerminal(uri, (state) => {
+                if (app.store.get(OPEN_TERMINAL) !== uri)
+                    return;
+                app.store.set(TERMINAL, state);
+            });
+            watching = { uri, close: held.close };
+        },
+        open: async (options) => {
+            try {
+                const uri = await host.createTerminal(options?.cwd ? { cwd: options.cwd } : {});
+                await list();
+                terminals.read(uri);
+            }
+            catch (error) {
+                report(error);
+            }
+        },
+        write: (data) => {
+            const uri = app.store.get(OPEN_TERMINAL);
+            if (!uri)
+                return;
+            host.writeTerminal(uri, data);
+        },
+        resize: (cols, rows) => {
+            const uri = app.store.get(OPEN_TERMINAL);
+            if (!uri)
+                return;
+            // The same size again is not a resize. A screen re-renders for reasons
+            // that have nothing to do with its width, and every one of them would
+            // otherwise be a dispatch.
+            const at = `${uri} ${String(cols)}x${String(rows)}`;
+            if (at === sized)
+                return;
+            sized = at;
+            host.resizeTerminal(uri, cols, rows);
+        },
+        clear: () => {
+            const uri = app.store.get(OPEN_TERMINAL);
+            if (!uri)
+                return;
+            host.clearTerminal(uri);
+        },
+        rename: (title) => {
+            const uri = app.store.get(OPEN_TERMINAL);
+            if (!uri)
+                return;
+            host.renameTerminal(uri, title);
+        },
+        close: async () => {
+            const uri = app.store.get(OPEN_TERMINAL);
+            if (!uri)
+                return;
+            watching?.close();
+            watching = undefined;
+            app.store.set(OPEN_TERMINAL, null);
+            app.store.set(TERMINAL, null);
+            try {
+                await host.disposeTerminal(uri);
+            }
+            catch (error) {
+                report(error);
+            }
+            const left = await list();
+            const next = left[0];
+            if (next)
+                terminals.read(next.resource);
+        },
+        dispose: () => {
+            watching?.close();
+            watching = undefined;
+        },
+    };
+    return terminals;
+}