janissary 0.5.0

package/dist/ssh-manager.js

@@ -0,0 +1,42 @@
+import { makeHarnessTab, distinctColor, uniqueLabel } from './tab/index.js';
+import { parseSshCommand } from './ssh.js';
+import { messageBus } from './bus.js';
+// Owns the `ssh <destination> [options…]` command: launching a real `ssh` session as a
+// full-tab PTY (reusing the harness-view tab shape, `HarnessView.destination` set). Mirrors
+// `HarnessManager` — same tab creation, focus, and PTY-spawn flow — but with no `as`/`--workspace`
+// clauses (both would collide with ssh's own argument grammar).
+export class SshManager {
+    managers;
+    constructor(managers) {
+        this.managers = managers;
+    }
+    // Handle an `ssh <destination> [options…]` command. Returns an error message to surface in
+    // the creator's transcript, or undefined once the ssh tab has been opened.
+    run(input) {
+        const parsed = parseSshCommand(input);
+        if ('error' in parsed)
+            return parsed.error;
+        return this.open(parsed.command, parsed.destination, parsed.label);
+    }
+    // Open (and focus) an ssh tab labeled after the destination's host, running `command`
+    // (the verbatim `ssh …` invocation) in the creator's cwd.
+    open(command, destination, label_) {
+        const creator = this.managers.tab.cur();
+        const label = uniqueLabel(this.managers.tab.tabs, label_);
+        const cwd = this.managers.tab.cwdOf(creator.label) ?? process.cwd();
+        const dotColor = distinctColor(this.managers.tab.tabs.map((t) => t.dotColor));
+        const group = creator?.group ?? 1;
+        const groupColor = creator?.groupColor ?? dotColor;
+        const harness = { name: 'ssh', program: 'ssh', ptyId: '', status: 'running', destination };
+        const tab = makeHarnessTab(label, dotColor, this.managers.tab.tabs.length + 1, group, groupColor, harness);
+        this.managers.tab.insertTabInGroup(tab);
+        this.managers.tab.activeTab = this.managers.tab.findIndex(tab.label);
+        const id = this.managers.pty.spawn(label, 'ssh', command, cwd);
+        this.managers.harness.registerScreenReader(id);
+        const liveTab = this.managers.tab.tabs.find((t) => t.label === label);
+        if (liveTab?.harness)
+            liveTab.harness.ptyId = id;
+        messageBus.emit('state', { type: 'dirty' });
+        return undefined;
+    }
+}

package/dist/ssh.js

@@ -0,0 +1,39 @@
+// OpenSSH flags that take a following value, so the token after them is never mistaken for the
+// destination (e.g. `ssh -p 2222 -i ~/.ssh/id admin@host` must still find `admin@host`).
+const VALUE_FLAGS = new Set(['-B', '-b', '-c', '-D', '-E', '-e', '-F', '-I', '-i', '-J', '-L', '-l', '-m', '-O', '-o', '-p', '-Q', '-R', '-S', '-W', '-w']);
+const SCHEME = /^ssh:\/\//i;
+const USER_PREFIX = /^[^@]*@/;
+const PORT_SUFFIX = /:\d+$/;
+const USAGE = 'Usage: ssh <destination> [ssh options].';
+// Find the first non-option token in an `ssh` command's arguments, skipping any flag and (for
+// value-taking flags) the value that follows it.
+function findDestination(tokens) {
+    let i = 0;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        if (token.startsWith('-')) {
+            i += VALUE_FLAGS.has(token) ? 2 : 1;
+            continue;
+        }
+        return token;
+    }
+    return undefined;
+}
+/**
+ * Parse an `ssh <destination> [ssh options…]` command. `command` is the input verbatim
+ * (trimmed), spawned as-is — every flag, `user@host`, port, jump host, or trailing remote
+ * command works without modeling ssh's own CLI grammar. `destination` is the connection
+ * identity (scheme stripped, if any); `label` is its bare host, used as the tab label.
+ */
+export function parseSshCommand(input) {
+    const trimmed = input.trim();
+    const rest = trimmed.replace(/^ssh\b\s*/i, '').trim();
+    if (!rest)
+        return { error: USAGE };
+    const destinationToken = findDestination(rest.split(/\s+/));
+    if (!destinationToken)
+        return { error: USAGE };
+    const destination = destinationToken.replace(SCHEME, '');
+    const label = destination.replace(USER_PREFIX, '').replace(PORT_SUFFIX, '');
+    return { command: trimmed, destination, label };
+}

package/dist/startup-errors.js

@@ -0,0 +1,21 @@
+import { appVersion } from './cli-args.js';
+export function explainStartupError(error, context = {}) {
+    const code = error?.code;
+    const port = context.port === undefined ? 'the requested port' : String(context.port);
+    if (code === 'EADDRINUSE') {
+        return `port ${port} is already in use.\n  Another janus (or other app) is listening there. Pick another port with --port=<n>,\n  or omit --port to choose a free port automatically.`;
+    }
+    if (code === 'EACCES') {
+        return `permission denied binding to port ${port}.\n  Ports below 1024 need elevated privileges. Pick a port above 1024 with --port=<n>.`;
+    }
+    return null;
+}
+export function formatFatal(message) {
+    return `${appVersion()} — failed to start: ${message}`;
+}
+export function maybeStack(error) {
+    if (!process.env.JANUS_DEBUG)
+        return '';
+    const stack = error instanceof Error ? error.stack : undefined;
+    return stack ? `${stack}\n` : '';
+}

package/dist/state-event.js

@@ -0,0 +1,14 @@
+import { getConfig } from './config.js';
+import { globalCommands } from './global-history.js';
+import { listTasks } from './tasks.js';
+import { listProfiles } from './profiles.js';
+// Full state snapshot sent on `init` and whenever anything changes — shared by index.ts's
+// broadcast-driving emitState and message-handler.ts's `init` reply.
+export function buildStateEvent(controller) {
+    return {
+        t: 'state', tabs: controller.view(), activeTab: controller.managers.tab.activeTab,
+        route: controller.routeView(), tabNameMaxLength: getConfig().tabNameMaxLength,
+        globalHistory: globalCommands(), syntaxTheme: getConfig().syntaxTheme, theme: getConfig().theme, tasks: listTasks(),
+        profiles: listProfiles(), projectDir: controller.rootDir,
+    };
+}

package/dist/state-format.js

@@ -0,0 +1,38 @@
+// Format an agent's persisted state for the `state` command (ported from commands/state.ts).
+function formatValue(v, maxLines = 10) {
+    if (v === undefined || v === null)
+        return '<empty>';
+    if (typeof v === 'string')
+        return v || '<empty>';
+    if (typeof v === 'boolean' || typeof v === 'number')
+        return String(v);
+    if (Array.isArray(v)) {
+        if (v.length === 0)
+            return '<empty>';
+        const lines = v.flatMap((item) => {
+            if (typeof item === 'object' && item !== null) {
+                const entry = item;
+                return [
+                    `> ${entry.input ?? ''}`,
+                    ...(typeof entry.output === 'string' && entry.output ? entry.output.split('\n').map((l) => `  ${l}`) : ['  <empty>']),
+                ];
+            }
+            return [`  - ${JSON.stringify(item)}`];
+        });
+        if (lines.length <= maxLines)
+            return lines.join('\n');
+        return `... (${lines.length - maxLines} lines omitted)\n${lines.slice(-maxLines).join('\n')}`;
+    }
+    if (typeof v === 'object') {
+        const lines = Object.entries(v).map(([k, value]) => `  ${k}: ${formatValue(value)}`);
+        if (lines.length <= maxLines)
+            return lines.join('\n');
+        return `... (${lines.length - maxLines} lines omitted)\n${lines.slice(-maxLines).join('\n')}`;
+    }
+    return String(v);
+}
+export function formatState(label, state) {
+    if (!state)
+        return `No state file found for "${label}".`;
+    return Object.entries(state).map(([k, v]) => `${k}:\n${formatValue(v)}`).join('\n\n');
+}

package/dist/syntax-themes.js

@@ -0,0 +1,14 @@
+// Names of the syntax-highlighting themes available for `syntax theme <name>`. Shared between the
+// server (persisted config, command validation) and the web client (theme CSS lookup) via the
+// `@shared` alias, so this file must stay free of Node imports.
+export const SYNTAX_THEMES = [
+    'github-dark',
+    'github',
+    'atom-one-dark',
+    'atom-one-light',
+    'monokai',
+    'nord',
+    'vs2015',
+    'tokyo-night-dark',
+];
+export const DEFAULT_SYNTAX_THEME = 'github-dark';

package/dist/tab/agent-state.js

@@ -0,0 +1,19 @@
+// Assembles the persisted-state snapshot for one tab — the shape saved to disk and restored by
+// rehydrate() (see tab-rehydrate.ts) — from the tab itself plus the manager's per-label maps.
+export function buildAgentStateFromTab(tab, busy, cwd, context, commandQueue, extra) {
+    return {
+        name: tab.label,
+        dotColor: tab.dotColor,
+        active: busy,
+        number: tab.number,
+        group: tab.group,
+        groupColor: tab.groupColor,
+        cmdHistory: tab.cmdHistory,
+        cwd,
+        context,
+        commandQueue,
+        title: tab.title,
+        offline: tab.offline,
+        ...extra,
+    };
+}

package/dist/tab/cleanup.js

@@ -0,0 +1,33 @@
+import { messageBus } from '../bus.js';
+export function closeTabResources(tab, managers, openFiles, context, queue, tabsLength) {
+    // Remove the workspace clone in the background: it is a recursive rmSync of a full git clone,
+    // slow enough to freeze the UI if run inline (the tab can't visibly close until it finishes).
+    // Deferring it lets the tab close and the state broadcast reach the client first. The clone stays
+    // tracked until `remove` runs, so a shutdown before this fires still cleans it up via removeAll().
+    if (tab.workspaceDir) {
+        const workspaceDir = tab.workspaceDir;
+        setTimeout(() => managers.workspace.remove(workspaceDir), 0);
+    }
+    managers.shell.close(tab.label);
+    managers.acp.close(tab.label);
+    managers.browser.closeTab(tab.label);
+    managers.pty.closeTab(tab.label);
+    managers.tab.deleteBusy(tab.label);
+    managers.fileTree.closeTab(tab.label);
+    managers.editorWatch.closeTab(tab.label);
+    managers.schedule.delete(tab.label);
+    managers.database.forgetTab(tab.label);
+    if (tabsLength <= 1)
+        managers.database.closeAll();
+    messageBus.emit('transcript', { type: 'tab:removed', tabLabel: tab.label });
+    if (tab.image) {
+        const id = tab.image.url.replace(/^\/open\//, '');
+        openFiles.delete(id);
+    }
+    if (tab.markdown) {
+        const id = tab.markdown.url.replace(/^\/open\//, '');
+        openFiles.delete(id);
+    }
+    context.delete(tab.label);
+    queue.delete(tab.label);
+}

package/dist/tab/colors.js

@@ -0,0 +1,43 @@
+export const dotColors = [
+    '#5b9cff', '#ff6b6b', '#ffd93d', '#6bcb77', '#4d96ff',
+    '#ff8a5c', '#a66cff', '#ff6f91', '#00d2d3', '#f368e0',
+    '#ff9f43', '#54a0ff', '#5f27cd', '#01a3a4', '#ee5a24',
+];
+const COLOR_MIN_DIST = 110;
+function hexToRgb(hex) {
+    if (!hex)
+        return undefined;
+    const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+    if (!m)
+        return undefined;
+    const n = Number.parseInt(m[1], 16);
+    return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+function colorDistance(a, b) {
+    const rmean = (a[0] + b[0]) / 2;
+    const dr = a[0] - b[0], dg = a[1] - b[1], db = a[2] - b[2];
+    return Math.sqrt((2 + rmean / 256) * dr * dr + 4 * dg * dg + (2 + (255 - rmean) / 256) * db * db);
+}
+function nearestUsedDistance(color, used) {
+    const rgb = hexToRgb(color);
+    if (!rgb)
+        return 0;
+    if (used.length === 0)
+        return Infinity;
+    return Math.min(...used.map((u) => colorDistance(rgb, u)));
+}
+export function distinctColor(used, preferred) {
+    const usedRgb = [...used].map((c) => hexToRgb(c)).filter((c) => c !== undefined);
+    if (preferred && nearestUsedDistance(preferred, usedRgb) >= COLOR_MIN_DIST)
+        return preferred;
+    let best = dotColors[0];
+    let bestDist = -1;
+    for (const c of dotColors) {
+        const d = nearestUsedDistance(c, usedRgb);
+        if (d > bestDist) {
+            bestDist = d;
+            best = c;
+        }
+    }
+    return best;
+}

package/dist/tab/creators.js

@@ -0,0 +1,95 @@
+import { makeImageTab, makeMarkdownTab, makeEditorTab, makePageTab, makeFilesTab, makeNotificationsTab, distinctColor, insertTabInGroup, } from './index.js';
+import { NOTIFICATIONS_LABEL } from '../notifications-tab.js';
+import { getConfig } from '../config.js';
+function uniqueLabel(used, prefix) {
+    if (!used.has(prefix))
+        return prefix;
+    let n = 2;
+    while (used.has(`${prefix}-${n}`))
+        n++;
+    return `${prefix}-${n}`;
+}
+export function uniqueImageLabel(tabs) {
+    return uniqueLabel(new Set(tabs.map((t) => t.label)), 'image');
+}
+export function uniqueMarkdownLabel(tabs) {
+    return uniqueLabel(new Set(tabs.map((t) => t.label)), 'markdown');
+}
+export function uniqueEditorLabel(tabs) {
+    return uniqueLabel(new Set(tabs.map((t) => t.label)), 'editor');
+}
+export function uniqueFilesLabel(tabs) {
+    return uniqueLabel(new Set(tabs.map((t) => t.label)), 'navigator');
+}
+export function uniquePageNumber(tabs) {
+    const used = new Set(tabs.filter((t) => t.page).map((t) => t.page.number));
+    let n = 1;
+    while (used.has(n))
+        n++;
+    return n;
+}
+export function addImageTab(tabs, activeTab, image) {
+    const creator = tabs[activeTab];
+    const label = uniqueImageLabel(tabs);
+    const dotColor = distinctColor(tabs.map((t) => t.dotColor));
+    const group = creator?.group ?? 1;
+    const groupColor = creator?.groupColor ?? dotColor;
+    const tab = makeImageTab(label, dotColor, tabs.length + 1, group, groupColor, image);
+    tab.title = image.name.slice(0, getConfig().tabNameMaxLength);
+    const newTabs = insertTabInGroup(tabs, tab);
+    return { tabs: newTabs, activeTab: newTabs.findIndex((t) => t.label === label) };
+}
+function finalizeTab(tabs, tab, label, title) {
+    tab.title = title.slice(0, getConfig().tabNameMaxLength);
+    const newTabs = insertTabInGroup(tabs, tab);
+    return { tabs: newTabs, activeTab: newTabs.findIndex((t) => t.label === label) };
+}
+export function addMarkdownTab(tabs, activeTab, view) {
+    const creator = tabs[activeTab];
+    const label = uniqueMarkdownLabel(tabs);
+    const dotColor = distinctColor(tabs.map((t) => t.dotColor));
+    const group = creator?.group ?? 1;
+    const groupColor = creator?.groupColor ?? dotColor;
+    const tab = makeMarkdownTab(label, dotColor, tabs.length + 1, group, groupColor, view);
+    return finalizeTab(tabs, tab, label, view.name);
+}
+export function addEditorTab(tabs, activeTab, view) {
+    const creator = tabs[activeTab];
+    const label = uniqueEditorLabel(tabs);
+    const dotColor = distinctColor(tabs.map((t) => t.dotColor));
+    const group = creator?.group ?? 1;
+    const groupColor = creator?.groupColor ?? dotColor;
+    const tab = makeEditorTab(label, dotColor, tabs.length + 1, group, groupColor, view);
+    return finalizeTab(tabs, tab, label, view.name);
+}
+export function addFilesTab(tabs, activeTab, view) {
+    const creator = tabs[activeTab];
+    const label = uniqueFilesLabel(tabs);
+    const dotColor = distinctColor(tabs.map((t) => t.dotColor));
+    const group = creator?.group ?? 1;
+    const groupColor = creator?.groupColor ?? dotColor;
+    const tab = makeFilesTab(label, dotColor, tabs.length + 1, group, groupColor, view);
+    const newTabs = insertTabInGroup(tabs, tab, 'start');
+    return { tabs: newTabs, activeTab: newTabs.findIndex((t) => t.label === label) };
+}
+export function addNotificationsTab(tabs, activeTab) {
+    const creator = tabs[activeTab];
+    const dotColor = distinctColor(tabs.map((t) => t.dotColor));
+    const group = creator?.group ?? 1;
+    const groupColor = creator?.groupColor ?? dotColor;
+    const tab = makeNotificationsTab(NOTIFICATIONS_LABEL, dotColor, tabs.length + 1, group, groupColor);
+    const newTabs = insertTabInGroup(tabs, tab, 'start');
+    return { tabs: newTabs, activeTab: newTabs.findIndex((t) => t.label === NOTIFICATIONS_LABEL) };
+}
+export function addPageTab(tabs, activeTab, url, domain) {
+    const creator = tabs[activeTab];
+    const number = uniquePageNumber(tabs);
+    const label = `page-${number}`;
+    const dotColor = distinctColor(tabs.map((t) => t.dotColor));
+    const group = creator?.group ?? 1;
+    const groupColor = creator?.groupColor ?? dotColor;
+    const page = { url, domain, number };
+    const tab = makePageTab(label, dotColor, tabs.length + 1, group, groupColor, page);
+    const newTabs = insertTabInGroup(tabs, tab);
+    return { tabs: newTabs, activeTab: newTabs.findIndex((t) => t.label === label) };
+}

package/dist/tab/dock.js

@@ -0,0 +1,35 @@
+// Resolves docking a tab into a sidebar (`'left'` | `'right'`), or undocking it back to the
+// center strip (`null`, which also makes it the active tab). Docking into a side that already
+// holds a tab of the *same view kind* displaces that occupant back to center (non-destructive —
+// nothing closes); a different-kind occupant (the file navigator and notifications tab share a
+// sidebar via the client's own tab-switcher) is left docked. Mutates `tab.dock`/`tab.hasUnread`
+// in place (matching the rest of TabManager's per-tab field mutation) and returns the active tab
+// index the caller should adopt. `recordLeavingActiveTab` is invoked exactly where the caller's
+// focus-history bookkeeping expects it — right before the active tab actually changes.
+export function applyDock(tabs, activeTab, index, dock, recordLeavingActiveTab) {
+    const tab = tabs[index];
+    if (!tab)
+        return activeTab;
+    if (dock === null) {
+        tab.dock = undefined;
+        recordLeavingActiveTab(index);
+        tab.hasUnread = false;
+        return index;
+    }
+    const occupant = tabs.find((t, i) => i !== index && t.dock === dock && t.view === tab.view);
+    if (occupant)
+        occupant.dock = undefined;
+    tab.dock = dock;
+    return activeTab === index ? nearestNonDocked(tabs, activeTab, recordLeavingActiveTab) : activeTab;
+}
+function nearestNonDocked(tabs, activeTab, recordLeavingActiveTab) {
+    const total = tabs.length;
+    for (let step = 0; step < total; step++) {
+        const index = (activeTab + step) % total;
+        if (!tabs[index]?.dock) {
+            recordLeavingActiveTab(index);
+            return index;
+        }
+    }
+    return activeTab;
+}

package/dist/tab/focus-history.js

@@ -0,0 +1,41 @@
+// Tracks which tab was active before the current one, so closing or undocking a tab can restore
+// focus to its predecessor rather than just clamping to the nearest surviving index. Pure
+// operations on the `tabs`/`focusHistory` state; TabManager owns the state itself.
+// Records that `activeTab` is about to stop being active in favor of `newIndex`, so closing
+// `newIndex` later can restore focus to it. No-ops (returns `focusHistory` unchanged) if
+// `newIndex` is already active.
+export function recordLeavingActiveTab(tabs, activeTab, focusHistory, newIndex) {
+    if (newIndex === activeTab)
+        return focusHistory;
+    const leaving = tabs[activeTab]?.label;
+    if (!leaving)
+        return focusHistory;
+    return [...focusHistory.filter((l) => l !== leaving), leaving];
+}
+// Pops the most recent still-valid (existing, non-docked) label off the focus-history stack,
+// discarding any stale entries (closed or since-docked tabs) along the way. Returns the resolved
+// tab index (or `undefined` if none remain) and the history with all consumed entries removed.
+export function popFocusHistory(tabs, focusHistory) {
+    const history = [...focusHistory];
+    while (history.length > 0) {
+        const label = history.pop();
+        const index = tabs.findIndex((t) => t.label === label);
+        if (index !== -1 && !tabs[index].dock)
+            return { index, history };
+    }
+    return { index: undefined, history };
+}
+// The label of the file-tree tab to retarget when the metadata-row 📁 button is clicked: the
+// most-recently-left still-open `view === 'files'` tab. Scans `focusHistory` from most-recent to
+// least-recent without mutating it and — unlike `popFocusHistory` — includes docked tabs, since a
+// docked file navigator is a valid retarget target. Falls back to the first `view === 'files'`
+// tab in `tabs` order (e.g. a tree that never lost focus since opening); returns `undefined` when
+// no file-tree tab exists.
+export function mostRecentFileTreeLabel(tabs, focusHistory) {
+    for (let i = focusHistory.length - 1; i >= 0; i--) {
+        const tab = tabs.find((t) => t.label === focusHistory[i]);
+        if (tab?.view === 'files')
+            return tab.label;
+    }
+    return tabs.find((t) => t.view === 'files')?.label;
+}

package/dist/tab/formatting-handlers.js

@@ -0,0 +1,77 @@
+import { formatMessageContent, tryCollapseToolSteps } from '../buffer.js';
+export function expandTabs(text, tabWidth = 8) {
+    if (!text.includes('\t'))
+        return text;
+    let col = 0;
+    let out = '';
+    for (const ch of text) {
+        if (ch === '\t') {
+            const spaces = tabWidth - (col % tabWidth);
+            out += ' '.repeat(spaces);
+            col += spaces;
+        }
+        else {
+            out += ch;
+            col += ch === '\n' ? 0 : 1;
+        }
+    }
+    return out;
+}
+export function handleCollapsedToolSteps(log, index, lines, shouldCollapseToolSteps) {
+    if (!shouldCollapseToolSteps)
+        return { handled: false, newIndex: index };
+    const collapse = tryCollapseToolSteps(log, index);
+    if (!collapse)
+        return { handled: false, newIndex: index };
+    if (lines.length > 0)
+        lines.push({ type: 'spacer', text: '' });
+    lines.push({
+        type: 'collapsed',
+        text: `${collapse.count} tool step${collapse.count === 1 ? '' : 's'}`,
+        acp: true,
+    });
+    return { handled: true, newIndex: collapse.newIndex };
+}
+export function handleTerminalEntry(entry, lines) {
+    if (!entry.terminal)
+        return false;
+    if (lines.length > 0)
+        lines.push({ type: 'spacer', text: '' });
+    lines.push({ type: 'terminal', text: '', terminal: entry.terminal });
+    return true;
+}
+export function handleMessageEntry(entry, lines) {
+    if (!entry.from)
+        return false;
+    if (lines.length > 0)
+        lines.push({ type: 'spacer', text: '' });
+    const parts = entry.output.split('\n');
+    lines.push(...formatMessageContent(entry, parts));
+    return true;
+}
+export function handleInputOutput(entry, lines) {
+    if (!entry.input && !entry.output)
+        return false;
+    if (lines.length > 0)
+        lines.push({ type: 'spacer', text: '' });
+    if (entry.input) {
+        lines.push({
+            type: 'prompt',
+            text: expandTabs(entry.input),
+            cwd: entry.cwd,
+            acp: entry.acp,
+            running: entry.running,
+        });
+    }
+    if (entry.output) {
+        if (entry.markdown) {
+            lines.push({ type: 'markdown', text: entry.output });
+        }
+        else {
+            for (const outLine of entry.output.split('\n')) {
+                lines.push({ type: 'output', text: expandTabs(outLine), acp: entry.acp });
+            }
+        }
+    }
+    return true;
+}

package/dist/tab/formatting.js

@@ -0,0 +1,21 @@
+import { handleCollapsedToolSteps, handleTerminalEntry, handleMessageEntry, handleInputOutput } from './formatting-handlers.js';
+export { expandTabs } from './formatting-handlers.js';
+export { wordWrap } from '../word-wrapping.js';
+export function flattenBuffer(log, shouldCollapseToolSteps = false) {
+    const lines = [];
+    for (let index = 0; index < log.length; index++) {
+        const entry = log[index];
+        const collapsed = handleCollapsedToolSteps(log, index, lines, shouldCollapseToolSteps);
+        if (collapsed.handled) {
+            index = collapsed.newIndex;
+            continue;
+        }
+        if (handleTerminalEntry(entry, lines))
+            continue;
+        if (handleMessageEntry(entry, lines))
+            continue;
+        if (handleInputOutput(entry, lines))
+            continue;
+    }
+    return lines;
+}

package/dist/tab/history.js

@@ -0,0 +1,14 @@
+import { stripComments } from './index.js';
+// Appends `text` (after stripping shell comments) to `tab`'s command history, deduping an
+// immediate repeat and capping at 100 entries, and resets the history-scroll cursor. Returns the
+// stripped text for the caller to actually run.
+export function recordHistory(tab, text) {
+    const trimmed = stripComments(text);
+    if (tab) {
+        if (trimmed && tab.cmdHistory.at(-1) !== trimmed) {
+            tab.cmdHistory = [...tab.cmdHistory, trimmed].slice(-100);
+        }
+        tab.cmdHistoryIdx = -1;
+    }
+    return trimmed;
+}

package/dist/tab/index.js

@@ -0,0 +1,65 @@
+export { expandTabs, wordWrap, flattenBuffer } from './formatting.js';
+export { distinctColor, dotColors } from './colors.js';
+export { stripComments, renumberTabs, canMoveTab, swapTabsLeft, swapTabsRight, insertTabInGroup, uniqueLabel } from './utils.js';
+export const makeTab = (label, dotColor, number = 1, commandHistory = [], log = [], workspaceDirectory, group = 1, groupColor = dotColor) => ({
+    label,
+    dotColor,
+    number,
+    group,
+    groupColor,
+    log,
+    cmdHistory: commandHistory,
+    cmdHistoryIdx: -1,
+    scrollOffset: 0,
+    workspaceDir: workspaceDirectory,
+});
+// An image view tab (opened via `open <image>`). It carries no transcript/history/shell — just the
+// image payload — and is always titled `image` while keeping a unique `label` so several can coexist.
+export const makeImageTab = (label, dotColor, number, group, groupColor, image) => ({
+    ...makeTab(label, dotColor, number, [], [], undefined, group, groupColor),
+    view: 'image',
+    title: 'image',
+    image,
+});
+// A page view tab (opened via `open https://…` or `open page …`). Renders an iframe; carries no
+// transcript/history/shell. The title shows the domain (e.g. "slashdot.org").
+export const makePageTab = (label, dotColor, number, group, groupColor, page) => ({
+    ...makeTab(label, dotColor, number, [], [], undefined, group, groupColor),
+    view: 'page',
+    title: page.domain,
+    page,
+});
+// A markdown view tab (opened via `open <file>.md`). Renders the file as formatted Markdown.
+export const makeMarkdownTab = (label, dotColor, number, group, groupColor, markdown) => ({
+    ...makeTab(label, dotColor, number, [], [], undefined, group, groupColor),
+    view: 'markdown',
+    title: 'markdown',
+    markdown,
+});
+// An editor view tab (opened via `open <text file>` or `edit <file>`). Hosts the plain-text editor.
+export const makeEditorTab = (label, dotColor, number, group, groupColor, editor) => ({
+    ...makeTab(label, dotColor, number, [], [], undefined, group, groupColor),
+    view: 'editor',
+    title: editor.name,
+    editor,
+});
+// A harness view tab (opened via `harness <name>`). The entire tab body is a live PTY terminal.
+export const makeHarnessTab = (label, dotColor, number, group, groupColor, harness, workspaceDirectory) => ({
+    ...makeTab(label, dotColor, number, [], [], workspaceDirectory, group, groupColor),
+    view: 'harness', title: label, harness,
+});
+// A file tree view tab (opened via `files [path]`). Shows a directory tree rooted at `files.root`.
+export const makeFilesTab = (label, dotColor, number, group, groupColor, files) => ({
+    ...makeTab(label, dotColor, number, [], [], undefined, group, groupColor),
+    view: 'files',
+    title: 'navigator',
+    files,
+});
+// A notifications view tab (opened via `notifications`). A singleton, view-only feed whose body is
+// the standard transcript fed by its own `log`; it takes no typed input. Live and in-memory like
+// the file tree tab — never persisted, never restored on `--relaunch`.
+export const makeNotificationsTab = (label, dotColor, number, group, groupColor) => ({
+    ...makeTab(label, dotColor, number, [], [], undefined, group, groupColor),
+    view: 'notifications',
+    title: 'notifications',
+});