janissary 0.5.0

package/dist/tab-creators.js

@@ -0,0 +1,85 @@
+import { makeImageTab, makeMarkdownTab, makeEditorTab, makePageTab, makeFilesTab, distinctColor, insertTabInGroup, } from './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 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-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 './tab-formatting-handlers.js';
+export { expandTabs } from './tab-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-manager.js

@@ -0,0 +1,418 @@
+import { makeTab, distinctColor, insertTabInGroup, flattenBuffer, swapTabsLeft, swapTabsRight, stripComments, } from './tab.js';
+import { saveAgentState, listAgentStates } from './agent-state.js';
+import { abbreviatePath } from './paths.js';
+import { getConfig } from './config.js';
+import { messageBus } from './bus.js';
+import { closeTabResources } from './tab-cleanup.js';
+import { addImageTab, addMarkdownTab, addEditorTab, addPageTab, addFilesTab, } from './tab-creators.js';
+export class TabManager {
+    managers;
+    tabs = [];
+    activeTab = 0;
+    cwd = new Map();
+    busy = new Set();
+    context = new Map();
+    queue = new Map();
+    onIdle = null;
+    openFiles = new Map();
+    openFileCounter = 0;
+    rootDir;
+    get launchDir() { return this.rootDir; }
+    static OPEN_MAX_FILES = 10;
+    constructor(managers, projectDir) {
+        this.managers = managers;
+        this.rootDir = projectDir ?? process.cwd();
+        this.tabs = [this.makeRootTab()];
+        this.cwd.set('janus', this.rootDir);
+    }
+    cur() {
+        return this.tabs[this.activeTab] ?? this.tabs[0];
+    }
+    allLabels() {
+        return this.tabs.map((t) => t.label);
+    }
+    isBusy(label) {
+        return this.busy.has(label);
+    }
+    cwdOf(label) {
+        return this.cwd.get(label);
+    }
+    setCwd(label, dir) {
+        this.cwd.set(label, dir);
+    }
+    addBusy(label) {
+        this.busy.add(label);
+    }
+    deleteBusy(label) {
+        this.busy.delete(label);
+        if (this.queueFor(label).length > 0) {
+            queueMicrotask(() => this.onIdle?.(label));
+        }
+    }
+    setOnIdle(hook) {
+        this.onIdle = hook;
+    }
+    queueFor(label) {
+        return this.queue.get(label) ?? [];
+    }
+    enqueue(label, text) {
+        this.queue.set(label, [...this.queueFor(label), text]);
+        this.persistQueue(label);
+    }
+    dequeue(label) {
+        const q = this.queueFor(label);
+        if (q.length === 0)
+            return undefined;
+        const [front, ...rest] = q;
+        this.queue.set(label, rest);
+        this.persistQueue(label);
+        return front;
+    }
+    editQueued(label, index, text) {
+        const q = this.queueFor(label);
+        if (index < 0 || index >= q.length)
+            return;
+        const next = [...q];
+        next[index] = text;
+        this.queue.set(label, next);
+        this.persistQueue(label);
+    }
+    deleteQueued(label, index) {
+        const q = this.queueFor(label);
+        if (index < 0 || index >= q.length)
+            return;
+        this.queue.set(label, q.filter((_, i) => i !== index));
+        this.persistQueue(label);
+    }
+    persistQueue(label) {
+        const tab = this.tabs.find((t) => t.label === label);
+        if (tab)
+            this.persist(this.buildAgentState(tab));
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    contextFor(label) {
+        return this.context.get(label) ?? [];
+    }
+    setContext(label, ctx) {
+        this.context.set(label, ctx);
+    }
+    appendContext(label, text) {
+        this.context.set(label, [...(this.context.get(label) ?? []), text]);
+    }
+    findIndex(label) {
+        return this.tabs.findIndex((t) => t.label === label);
+    }
+    persist(state) {
+        try {
+            saveAgentState(state);
+        }
+        catch { /* ignore */ }
+    }
+    buildAgentState(tab, extra) {
+        return {
+            name: tab.label,
+            dotColor: tab.dotColor,
+            active: this.busy.has(tab.label),
+            number: tab.number,
+            group: tab.group,
+            groupColor: tab.groupColor,
+            cmdHistory: tab.cmdHistory,
+            cwd: this.cwd.get(tab.label),
+            context: this.context.get(tab.label),
+            commandQueue: this.queue.get(tab.label),
+            title: tab.title,
+            offline: tab.offline,
+            ...extra,
+        };
+    }
+    activeLabel() {
+        return this.tabs[this.activeTab]?.label;
+    }
+    markUnread(label) {
+        if (label === this.activeLabel())
+            return;
+        const tab = this.tabs.find((t) => t.label === label);
+        if (tab)
+            tab.hasUnread = true;
+    }
+    setActiveTab(index) {
+        if (index < 0 || index >= this.tabs.length)
+            return;
+        if (this.tabs[index]?.dock)
+            return; // a docked tab is never the active tab
+        this.activeTab = index;
+        const tab = this.tabs[index];
+        if (tab)
+            tab.hasUnread = false;
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    moveTab(dir) {
+        const total = this.tabs.length;
+        for (let step = 1; step <= total; step++) {
+            const index = (this.activeTab + dir * step + total) % total;
+            if (!this.tabs[index]?.dock) {
+                this.setActiveTab(index);
+                return;
+            }
+        }
+    }
+    // Dock a tab into a sidebar (`'left'` | `'right'`), or undock it back to the center strip
+    // (`null`, which also makes it the active tab). Docking into an occupied side displaces the
+    // previous occupant back to center (non-destructive — nothing closes). Docking the active tab
+    // first moves `activeTab` to the nearest non-docked tab, preserving the invariant that a
+    // docked tab is never active.
+    setDock(index, dock) {
+        const tab = this.tabs[index];
+        if (!tab)
+            return;
+        if (dock === null) {
+            tab.dock = undefined;
+            this.activeTab = index;
+            tab.hasUnread = false;
+            messageBus.emit('state', { type: 'dirty' });
+            return;
+        }
+        const occupant = this.tabs.find((t, i) => i !== index && t.dock === dock);
+        if (occupant)
+            occupant.dock = undefined;
+        tab.dock = dock;
+        if (this.activeTab === index)
+            this.activateNearestNonDocked();
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    activateNearestNonDocked() {
+        const total = this.tabs.length;
+        for (let step = 0; step < total; step++) {
+            const index = (this.activeTab + step) % total;
+            if (!this.tabs[index]?.dock) {
+                this.activeTab = index;
+                return;
+            }
+        }
+    }
+    reorderTab(dir) {
+        const from = this.activeTab;
+        const next = dir < 0 ? swapTabsLeft(this.tabs, from) : swapTabsRight(this.tabs, from);
+        if (next === this.tabs)
+            return;
+        this.tabs = next;
+        const to = dir < 0 ? Math.max(0, from - 1) : Math.min(from + 1, this.tabs.length - 1);
+        this.activeTab = to;
+        const active = this.tabs[to];
+        if (active)
+            active.hasUnread = false;
+        this.persist(this.buildAgentState(this.tabs[from]));
+        this.persist(this.buildAgentState(this.tabs[to]));
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    closeTab(index) {
+        const tab = this.tabs[index];
+        if (!tab)
+            return;
+        const nonDockedCount = this.tabs.filter((t) => !t.dock).length;
+        closeTabResources(tab, this.managers, this.openFiles, this.context, this.queue, nonDockedCount);
+        // Closing the last remaining non-docked tab quits the app (same as the `quit` command).
+        if (!tab.dock && nonDockedCount <= 1) {
+            messageBus.emit('app', { type: 'exit' });
+            return;
+        }
+        this.tabs = this.tabs.filter((_, index_) => index_ !== index).map((t, index_) => ({ ...t, number: index_ + 1 }));
+        this.activeTab = Math.min(this.activeTab, this.tabs.length - 1);
+        const active = this.tabs[this.activeTab];
+        if (active)
+            active.hasUnread = false;
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    renameTab(index, title) {
+        const tab = this.tabs[index];
+        if (!tab)
+            return;
+        const trimmed = title.trim().slice(0, getConfig().tabNameMaxLength);
+        if (trimmed && trimmed !== tab.label)
+            tab.title = trimmed;
+        else
+            delete tab.title;
+        this.persist(this.buildAgentState(tab));
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    toggleCollapse() {
+        const tab = this.cur();
+        tab.toolStepsExpanded = !tab.toolStepsExpanded;
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    insertTabInGroup(tab) {
+        this.tabs = insertTabInGroup(this.tabs, tab);
+    }
+    makeRootTab() {
+        const tab = makeTab('janus', distinctColor([]));
+        tab.toolStepsExpanded = false;
+        return tab;
+    }
+    startRunning(label, input) {
+        this.busy.add(label);
+        this.append(label, { input, output: '', running: true });
+    }
+    finishRunning(label, output) {
+        const t = this.tabs.find((x) => x.label === label);
+        if (t) {
+            const log = [...t.log];
+            const index = log.findLastIndex((e) => e.running);
+            if (index !== -1)
+                log[index] = { ...log[index], output, running: false };
+            t.log = log;
+            this.deleteBusy(label);
+            this.persist(this.buildAgentState(t));
+        }
+        if (output && t) {
+            messageBus.emit('transcript', {
+                type: 'entry:appended', tabLabel: label, entry: { input: '', output }, tab: t,
+            });
+        }
+        this.markUnread(label);
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    capLog(log) {
+        const max = getConfig().transcriptMaxLines;
+        return log.length > max ? log.slice(log.length - max) : log;
+    }
+    append(label, entry) {
+        const tab = this.tabs.find((t) => t.label === label);
+        if (!tab)
+            return;
+        const before = tab.log.length;
+        tab.log = this.capLog([...tab.log, entry]);
+        tab.scrollOffset = 0;
+        const trimmed = before + 1 - tab.log.length;
+        if (trimmed > 0)
+            messageBus.emit('transcript', { type: 'entries:trimmed', tabLabel: label, count: trimmed });
+        messageBus.emit('transcript', { type: 'entry:appended', tabLabel: label, entry, tab });
+        this.markUnread(label);
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    clearTranscript(label) {
+        const tab = this.tabs.find((t) => t.label === label);
+        if (!tab)
+            return;
+        tab.log = [];
+        this.persist(this.buildAgentState(tab));
+        messageBus.emit('transcript', { type: 'tab:cleared', tabLabel: label });
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    recordHistory(index, text) {
+        const trimmed = stripComments(text);
+        const tab = this.tabs[index];
+        if (tab) {
+            if (trimmed && tab.cmdHistory.at(-1) !== trimmed) {
+                tab.cmdHistory = [...tab.cmdHistory, trimmed].slice(-100);
+            }
+            tab.cmdHistoryIdx = -1;
+        }
+        return trimmed;
+    }
+    shorten(p) {
+        return abbreviatePath(p, { root: this.rootDir });
+    }
+    registerFile(absPath) {
+        const id = String(++this.openFileCounter);
+        this.openFiles.set(id, absPath);
+        return `/open/${id}`;
+    }
+    openFilePath(id) {
+        return this.openFiles.get(id);
+    }
+    view(connectionsFor, acpLabel, scheduleView) {
+        return this.tabs.map((t) => ({
+            label: t.label,
+            number: t.number,
+            dotColor: t.dotColor,
+            group: t.group,
+            groupColor: t.groupColor,
+            busy: this.busy.has(t.label),
+            hasUnread: !!t.hasUnread,
+            cwd: this.cwd.get(t.label) ?? process.cwd(),
+            acp: acpLabel(t.label),
+            connections: connectionsFor(t.label),
+            schedule: scheduleView(t.label),
+            bufferLines: flattenBuffer(t.log, !t.toolStepsExpanded)
+                .map((l) => (l.cwd ? { ...l, cwd: this.shorten(l.cwd) } : l)),
+            cmdHistory: t.cmdHistory,
+            commandQueue: this.queue.get(t.label) ?? [],
+            toolStepsExpanded: !!t.toolStepsExpanded,
+            view: t.view,
+            title: t.title,
+            image: t.image,
+            page: t.page,
+            harness: t.harness,
+            markdown: t.markdown,
+            editor: t.editor,
+            monitor: t.monitor,
+            files: t.files ? { ...t.files, root: this.shorten(t.files.root) } : undefined,
+            activePty: t.activePty,
+            dock: t.dock,
+        }));
+    }
+    openImageTab(image) {
+        const { tabs, activeTab } = addImageTab(this.tabs, this.activeTab, image);
+        this.tabs = tabs;
+        this.activeTab = activeTab;
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    openMarkdownTab(view) {
+        const { tabs, activeTab } = addMarkdownTab(this.tabs, this.activeTab, view);
+        this.tabs = tabs;
+        this.activeTab = activeTab;
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    openEditorTab(view) {
+        const existing = this.tabs.find((t) => t.editor?.path === view.path);
+        if (existing) {
+            if (view.line !== undefined)
+                existing.editor.line = view.line;
+            this.setActiveTab(this.tabs.indexOf(existing));
+            messageBus.emit('state', { type: 'dirty' });
+            return;
+        }
+        const { tabs, activeTab } = addEditorTab(this.tabs, this.activeTab, view);
+        this.tabs = tabs;
+        this.activeTab = activeTab;
+        this.managers.editorWatch.watch(tabs[activeTab].label, view.path);
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    openPageTab({ url, domain }) {
+        const { tabs, activeTab } = addPageTab(this.tabs, this.activeTab, url, domain);
+        this.tabs = tabs;
+        this.activeTab = activeTab;
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    openFilesTab(view) {
+        const { tabs, activeTab } = addFilesTab(this.tabs, this.activeTab, view);
+        this.tabs = tabs;
+        this.activeTab = activeTab;
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    rehydrate(loadTranscript, onState) {
+        const states = listAgentStates().toSorted((a, b) => (a.number ?? Infinity) - (b.number ?? Infinity));
+        if (states.length === 0)
+            return;
+        this.tabs = states.map((s, index) => {
+            const log = this.capLog(loadTranscript(s.name) ?? s.log ?? []);
+            const tab = makeTab(s.name, s.dotColor || distinctColor([]), s.number ?? index + 1, s.cmdHistory ?? [], log, s.workspaceDir, s.group ?? 1, s.groupColor || s.dotColor || '#5b9cff');
+            tab.toolStepsExpanded = false;
+            if (s.title)
+                tab.title = s.title;
+            if (s.offline)
+                tab.offline = s.offline;
+            return tab;
+        });
+        for (const s of states) {
+            if (s.cwd)
+                this.cwd.set(s.name, s.cwd);
+            if (s.context)
+                this.context.set(s.name, s.context);
+            if (s.commandQueue)
+                this.queue.set(s.name, s.commandQueue);
+            onState(s);
+        }
+        this.activeTab = 0;
+    }
+}

package/dist/tab-utils.js

@@ -0,0 +1,55 @@
+export function stripComments(command) {
+    return command.replaceAll(/\s*##(?:[\s\S]*?##\s*|[\s\S]*)/g, ' ').trim();
+}
+export function renumberTabs(tabs) {
+    return tabs.map((t, index) => ({ ...t, number: index + 1 }));
+}
+export function canMoveTab(tabs, index, direction) {
+    const index_ = index + direction;
+    if (index < 0 || index_ < 0 || index_ >= tabs.length)
+        return false;
+    return tabs[index].group === tabs[index_].group;
+}
+export function swapTabsLeft(tabs, index) {
+    if (!canMoveTab(tabs, index, -1))
+        return tabs;
+    const next = [...tabs];
+    const left = next[index - 1];
+    next[index - 1] = next[index];
+    next[index] = left;
+    return renumberTabs(next);
+}
+export function swapTabsRight(tabs, index) {
+    if (!canMoveTab(tabs, index, 1))
+        return tabs;
+    const next = [...tabs];
+    const right = next[index + 1];
+    next[index + 1] = next[index];
+    next[index] = right;
+    return renumberTabs(next);
+}
+export function insertTabInGroup(tabs, tab, position = 'end') {
+    let insertAt = tabs.length;
+    for (const [index, tab_] of tabs.entries()) {
+        if (tab_.group !== tab.group)
+            continue;
+        if (position === 'start') {
+            insertAt = index;
+            break;
+        }
+        insertAt = index + 1;
+    }
+    return renumberTabs([...tabs.slice(0, insertAt), tab, ...tabs.slice(insertAt)]);
+}
+// A unique tab label derived from `base` (a harness name, an ssh destination's host, or a custom
+// `as <label>`): `claude`, `claude-2`, … Shared by HarnessManager and SshManager so several tabs
+// with the same base name can coexist.
+export function uniqueLabel(tabs, base) {
+    const used = new Set(tabs.map((t) => t.label));
+    if (!used.has(base))
+        return base;
+    let n = 2;
+    while (used.has(`${base}-${n}`))
+        n++;
+    return `${base}-${n}`;
+}