Files
gods-eye-view/src/voice/panelLayout.js
T
manjunath22466andDarren Dignam af461febae feat(voice): add typed AI chat beside voice
Chat sits next to the mic in the command dock. Replies are silent and never
request the microphone; the first message connects with the selected provider
and runs the same map actions as voice through each provider's text API
(OpenAI OPENAI_CHAT_MODEL, Gemini GEMINI_CHAT_MODEL via generateContent, which
never starts Live). Only one mode runs at a time.

- Chat panel rendered by the voice control presenter: conversation, recent and
  quick-command suggestions, Up/Down history, attachments (map-layer
  references or small UTF-8 text files, sent only with the message)
- Chat and voice panels sit above the dock or dock into the right rail's
  column; minimized bars sit centred above the dock, and height animates on
  swaps
- A centred panel steps down to its bar for the Location and Visual Presets
  trays without moving focus, rests above an open tray, and docks right while
  expanded over one; it returns to the centre once the trays close
- Minimized voice previews the last sentence from each side; the empty Voice
  Preview suggests things to say
- Settings opened from chat keep chat's frame and show the shared AI provider
  and quick commands; voice Settings show Back to voice
- Closing chat ends a typed session; the voice panel's close turns voice off
- The dock widens its voice control for the chat button and restyles its
  wings, which show icons only at 900px and below; assistant panels share the
  left panels' glass, and Cyber keeps its own surfaces
- Server text-chat handlers with body, time and per-IP limits
  (GEV_RATELIMIT_*_CHAT_PER_MIN), documented in SECURITY.md; tests and all
  eleven locales

Co-authored-by: Darren Dignam <[email protected]>
2026-11-02 20:56:39 +05:30

385 lines
14 KiB
JavaScript

import { nextTick } from 'vue';
const DOCK_KEY = 'gev.panel.docked';
// The last height each dock root showed, so the next panel can grow from it.
const handoffs = new WeakMap();
function readDocked() {
try {
return localStorage.getItem(DOCK_KEY) === 'true';
} catch {
return false;
}
}
/**
* The shared dock choice for the assistant panels: above the dock, or docked
* into the right rail's lane. Bind it before the panels' layouts, which place
* again after it toggles.
* @returns {() => void} Removes the listener.
*/
export function bindLayoutDock(ui) {
ui.update('layout', { docked: readDocked() });
return ui.on('layout-dock', () => {
const docked = !ui.state.layout.docked;
try {
localStorage.setItem(DOCK_KEY, String(docked));
} catch {
/* Storage is optional. */
}
ui.update('layout', { docked, trayDocked: false });
});
}
/**
* Place an assistant panel (`chatPanel` or `voicePanel`, as the presenter
* names it) above the command dock, or docked into the right rail's lane. The
* panel renders on the next tick; session and presentation ownership stay
* with the caller.
*/
export function bindAssistantPanelLayout({ ui, name, minimize, restore }) {
let cancelled = false;
let teardown = () => {};
void nextTick(() => {
if (!cancelled) teardown = layOut({ ui, name, minimize, restore });
});
return () => {
cancelled = true;
teardown();
};
}
function layOut({ ui, name, minimize, restore }) {
const panel = ui.element(name);
const root = ui.element('root');
if (!panel || !root?.getBoundingClientRect) return () => {};
const lifetime = new AbortController();
const doc = panel.ownerDocument;
const view = doc.defaultView || window;
panel.dataset.assistantPanel = '';
const isDocked = () => Boolean(ui.state.layout.docked);
const listen = (target, event, handler) =>
target?.addEventListener(event, handler, { signal: lifetime.signal });
const isMobile = () => view.matchMedia?.('(max-width: 720px)').matches;
const shown = (element) =>
!element.hidden && element.checkVisibility?.() !== false;
// The rail yields its lane while any assistant panel is docked over it.
const syncRail = () => {
const occupied =
isDocked() &&
!isMobile() &&
[...(root.querySelectorAll?.('[data-assistant-panel]') ?? [])].some(
(item) => shown(item) && !item.dataset.minimized,
);
const body = doc.body;
if (!body?.dataset) return;
if (occupied) body.dataset.assistantDocked = 'true';
else delete body.dataset.assistantDocked;
};
const floatingReply = panel.querySelector('#gev-chat-mini-reply');
// The dock's Location and Visual Presets wings open trays above the dock.
// They are looked up on use, since the dock can mount or re-render after
// this binds; each new wing is watched as it is found. Trays open, close
// and pin through the wings' classes.
const trayChanges = new MutationObserver(() => {
schedule();
release();
});
const leaveWing = () => {
release();
schedule();
};
const watchedWings = new WeakSet();
const wings = () => {
const found = ['location-bar', 'control-panel']
.map((id) => doc.getElementById?.(id))
.filter(Boolean);
for (const wing of found) {
if (watchedWings.has(wing)) continue;
watchedWings.add(wing);
trayChanges.observe(wing, {
attributes: true,
attributeFilter: ['class'],
});
listen(wing, 'pointerleave', leaveWing);
}
return found;
};
const openTrays = () =>
wings()
.filter((wing) => !wing.classList.contains('collapsed'))
.map((wing) => wing.querySelector('.dock-popover-content'))
.filter((tray) => tray && shown(tray));
const trayOpen = () =>
wings().some(
(wing) => !wing.classList.contains('collapsed') && shown(wing),
);
// A centred panel yields to the trays as its minimized bar. The yield
// passes to the other panel on a switch, and ends with an expand, or once
// the trays close and the pointer leaves the wings. A dock taken for a
// tray ends then too.
const yieldToTrays = () => {
ui.update('layout', { yielded: name });
minimize();
};
// Touch screens can keep :hover on the last wing tapped.
const hovered = (wing) =>
view.matchMedia?.('(hover: hover)').matches && wing.matches?.(':hover');
const release = () => {
if (trayOpen() || wings().some(hovered)) return;
// Either panel's layout may end the dock; the other re-places on its own
// schedule.
if (ui.state.layout.trayDocked) {
ui.update('layout', { docked: false, trayDocked: false });
place();
}
if (ui.state.layout.yielded !== name) return;
ui.update('layout', { yielded: null });
if (shown(panel) && panel.dataset.minimized) restore();
};
let frame = 0;
let seen = false;
let wasMinimized = false;
let wasShown = false;
let lastHeight = 0;
let animateNext = false;
let heightAnimation = null;
const animateHeight = (from, to) => {
if (view.matchMedia?.('(prefers-reduced-motion: reduce)').matches) return;
heightAnimation?.cancel();
heightAnimation = panel.animate?.(
[
{ height: `${from}px`, overflow: 'hidden' },
{ height: `${to}px`, overflow: 'hidden' },
],
{ duration: 240, easing: 'cubic-bezier(0.2, 0.8, 0.2, 1)' },
);
};
const place = () => {
const minimized = Boolean(panel.dataset.minimized);
// Minimized bars always sit centred above the dock; only an expanded
// docked panel takes the right lane.
const inLane = isDocked() && !minimized && !isMobile();
panel.dataset.placement = inLane ? 'docked' : 'compact';
syncRail();
if (lifetime.signal.aborted) return;
if (panel.hidden || !shown(panel)) {
wasShown = false;
seen = false;
wasMinimized = false;
return;
}
const appearing = !seen;
const expanding = !appearing && wasMinimized && !minimized;
seen = true;
wasMinimized = minimized;
if (!isDocked() && !isMobile()) {
// A panel opened or switched to while the trays hold the centre
// starts as its bar.
if (appearing && !minimized && (ui.state.layout.yielded || trayOpen())) {
yieldToTrays();
return;
}
// Expanding over an open tray takes the right lane instead of covering
// it. Only the layout state changes; the saved dock choice stays.
if (expanding && trayOpen()) {
ui.update('layout', { docked: true, trayDocked: true, yielded: null });
void nextTick(place);
return;
}
}
if (expanding && ui.state.layout.yielded === name)
ui.update('layout', { yielded: null });
// Offsets are from the root's padding box, inside its border.
const box = root.getBoundingClientRect();
const anchor = {
left: box.left + (root.clientLeft || 0),
top: box.top + (root.clientTop || 0),
};
const anchorBottom = anchor.top + (root.clientHeight || box.height);
const w = view.innerWidth,
h = view.innerHeight;
if (inLane) {
const rail = doc.getElementById?.('right-context-rail');
const lane = rail?.getBoundingClientRect();
// The panel takes the rail's whole column, its icon strip included;
// the hidden strip keeps its layout.
const strip = rail
?.querySelector?.('.gev-panel-rail--right')
?.getBoundingClientRect();
const right = lane?.width
? Math.max(lane.right, strip?.right || 0)
: w - 52;
const width = lane?.width ? right - lane.left : 330;
const top = lane?.width ? lane.top : h * 0.26;
const bottom = Number(rail?.dataset.safeBottom) || h * 0.77;
panel.style.width = `${width}px`;
panel.style.height = `${Math.max(240, bottom - top)}px`;
panel.style.left = `${right - width - anchor.left}px`;
panel.style.top = `${top - anchor.top}px`;
panel.style.bottom = 'auto';
} else {
// Above the dock on its centre line, at the panel's own CSS size; phones
// get a full-width sheet above the tab bar. The bottom edge is the
// anchor, so height changes grow upward from the dock.
const dockRect = doc
.getElementById?.('command-dock')
?.getBoundingClientRect();
panel.style.removeProperty('height');
if (isMobile() && !minimized) panel.style.width = `${w - 16}px`;
else panel.style.removeProperty('width');
const rect = panel.getBoundingClientRect();
const centre = dockRect?.width
? dockRect.left + dockRect.width / 2
: w / 2;
const x = Math.max(
8,
Math.min(centre - rect.width / 2, w - rect.width - 8),
);
const replyRect = floatingReply?.getBoundingClientRect();
const above = replyRect?.height
? Math.max(0, rect.top - replyRect.top)
: 0;
// The voice control rises above the dock; keep the gap from its top,
// and rest above any open tray under the panel.
const trayTop = openTrays()
.map((tray) => tray.getBoundingClientRect())
.filter((tray) => tray.left < x + rect.width && tray.right > x)
.reduce((top, tray) => Math.min(top, tray.top), Infinity);
const base = Math.min(dockRect?.top ?? Infinity, box.top, trayTop);
const ceiling = base - rect.height - 16;
const y = Math.max(8 + above, Math.min(ceiling, h - rect.height - 8));
panel.style.left = `${x - anchor.left}px`;
panel.style.top = 'auto';
panel.style.bottom = `${anchorBottom - (y + rect.height)}px`;
}
panel.style.transform = 'none';
// Grow from the panel shown before (chat and voice swap), or from this
// panel's last height when its view changes. A running animation is
// mid-flight, so its frames are not recorded as the panel's height.
if (heightAnimation?.playState === 'running' && !animateNext) return;
const height = panel.getBoundingClientRect().height;
const previous = handoffs.get(root);
const from = minimized
? 0
: !wasShown
? previous?.panel !== panel && !shown(previous?.panel ?? panel)
? previous?.height
: 0
: animateNext
? lastHeight
: 0;
animateNext = false;
wasShown = true;
if (from && Math.abs(from - height) > 8) animateHeight(from, height);
lastHeight = height;
if (!minimized) handoffs.set(root, { panel, height });
};
const schedule = () => {
cancelAnimationFrame(frame);
frame = requestAnimationFrame(place);
};
// The dock choice toggles first (bindLayoutDock), then each panel places.
// Undocking while a tray is open brings the panel back as its bar.
const offDock = ui.on('layout-dock', () =>
nextTick(() => {
if (
!isDocked() &&
!isMobile() &&
trayOpen() &&
shown(panel) &&
!panel.dataset.minimized
)
yieldToTrays();
place();
}),
);
listen(view, 'resize', schedule);
// The dock slides into place; observers report size changes, not moves.
const commandDock = doc.getElementById?.('command-dock');
listen(commandDock, 'transitionend', schedule);
listen(commandDock, 'animationend', schedule);
// A rail panel opened while docked (a typed "show cameras", say) wins the
// lane: the assistant panel steps down to its minimized bar.
const rail = doc.getElementById?.('right-context-rail');
const expandedRailPanels = () =>
new Set(
[...(rail?.children ?? [])]
.filter(
(item) =>
item.matches?.('[data-panel-id]') &&
!item.classList.contains('collapsed'),
)
.map((item) => item.id),
);
let railOpen = expandedRailPanels();
const railChanges = new MutationObserver(() => {
const next = expandedRailPanels();
const opened = [...next].some((id) => !railOpen.has(id));
railOpen = next;
if (
opened &&
panel.dataset.placement === 'docked' &&
shown(panel) &&
!panel.dataset.minimized
)
minimize();
});
if (rail)
railChanges.observe(rail, {
attributes: true,
attributeFilter: ['class'],
subtree: true,
});
// Reaching for a wing's button steps a centred panel down to its bar,
// which then rests above the tray.
const reachWing = ({ target }) => {
if (
target?.closest?.('.dock-tray-toggle') &&
wings().some((wing) => wing.contains(target)) &&
panel.dataset.placement === 'compact' &&
!isMobile() &&
shown(panel) &&
!panel.dataset.minimized
)
yieldToTrays();
};
for (const event of ['pointerover', 'pointerdown'])
listen(doc, event, reachWing);
wings();
const resize = new ResizeObserver(schedule);
resize.observe(panel);
resize.observe(root);
if (floatingReply) resize.observe(floatingReply);
// Show, hide, minimize and view changes place at once; only resizes wait
// for a frame. A view change animates from the old height.
const changes = new MutationObserver((records) => {
if (records.some((record) => record.attributeName === 'data-view'))
animateNext = true;
place();
});
changes.observe(panel, {
attributes: true,
attributeFilter: ['hidden', 'data-minimized', 'data-view'],
});
// Chat and voice hide each other through root state, not their own hidden.
changes.observe(root, {
attributes: true,
attributeFilter: ['data-chat-open', 'data-assistant-mode'],
});
place();
return () => {
lifetime.abort();
cancelAnimationFrame(frame);
resize.disconnect();
changes.disconnect();
railChanges.disconnect();
trayChanges.disconnect();
heightAnimation?.cancel();
offDock();
delete panel.dataset.assistantPanel;
syncRail();
};
}