janissary 0.5.0

package/dist/tab/manager.js

@@ -0,0 +1,329 @@
+import { makeTab, distinctColor, insertTabInGroup, } from './index.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 './cleanup.js';
+import * as tabOpeners from './openers.js';
+import { getQueue, pushQueue, shiftQueue, updateQueueEntry, removeQueueEntry } from './queue.js';
+import { buildTabView } from './view.js';
+import { rehydrateTabs } from './rehydrate.js';
+import { buildAgentStateFromTab } from './agent-state.js';
+import { recordLeavingActiveTab, popFocusHistory, mostRecentFileTreeLabel } from './focus-history.js';
+import { applyDock } from './dock.js';
+import { capLog, finishRunningEntry } from './transcript.js';
+import { computeReorder, removeTabAt } from './reorder.js';
+import { recordHistory } from './history.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;
+    // Labels of tabs that were previously active, most-recent-last. Closing the active tab pops
+    // this to restore focus to whatever was focused right before it, rather than just clamping to
+    // the nearest surviving index.
+    focusHistory = [];
+    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 getQueue(this.queue, label);
+    }
+    enqueue(label, text) {
+        pushQueue(this.queue, label, text);
+        this.persistQueue(label);
+    }
+    dequeue(label) {
+        const front = shiftQueue(this.queue, label);
+        if (front !== undefined)
+            this.persistQueue(label);
+        return front;
+    }
+    editQueued(label, index, text) {
+        if (updateQueueEntry(this.queue, label, index, text))
+            this.persistQueue(label);
+    }
+    deleteQueued(label, index) {
+        if (removeQueueEntry(this.queue, label, 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 buildAgentStateFromTab(tab, this.busy.has(tab.label), this.cwd.get(tab.label), this.context.get(tab.label), this.queue.get(tab.label), 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;
+    }
+    recordLeavingActiveTab(newIndex) {
+        this.focusHistory = recordLeavingActiveTab(this.tabs, this.activeTab, this.focusHistory, newIndex);
+    }
+    popFocusHistory() {
+        const { index, history } = popFocusHistory(this.tabs, this.focusHistory);
+        this.focusHistory = history;
+        return index;
+    }
+    mostRecentFileTreeLabel() {
+        return mostRecentFileTreeLabel(this.tabs, this.focusHistory);
+    }
+    // Applies the result of adding a new tab (or focusing an existing one) from the `openers.ts`
+    // helpers, which otherwise assign `tabs`/`activeTab` directly and would bypass focus-history
+    // tracking — a freshly opened, auto-focused tab still needs its predecessor recorded.
+    applyOpenResult(result) {
+        this.recordLeavingActiveTab(result.activeTab);
+        this.tabs = result.tabs;
+        this.activeTab = result.activeTab;
+    }
+    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.recordLeavingActiveTab(index);
+        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;
+            }
+        }
+    }
+    setDock(index, dock) {
+        if (this.tabs[index] === undefined)
+            return;
+        this.activeTab = applyDock(this.tabs, this.activeTab, index, dock, (i) => this.recordLeavingActiveTab(i));
+        messageBus.emit('state', { type: 'dirty' });
+    }
+    reorderTab(dir) {
+        const from = this.activeTab;
+        const result = computeReorder(this.tabs, from, dir);
+        if (!result)
+            return;
+        this.tabs = result.tabs;
+        this.activeTab = result.activeTab;
+        const active = this.tabs[this.activeTab];
+        if (active)
+            active.hasUnread = false;
+        this.persist(this.buildAgentState(this.tabs[from]));
+        this.persist(this.buildAgentState(this.tabs[this.activeTab]));
+        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;
+        }
+        const wasActive = index === this.activeTab;
+        this.focusHistory = this.focusHistory.filter((l) => l !== tab.label);
+        this.tabs = removeTabAt(this.tabs, index);
+        const restored = wasActive ? this.popFocusHistory() : undefined;
+        this.activeTab = restored ?? 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) {
+            t.log = finishRunningEntry(t.log, output);
+            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) {
+        return capLog(log, getConfig().transcriptMaxLines);
+    }
+    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) {
+        return recordHistory(this.tabs[index], text);
+    }
+    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) => buildTabView(t, this.busy.has(t.label), this.cwd.get(t.label) ?? process.cwd(), acpLabel(t.label), connectionsFor(t.label), scheduleView(t.label), this.queue.get(t.label) ?? [], (p) => this.shorten(p)));
+    }
+    openImageTab(image) {
+        tabOpeners.openImageTab(this, image);
+    }
+    openMarkdownTab(view) {
+        tabOpeners.openMarkdownTab(this, view);
+    }
+    openEditorTab(view) {
+        tabOpeners.openEditorTab(this, view, (label, path) => this.managers.editorWatch.watch(label, path));
+    }
+    openPageTab(view) {
+        tabOpeners.openPageTab(this, view);
+    }
+    openFilesTab(view) {
+        tabOpeners.openFilesTab(this, view);
+    }
+    openNotificationsTab() {
+        tabOpeners.openNotificationsTab(this);
+    }
+    rehydrate(loadTranscript, onState) {
+        const states = listAgentStates().toSorted((a, b) => (a.number ?? Infinity) - (b.number ?? Infinity));
+        if (states.length === 0)
+            return;
+        this.tabs = rehydrateTabs(states, loadTranscript, (log) => this.capLog(log));
+        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/openers.js

@@ -0,0 +1,35 @@
+import { messageBus } from '../bus.js';
+import { addImageTab, addMarkdownTab, addEditorTab, addPageTab, addFilesTab, addNotificationsTab, } from './creators.js';
+function activate(target, result) {
+    target.applyOpenResult(result);
+    messageBus.emit('state', { type: 'dirty' });
+}
+export function openImageTab(target, image) {
+    activate(target, addImageTab(target.tabs, target.activeTab, image));
+}
+export function openMarkdownTab(target, view) {
+    activate(target, addMarkdownTab(target.tabs, target.activeTab, view));
+}
+export function openEditorTab(target, view, watch) {
+    const existing = target.tabs.find((t) => t.editor?.path === view.path);
+    if (existing) {
+        if (view.line !== undefined)
+            existing.editor.line = view.line;
+        target.setActiveTab(target.tabs.indexOf(existing));
+        messageBus.emit('state', { type: 'dirty' });
+        return;
+    }
+    const result = addEditorTab(target.tabs, target.activeTab, view);
+    target.applyOpenResult(result);
+    watch(result.tabs[result.activeTab].label, view.path);
+    messageBus.emit('state', { type: 'dirty' });
+}
+export function openPageTab(target, { url, domain }) {
+    activate(target, addPageTab(target.tabs, target.activeTab, url, domain));
+}
+export function openFilesTab(target, view) {
+    activate(target, addFilesTab(target.tabs, target.activeTab, view));
+}
+export function openNotificationsTab(target) {
+    activate(target, addNotificationsTab(target.tabs, target.activeTab));
+}

package/dist/tab/queue.js

@@ -0,0 +1,33 @@
+// Per-tab command queue: an agent's queued-but-not-yet-run commands (`queue <agent> <cmd>`),
+// keyed by tab label. Pure operations on the queue Map itself; persistence and change
+// notification stay the caller's responsibility (TabManager).
+export function getQueue(queue, label) {
+    return queue.get(label) ?? [];
+}
+export function pushQueue(queue, label, text) {
+    queue.set(label, [...getQueue(queue, label), text]);
+}
+export function shiftQueue(queue, label) {
+    const q = getQueue(queue, label);
+    if (q.length === 0)
+        return undefined;
+    const [front, ...rest] = q;
+    queue.set(label, rest);
+    return front;
+}
+export function updateQueueEntry(queue, label, index, text) {
+    const q = getQueue(queue, label);
+    if (index < 0 || index >= q.length)
+        return false;
+    const next = [...q];
+    next[index] = text;
+    queue.set(label, next);
+    return true;
+}
+export function removeQueueEntry(queue, label, index) {
+    const q = getQueue(queue, label);
+    if (index < 0 || index >= q.length)
+        return false;
+    queue.set(label, q.filter((_, i) => i !== index));
+    return true;
+}

package/dist/tab/rehydrate.js

@@ -0,0 +1,15 @@
+import { makeTab, distinctColor } from './index.js';
+// Reconstructs Tab objects (in `states`' order, e.g. sorted by persisted number) from saved
+// AgentState records, restoring each tab's transcript, history, title, and offline flag.
+export function rehydrateTabs(states, loadTranscript, capLog) {
+    return states.map((s, index) => {
+        const log = 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;
+    });
+}

package/dist/tab/reorder.js

@@ -0,0 +1,15 @@
+import { swapTabsLeft, swapTabsRight } from './index.js';
+// Resolves TabManager.reorderTab: swaps the active tab with its left/right neighbor (skipping
+// docked tabs, per swapTabsLeft/swapTabsRight) and moves `activeTab` along with it. Returns
+// undefined when the swap is a no-op (already at an edge).
+export function computeReorder(tabs, activeTab, dir) {
+    const next = dir < 0 ? swapTabsLeft(tabs, activeTab) : swapTabsRight(tabs, activeTab);
+    if (next === tabs)
+        return undefined;
+    const to = dir < 0 ? Math.max(0, activeTab - 1) : Math.min(activeTab + 1, next.length - 1);
+    return { tabs: next, activeTab: to };
+}
+// Removes the tab at `index`, renumbering the survivors (TabManager.closeTab).
+export function removeTabAt(tabs, index) {
+    return tabs.filter((_, i) => i !== index).map((t, i) => ({ ...t, number: i + 1 }));
+}

package/dist/tab/transcript.js

@@ -0,0 +1,15 @@
+// Caps a log to at most `max` entries, dropping the oldest. Shared by every mutation that grows a
+// tab's log (append) or resumes one rehydrated from disk (TabManager.rehydrate).
+export function capLog(log, max) {
+    return log.length > max ? log.slice(log.length - max) : log;
+}
+// Marks the most recent still-running log entry (if any) as finished with `output`. Returns the
+// same log reference when nothing was running.
+export function finishRunningEntry(log, output) {
+    const index = log.findLastIndex((e) => e.running);
+    if (index === -1)
+        return log;
+    const next = [...log];
+    next[index] = { ...next[index], output, running: false };
+    return next;
+}

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}`;
+}

package/dist/tab/view.js

@@ -0,0 +1,42 @@
+import { flattenBuffer } from './index.js';
+// Converts one internal Tab into the wire-format TabView sent to the client — the shape the
+// client actually renders, as opposed to Tab's server-side bookkeeping fields.
+export function buildTabView(tab, busy, cwd, acp, connections, schedule, commandQueue, shorten) {
+    return {
+        label: tab.label,
+        number: tab.number,
+        dotColor: tab.dotColor,
+        group: tab.group,
+        groupColor: tab.groupColor,
+        busy,
+        hasUnread: !!tab.hasUnread,
+        cwd: shorten(cwd),
+        flags: [
+            ...(tab.workspaceDir ? ['workspaced'] : []),
+            ...(tab.autoApprove ? ['autoApprove'] : []),
+        ],
+        acp,
+        connections,
+        schedule,
+        bufferLines: flattenBuffer(tab.log, !tab.toolStepsExpanded)
+            .map((l) => (l.cwd ? { ...l, cwd: shorten(l.cwd) } : l)),
+        cmdHistory: tab.cmdHistory,
+        commandQueue,
+        toolStepsExpanded: !!tab.toolStepsExpanded,
+        view: tab.view,
+        title: tab.title,
+        image: tab.image,
+        page: tab.page,
+        harness: tab.harness,
+        markdown: tab.markdown,
+        editor: tab.editor,
+        // Deliberately NOT spreading `tab.editorDraft` here: the transient unsaved buffer is
+        // server-only and must never be broadcast back to clients (see editor-live-buffer-sync plan).
+        // Same for `tab.pageSnapshot`: the visible-text cache is server-only, read by monitor page
+        // feeds, and must never be broadcast back to clients (see monitor-page-tab-content-feed plan).
+        monitor: tab.monitor,
+        files: tab.files ? { ...tab.files, root: shorten(tab.files.root), absoluteRoot: tab.files.root } : undefined,
+        activePty: tab.activePty,
+        dock: tab.dock,
+    };
+}

package/dist/tab-cleanup.js

@@ -0,0 +1,27 @@
+import { messageBus } from './bus.js';
+export function closeTabResources(tab, managers, openFiles, context, queue, tabsLength) {
+    if (tab.workspaceDir)
+        managers.workspace.remove(tab.workspaceDir);
+    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;
+}