mirror of
https://github.com/jparkerweb/plan2code.git
synced 2026-11-17 20:51:19 -08:00
2359 lines
95 KiB
JavaScript
2359 lines
95 KiB
JavaScript
// The app page: the top bar, the console dashboard in an iframe, and the
|
|
// agent's terminal panel, docked right by default (or at the bottom on
|
|
// request) with a drag handle.
|
|
|
|
import { mountTerminal } from './terminal.js';
|
|
import { TERMINAL_FONT_DEFAULT, UPDATE_RECHECK_MS, reasonSentence, releaseNotesUrl, confirmButtons, endedView, friendlyError, releaseAfterCheck, shortcutAction, shortcutFromMessage, shortcutLabel, tipWithShortcut, trapTab, waitingView, attentionSignal, barFit, looksFromMessage, splitterAria, splitterFraction, terminalTitle, barNextSteps, commandSegments, continueKeys, defaultRightFraction, folderName, lastAgentNotice, menuStep, pageDetailsLine, pageNotShownView, pickDefaultAgent, plainCommandText, taskbarSwitch, windowTitleFor, deadConsoleAction, folderPickerRows, loopBanner, loopLocks, loopStopLabels, loopWindowTitle, helloRetryAction, retryLabel, RETRY_AFTER_SECONDS } from './meter.js';
|
|
|
|
const { invoke, Channel } = window.__TAURI__.core;
|
|
|
|
// The window opens hidden (tauri.conf.json) and is shown once the first frame
|
|
// has painted, so there is no blank or wrongly colored flash. theme-early.js
|
|
// shows it anyway after a few seconds, should this module never get here.
|
|
function showWindowWhenPainted() {
|
|
const show = () => window.__TAURI__.window.getCurrentWindow().show().catch(() => {});
|
|
requestAnimationFrame(() => requestAnimationFrame(show));
|
|
}
|
|
showWindowWhenPainted();
|
|
|
|
const projectMenuBtn = document.getElementById('project-menu-button');
|
|
const projectNameEl = document.getElementById('project-name');
|
|
const projectPathEl = document.getElementById('project-path');
|
|
const projectMenu = document.getElementById('project-menu');
|
|
const agentMenuBtn = document.getElementById('agent-menu-button');
|
|
const agentMenu = document.getElementById('agent-menu');
|
|
const agentMenuHeadEl = document.getElementById('agent-menu-head');
|
|
const agentMenuMoreEl = document.getElementById('agent-menu-more');
|
|
const moreMenu = document.getElementById('more-menu');
|
|
const termTitleEl = document.getElementById('term-title');
|
|
const agentDotEl = document.getElementById('agent-dot');
|
|
const agentNameEl = document.getElementById('agent-name');
|
|
const agentEndedEl = document.getElementById('agent-ended');
|
|
const agentBypassEl = document.getElementById('agent-bypass');
|
|
const agentModelEl = document.getElementById('agent-model');
|
|
const agentNoneEl = document.getElementById('agent-none');
|
|
const agentStatusEl = document.getElementById('agent-status');
|
|
const restartBtn = document.getElementById('agent-restart');
|
|
const loopBannerEl = document.getElementById('loop-banner');
|
|
const loopTitleEl = document.getElementById('loop-title');
|
|
const loopDetailEl = document.getElementById('loop-detail');
|
|
const loopPipsEl = document.getElementById('loop-pips');
|
|
const loopHintEl = document.getElementById('loop-hint');
|
|
const loopSpecEl = document.getElementById('loop-spec');
|
|
const loopElapsedEl = document.getElementById('loop-elapsed');
|
|
const loopRetriesEl = document.getElementById('loop-retries');
|
|
const loopStopAfterBtn = document.getElementById('loop-stop-after');
|
|
const loopStopNowBtn = document.getElementById('loop-stop-now');
|
|
const loopErrorEl = document.getElementById('loop-error');
|
|
const loopRetryBtn = document.getElementById('loop-retry');
|
|
// Whether Stop after this phase is on, as the last state said; a press asks for the opposite.
|
|
let loopStopAfterOn = false;
|
|
// True while an Implementation Loop runs: New Session stays hidden meanwhile.
|
|
let loopRunning = false;
|
|
let loopStep = '';
|
|
// Whether this loop's one-time typing note was shown; a new loop resets it.
|
|
let loopTypingNoted = false;
|
|
const LOOP_TYPING_NOTE = 'A loop is running. Typing here can derail the phase it is working on.';
|
|
const LOOP_TYPING_NOTE_MS = 8000;
|
|
const changeAgentBtn = document.getElementById('change-agent');
|
|
const changeProjectBtn = document.getElementById('change-project');
|
|
const barRowEl = document.getElementById('bar-row');
|
|
const launchCard = document.getElementById('launch-card');
|
|
const launchAgentEl = document.getElementById('launch-agent');
|
|
const launchMissingEl = document.getElementById('launch-missing');
|
|
const launchWarningEl = document.getElementById('launch-agents-warning');
|
|
const launchModelEl = document.getElementById('launch-model');
|
|
const launchModelRowEl = document.getElementById('launch-model-row');
|
|
const launchEffortRow = document.getElementById('launch-effort-row');
|
|
const launchEffortEl = document.getElementById('launch-effort');
|
|
const launchBypassEl = document.getElementById('launch-bypass');
|
|
const launchBypassWarningEl = document.getElementById('launch-bypass-warning');
|
|
const launchStartBtn = document.getElementById('launch-start');
|
|
const folderPickerEl = document.getElementById('folder-picker');
|
|
const folderPickerPanelEl = document.getElementById('folder-picker-panel');
|
|
const folderPickerListEl = document.getElementById('folder-picker-list');
|
|
const folderPickerErrorEl = document.getElementById('folder-picker-error');
|
|
const folderPickerCancelBtn = document.getElementById('folder-picker-cancel');
|
|
const firstRunEl = document.getElementById('first-run');
|
|
const firstRunListEl = document.getElementById('first-run-list');
|
|
const firstRunStartBtn = document.getElementById('first-run-start');
|
|
const launchNoticeEl = document.getElementById('launch-notice');
|
|
const setupCloseBtn = document.getElementById('setup-close');
|
|
const nextStepEl = document.getElementById('next-step');
|
|
const nextStepTextEl = document.getElementById('next-step-text');
|
|
const nextStepBtn = document.getElementById('next-step-button');
|
|
const nextStepMoreEl = document.getElementById('next-step-more');
|
|
const frame = document.getElementById('console-frame');
|
|
const stateBox = document.getElementById('dashboard-state');
|
|
const statePlannyEl = document.getElementById('dashboard-state-planny');
|
|
const stateText = document.getElementById('dashboard-state-text');
|
|
const stateButton = document.getElementById('dashboard-state-button');
|
|
const stateCancelEl = document.getElementById('dashboard-state-cancel');
|
|
const stateSecondaryEl = document.getElementById('dashboard-state-secondary');
|
|
const stateDetailsEl = document.getElementById('dashboard-state-details');
|
|
const workspaceEl = document.getElementById('workspace');
|
|
const termPanel = document.getElementById('term-panel');
|
|
const termHandle = document.getElementById('term-handle');
|
|
const termDockBtn = document.getElementById('term-dock');
|
|
const termMaximizeBtn = document.getElementById('term-maximize');
|
|
const termCollapseBtn = document.getElementById('term-collapse');
|
|
const termBadgeEl = document.getElementById('term-badge');
|
|
const stateBusyEl = document.getElementById('dashboard-state-busy');
|
|
const stateToggleEl = document.getElementById('dashboard-state-toggle');
|
|
const appMenuBtn = document.getElementById('app-menu-button');
|
|
const appMenu = document.getElementById('app-menu');
|
|
const nextStepNotesEl = document.getElementById('next-step-notes');
|
|
const confirmModalEl = document.getElementById('confirm-modal');
|
|
const confirmPanelEl = document.getElementById('confirm-panel');
|
|
const confirmTitleEl = document.getElementById('confirm-title');
|
|
const confirmBodyEl = document.getElementById('confirm-body');
|
|
const confirmActionsEl = document.getElementById('confirm-actions');
|
|
const confirmCancelBtn = document.getElementById('confirm-cancel');
|
|
const confirmPrimaryBtn = document.getElementById('confirm-primary');
|
|
|
|
// Cmd on a Mac, Ctrl elsewhere: for the shortcuts and the tooltips that name them.
|
|
const IS_MAC = /Mac|iPhone|iPad/.test(navigator.platform || navigator.userAgent || '');
|
|
|
|
const STATUS_POLL_MS = 5000;
|
|
const BADGE_POLL_MS = 2000;
|
|
const MIN_PANE = 0.10;
|
|
const MAX_PANE = 0.60;
|
|
const MAXIMIZED_PANE = 0.80;
|
|
// Below this share of the window, a collapsed-or-small pane can hide a
|
|
// question the agent is quietly waiting on.
|
|
const SMALL_PANE = 0.15;
|
|
const QUIET_BADGE_MS = 10000;
|
|
|
|
// Only the bar's fallback, before (or without) agent_availability: the launch
|
|
// card and the bar otherwise read each agent's label from that list.
|
|
const FALLBACK_LABELS = { claude: 'Claude Code', devin: 'Devin', codex: 'Codex' };
|
|
const agentLabel = (id) => (agentAvailability[id] && agentAvailability[id].label) || FALLBACK_LABELS[id] || id || '';
|
|
// Devin's model ids already carry their effort (`swe-2-high`); only these two
|
|
// take a separate effort, at the levels their own CLI documents.
|
|
const EFFORT_OPTIONS = {
|
|
claude: ['low', 'medium', 'high', 'xhigh', 'max'],
|
|
codex: ['low', 'medium', 'high'],
|
|
};
|
|
|
|
// What the Rust agent host last said: idle, running or ended.
|
|
let agent = { state: 'idle', kind: null, generation: 0 };
|
|
const agentActive = () => agent.state === 'running';
|
|
|
|
const terminal = await mountTerminal(document.getElementById('term'), {
|
|
onInput: (data) => {
|
|
if (agentActive()) {
|
|
noteTypingDuringLoop();
|
|
invoke('agent_input', { data });
|
|
}
|
|
},
|
|
onResize: (cols, rows) => {
|
|
if (agentActive()) invoke('agent_resize', { cols, rows });
|
|
},
|
|
// Ctrl or Cmd with plus, minus or 0: remembered for the next launch.
|
|
onFontSize: (size) => {
|
|
invoke('save_terminal_font_size', { size }).catch(() => {
|
|
// A settings file that cannot be written must not stop the zoom.
|
|
});
|
|
},
|
|
// A link the agent printed, opened in the default browser (http and https only).
|
|
onLink: (uri) => openLink(uri),
|
|
// The shell's own shortcuts, typed with the terminal focused: handled here, never typed to the agent.
|
|
onShortcut: (event) => {
|
|
const id = shortcutAction(event, { mac: IS_MAC, inTerminal: true });
|
|
if (!id) return false;
|
|
runShortcut(id);
|
|
return true;
|
|
},
|
|
onCopyOnSelect: (on) => {
|
|
invoke('set_copy_on_select', { on }).catch(() => {
|
|
// Not saved: the choice holds until the app closes.
|
|
});
|
|
},
|
|
});
|
|
|
|
// Opens a web link in the default browser through the opener plugin; anything that is not
|
|
// http or https is refused here as well as by the plugin's own scope.
|
|
function openLink(url) {
|
|
if (!/^https?:\/\//i.test(String(url))) return;
|
|
invoke('plugin:opener|open_url', { url }).catch((error) => {
|
|
setAgentError(error, 'open that link');
|
|
});
|
|
}
|
|
|
|
// One channel for the page's life: the agent's output arrives as bytes and its
|
|
// state changes as objects, across restarts too.
|
|
const agentChannel = new Channel();
|
|
agentChannel.onmessage = (message) => {
|
|
if (message instanceof ArrayBuffer) {
|
|
terminal.write(new Uint8Array(message));
|
|
lastOutputAt = Date.now();
|
|
updateBadge();
|
|
} else if (message && typeof message === 'object' && 'state' in message) {
|
|
applyAgentState(message);
|
|
}
|
|
};
|
|
|
|
function applyAgentState(next, { skipReset } = {}) {
|
|
const wasEnded = agent.state === 'ended';
|
|
// A new generation is a fresh agent: it starts on a clean screen. Skipped
|
|
// when catching up to an agent that was already running before this page
|
|
// mounted (a reload): its replayed output, not a blank screen, belongs here,
|
|
// and the channel that delivers it races this call, not waits for it.
|
|
const freshScreen = next.generation !== agent.generation && !skipReset;
|
|
if (freshScreen) {
|
|
terminal.reset();
|
|
lastOutputAt = Date.now();
|
|
}
|
|
agent = next;
|
|
const label = agentLabel(agent.kind);
|
|
const active = agentActive();
|
|
|
|
const ended = agent.state === 'ended';
|
|
if (active) {
|
|
// Only ever auto-*hides* the card (the agent just started); it must
|
|
// never auto-*show* it on 'ended' or 'idle' — that is Change agent's
|
|
// job alone, so the card does not pop up over the dashboard uninvited.
|
|
launchCard.hidden = true;
|
|
hideFirstRun();
|
|
}
|
|
// One rule throughout: New Session and the agent menu while running or
|
|
// ended (New Session keeps the previous agent, model, effort and mode);
|
|
// Change agent, in that menu, only once ended, when there is a real choice
|
|
// to make again.
|
|
restartBtn.hidden = loopRunning || !(active || ended);
|
|
changeAgentBtn.hidden = !ended;
|
|
// Checked mode needs no marker; bypass always gets the "checks off" badge
|
|
// on the agent, for exactly as long as that agent runs.
|
|
const bypassActive = active && agent.mode === 'bypass';
|
|
agentMenuBtn.hidden = !(active || ended);
|
|
agentNoneEl.hidden = active || ended;
|
|
agentNameEl.textContent = active || ended ? label || 'The agent' : '';
|
|
termTitleEl.textContent = terminalTitle(active || ended ? label || 'The agent' : '');
|
|
agentDotEl.className = `agent-dot${active ? (bypassActive ? ' is-warn' : ' is-ok') : ''}`;
|
|
const endedWords = ended ? endedView(agent.reason) : null;
|
|
agentEndedEl.hidden = !ended;
|
|
if (endedWords) agentEndedEl.textContent = endedWords.bar;
|
|
// The model and effort the app started it with, when it knows them: an agent
|
|
// on its own default model has none to show, and an effort needs a model.
|
|
const modelText = agent.model ? (agent.effort ? `${agent.model} · ${agent.effort}` : agent.model) : '';
|
|
agentModelEl.textContent = active || ended ? modelText : '';
|
|
agentModelEl.hidden = !agentModelEl.textContent;
|
|
agentModelEl.title = agentModelEl.textContent ? `Started on ${agentModelEl.textContent}` : '';
|
|
agentBypassEl.hidden = !bypassActive;
|
|
renderAgentMenuHead(label || 'The agent', { active, ended, bypassActive });
|
|
if (agentMenu.hidden === false && agentMenuBtn.hidden) closeBarMenus();
|
|
restartBtn.title = tipWithShortcut(ended ? 'Start a fresh agent on the same brief' : 'Replace the agent with a fresh one, on a fresh context window', 'new-session', IS_MAC);
|
|
// The agent is back (a fresh generation, running): the restart message stays
|
|
// on screen (restarting() below) until its dashboard page is announced.
|
|
if (restarting && freshScreen && agent.state === 'running') {
|
|
terminal.write('\r\n\r\n[Fresh agent started. Waiting for the dashboard...]\r\n\r\n');
|
|
}
|
|
|
|
if (ended) {
|
|
// The why sits beside the agent's menu; the menu says the rest.
|
|
setAgentStatus(endedWords.sentence);
|
|
// A failed Restart clears the screen too, so it says so again.
|
|
if (!wasEnded || freshScreen) {
|
|
terminal.write(`\r\n[${label || 'The agent'} ${endedWords.sentence}. Press New Session in the bar to start a fresh one.]\r\n`);
|
|
}
|
|
} else {
|
|
// After a Restart the bar says what it left for the dashboard, if anything.
|
|
setAgentStatus(agent.briefNote || '');
|
|
}
|
|
updateBadge();
|
|
}
|
|
|
|
// The short line after the agent's menu: an ended agent's reason or a
|
|
// Restart's brief note (quiet), or something that went wrong (in red).
|
|
let statusDetails = '';
|
|
|
|
function setAgentStatus(text, { error = false, details = '' } = {}) {
|
|
agentStatusEl.replaceChildren(...commandNodes(text));
|
|
agentStatusEl.title = plainCommandText(text);
|
|
agentStatusEl.classList.toggle('is-error', error && Boolean(text));
|
|
// A long line is cut at the bar's width: it opens in full (with the raw text, when there is one) on a press.
|
|
statusDetails = details;
|
|
const pressable = Boolean(text) && (error || Boolean(details));
|
|
agentStatusEl.classList.toggle('is-pressable', pressable);
|
|
if (pressable) {
|
|
agentStatusEl.setAttribute('role', 'button');
|
|
agentStatusEl.tabIndex = 0;
|
|
} else {
|
|
agentStatusEl.setAttribute('role', 'status');
|
|
agentStatusEl.removeAttribute('tabindex');
|
|
}
|
|
}
|
|
|
|
// An error from the shell or the app's Rust side, in plain words with its next step; the raw
|
|
// text stays behind a press on the line (meter.js friendlyError).
|
|
function setAgentError(raw, action) {
|
|
const friendly = friendlyError(raw, action);
|
|
setAgentStatus(friendly.text, { error: true, details: friendly.details });
|
|
}
|
|
|
|
function openStatusDetails() {
|
|
if (!agentStatusEl.classList.contains('is-pressable')) return;
|
|
void confirmModal({ title: 'What the bar said', lines: [{ kind: 'text', text: agentStatusEl.textContent }, ...(statusDetails ? [{ kind: 'code', text: statusDetails }] : [])], cancel: 'Close', primary: null });
|
|
}
|
|
agentStatusEl.addEventListener('click', openStatusDetails);
|
|
agentStatusEl.addEventListener('keydown', (event) => {
|
|
if (event.key === 'Enter' || event.key === ' ') {
|
|
event.preventDefault();
|
|
openStatusDetails();
|
|
}
|
|
});
|
|
|
|
// A message's nodes, each command it marks with backticks in a <code>
|
|
// (meter.js commandSegments): built as text nodes, never parsed as markup.
|
|
function commandNodes(text) {
|
|
return commandSegments(text).map((part) => {
|
|
if (!part.code) return part.text;
|
|
const code = document.createElement('code');
|
|
code.textContent = part.text;
|
|
return code;
|
|
});
|
|
}
|
|
|
|
// The first key typed in the terminal while a loop runs: a note beside the agent,
|
|
// once per loop, gone after a few seconds. The key itself is always delivered.
|
|
function noteTypingDuringLoop() {
|
|
if (!loopRunning || loopTypingNoted) return;
|
|
loopTypingNoted = true;
|
|
setAgentStatus(LOOP_TYPING_NOTE);
|
|
setTimeout(() => {
|
|
if (agentStatusEl.textContent === LOOP_TYPING_NOTE) setAgentStatus('');
|
|
}, LOOP_TYPING_NOTE_MS);
|
|
}
|
|
|
|
// The agent menu's first lines: what the agent is doing and, while it runs,
|
|
// which permission mode it started with.
|
|
function renderAgentMenuHead(label, { active, ended, bypassActive }) {
|
|
const name = document.createElement('b');
|
|
name.textContent = label;
|
|
if (active) {
|
|
const mode = document.createElement('span');
|
|
if (bypassActive) {
|
|
mode.className = 'is-warn';
|
|
mode.textContent = 'off';
|
|
} else {
|
|
mode.textContent = 'on';
|
|
}
|
|
agentMenuHeadEl.replaceChildren(name, ' is running', document.createElement('br'), 'Permission checks are ', mode);
|
|
if (bypassActive) agentMenuHeadEl.append(': it runs commands and changes files without asking');
|
|
} else if (ended) {
|
|
agentMenuHeadEl.replaceChildren(name, ` ${endedView(agent.reason).sentence}`, document.createElement('br'), 'Nothing starts until you press New Session.');
|
|
} else {
|
|
agentMenuHeadEl.replaceChildren();
|
|
}
|
|
}
|
|
|
|
// The bar's three menus (project, agent, and the "+N more" list of pending
|
|
// steps). They hang outside the bar row, fixed under their trigger, so the
|
|
// row's overflow never clips them. Clicking anywhere else (the console frame
|
|
// and the terminal too), Escape or a resize closes them.
|
|
let openBarMenu = null;
|
|
|
|
const barMenus = () => [[projectMenuBtn, projectMenu], [agentMenuBtn, agentMenu], [nextStepMoreEl, moreMenu], [appMenuBtn, appMenu]];
|
|
|
|
function closeBarMenus() {
|
|
for (const [button, menu] of barMenus()) {
|
|
menu.hidden = true;
|
|
button.setAttribute('aria-expanded', 'false');
|
|
}
|
|
openBarMenu = null;
|
|
}
|
|
|
|
// A menu's items that can take focus now: shown and not off.
|
|
function barMenuItems(menu) {
|
|
return [...menu.querySelectorAll('[role="menuitem"]')].filter((item) => !item.hidden && !item.disabled);
|
|
}
|
|
|
|
function toggleBarMenu(button, menu) {
|
|
const wasOpen = openBarMenu === menu;
|
|
closeBarMenus();
|
|
if (wasOpen) return;
|
|
menu.hidden = false;
|
|
const at = button.getBoundingClientRect();
|
|
const left = Math.max(8, Math.min(at.left, window.innerWidth - menu.offsetWidth - 8));
|
|
menu.style.left = `${left}px`;
|
|
menu.style.top = `${at.bottom + 4}px`;
|
|
button.setAttribute('aria-expanded', 'true');
|
|
openBarMenu = menu;
|
|
// Focus goes into the menu: its first item, or the menu itself (tabindex
|
|
// -1) when every item is hidden or off, so Escape still hears the keyboard.
|
|
const [first] = barMenuItems(menu);
|
|
(first || menu).focus();
|
|
}
|
|
|
|
// Up, Down, Home and End move between a menu's items (meter.js menuStep).
|
|
function onBarMenuKey(event) {
|
|
const items = barMenuItems(event.currentTarget);
|
|
const next = menuStep(event.key, items.indexOf(document.activeElement), items.length);
|
|
if (next === null) return;
|
|
event.preventDefault();
|
|
items[next].focus();
|
|
}
|
|
|
|
projectMenuBtn.onclick = () => toggleBarMenu(projectMenuBtn, projectMenu);
|
|
agentMenuBtn.onclick = () => toggleBarMenu(agentMenuBtn, agentMenu);
|
|
nextStepMoreEl.onclick = () => toggleBarMenu(nextStepMoreEl, moreMenu);
|
|
appMenuBtn.onclick = () => toggleBarMenu(appMenuBtn, appMenu);
|
|
appMenu.addEventListener('keydown', onBarMenuKey);
|
|
projectMenu.addEventListener('keydown', onBarMenuKey);
|
|
agentMenu.addEventListener('keydown', onBarMenuKey);
|
|
moreMenu.addEventListener('keydown', onBarMenuKey);
|
|
document.addEventListener('pointerdown', (event) => {
|
|
if (!openBarMenu) return;
|
|
if (barMenus().some(([button, menu]) => menu.contains(event.target) || button.contains(event.target))) return;
|
|
closeBarMenus();
|
|
});
|
|
document.addEventListener('keydown', (event) => {
|
|
if (event.key !== 'Escape' || !openBarMenu) return;
|
|
const [trigger] = barMenus().find(([, menu]) => menu === openBarMenu);
|
|
closeBarMenus();
|
|
trigger.focus();
|
|
});
|
|
window.addEventListener('blur', closeBarMenus);
|
|
window.addEventListener('resize', closeBarMenus);
|
|
|
|
// A narrow window drops parts of the bar instead of scrolling it: the model
|
|
// text first, then the status line (meter.js barFit), each moving into the
|
|
// agent menu. Measured with everything showing, so a wider window brings them
|
|
// back; redone when the row's size or its parts change.
|
|
let fitQueued = false;
|
|
|
|
function fitBar() {
|
|
fitQueued = false;
|
|
barRowEl.classList.remove('no-model', 'no-status');
|
|
const model = agentModelEl.hidden ? 0 : agentModelEl.offsetWidth;
|
|
const status = agentStatusEl.textContent ? agentStatusEl.offsetWidth : 0;
|
|
// Only an agent's menu can hold them, so with none the row keeps everything.
|
|
const fit = agentMenuBtn.hidden ? { model: true, status: true } : barFit({ available: barRowEl.clientWidth, needed: barRowEl.scrollWidth, model, status });
|
|
const dropModel = !fit.model && model > 0;
|
|
const dropStatus = !fit.status && status > 0;
|
|
barRowEl.classList.toggle('no-model', dropModel);
|
|
barRowEl.classList.toggle('no-status', dropStatus);
|
|
const lines = [];
|
|
if (dropModel) lines.push(`Started on ${agentModelEl.textContent}`);
|
|
if (dropStatus) lines.push(agentStatusEl.textContent);
|
|
agentMenuMoreEl.replaceChildren(...lines.flatMap((line, i) => (i ? [document.createElement('br'), line] : [line])));
|
|
}
|
|
|
|
function scheduleFitBar() {
|
|
if (fitQueued) return;
|
|
fitQueued = true;
|
|
requestAnimationFrame(fitBar);
|
|
}
|
|
|
|
new ResizeObserver(scheduleFitBar).observe(barRowEl);
|
|
new MutationObserver(scheduleFitBar).observe(barRowEl, { childList: true, subtree: true, characterData: true, attributes: true, attributeFilter: ['hidden'] });
|
|
|
|
// True from a confirmed Restart until the fresh agent's dashboard page is
|
|
// announced (showAnnounced below): the frame stays blanked with a message the
|
|
// whole time, since the restarted agent must boot and run the skill again
|
|
// before anything can show.
|
|
let restarting = false;
|
|
|
|
async function confirmRestart(onYes) {
|
|
if (agent.state !== 'running') {
|
|
onYes();
|
|
return;
|
|
}
|
|
const yes = await confirmModal({
|
|
title: 'Restart the agent on a fresh context window?',
|
|
lines: [{ kind: 'text', text: 'What the agent was doing is not saved.' }],
|
|
primary: 'New Session',
|
|
danger: true,
|
|
});
|
|
if (!yes) return;
|
|
restarting = true;
|
|
currentUrl = null;
|
|
frameReady = false;
|
|
showState('The agent is restarting on a fresh context window. Please wait for the dashboard to load.');
|
|
onYes();
|
|
}
|
|
|
|
// Shows the agent's terminal: expands a collapsed pane (its own button, so
|
|
// focus and the saved setting come too), else just gives it the keyboard.
|
|
function showTerminal() {
|
|
if (paneCollapsed) termCollapseBtn.click();
|
|
else terminal.focus();
|
|
}
|
|
|
|
// What the launch card offers for each agent: whether its CLI was found on
|
|
// PATH (else how to install it) and whether it takes its own effort. The list
|
|
// keeps the order Rust sent (built-ins, then custom agents); the map is by id.
|
|
let agentList = [];
|
|
let agentAvailability = {};
|
|
// What was skipped in agents.json, shown under the picker.
|
|
let agentWarnings = [];
|
|
|
|
// `refresh` (Check again) also has the app work its PATH out again, so a CLI
|
|
// whose installer added a new folder is found without a restart.
|
|
async function loadAgentAvailability(refresh = false) {
|
|
try {
|
|
const result = await invoke('agent_availability', { refresh });
|
|
agentList = result.agents || [];
|
|
agentWarnings = result.warnings || [];
|
|
agentAvailability = Object.fromEntries(agentList.map((entry) => [entry.id, entry]));
|
|
} catch {
|
|
// Nothing to show is not a reason to block the card: Start just tries it.
|
|
agentList = [];
|
|
agentWarnings = [];
|
|
agentAvailability = {};
|
|
}
|
|
}
|
|
|
|
// The launch card's agent choices, from the availability list. With nothing
|
|
// to list (the check failed) the fixed options in index.html stay as they are.
|
|
function populateAgentSelect(selected) {
|
|
if (agentList.length === 0) return;
|
|
launchAgentEl.replaceChildren(
|
|
...agentList.map((entry) => {
|
|
const option = document.createElement('option');
|
|
option.value = entry.id;
|
|
option.textContent = entry.label || entry.id;
|
|
return option;
|
|
})
|
|
);
|
|
if (selected) launchAgentEl.value = selected;
|
|
}
|
|
|
|
// Pick the agent to start on and show the card's state for it.
|
|
function applyDefaultAgent(remembered) {
|
|
// The saved (last used) agent is gone but another works: one line, then
|
|
// carry on (FR-13). lastAgentNotice gives the pick it names.
|
|
const using = lastAgentNotice(agentList, remembered);
|
|
launchNoticeEl.hidden = !using;
|
|
if (using) launchNoticeEl.textContent = `${agentLabel(remembered)} (last used) was not found, using ${agentLabel(using)}`;
|
|
populateAgentSelect(pickDefaultAgent(agentList, remembered));
|
|
refreshLaunchCard();
|
|
}
|
|
|
|
// A button that opens a built-in agent's install page in the browser.
|
|
function installPageButton(id) {
|
|
const button = document.createElement('button');
|
|
button.type = 'button';
|
|
button.className = 'agent-link';
|
|
button.textContent = 'Install page';
|
|
button.onclick = () => {
|
|
invoke('open_install_page', { id }).catch((error) => {
|
|
setAgentError(error, 'open the install page');
|
|
});
|
|
};
|
|
return button;
|
|
}
|
|
|
|
// Where the setup page was opened from, while it is up: the screen to return
|
|
// to when it closes or reports agent-found. Null: no setup page up.
|
|
let setupReturn = null;
|
|
|
|
// The Set up an agent button, shown wherever the app says "no agent" (FR-17).
|
|
function setupButton(returnTo) {
|
|
const btn = document.createElement('button');
|
|
btn.type = 'button';
|
|
btn.className = 'setup-agent-btn';
|
|
btn.textContent = 'Set up an agent';
|
|
btn.onclick = () => openAgentSetup(returnTo);
|
|
return btn;
|
|
}
|
|
|
|
// Open the console's agent-less setup page in this window (FR-15, FR-17). No
|
|
// poll timer: a dead setup page needs no reconnect, and the Back button still
|
|
// returns.
|
|
async function openAgentSetup(returnTo) {
|
|
try {
|
|
const session = await invoke('console_setup_start');
|
|
setupReturn = returnTo;
|
|
hideState();
|
|
hideFirstRun();
|
|
hideLaunchCard();
|
|
markConsoleAlive();
|
|
consoleKnown = true;
|
|
setupCloseBtn.hidden = false;
|
|
loadFrame(session.url);
|
|
} catch (error) {
|
|
// A missing console.mjs means the skills install itself is gone (FR-16): friendlyError says so.
|
|
const text = String(error);
|
|
setAgentError(text.includes('console.mjs') ? `the web console is not installed: ${text}` : text, 'open the setup page');
|
|
}
|
|
}
|
|
|
|
// The setup page is done: it found an agent (agent-found carries its id) or
|
|
// the person pressed Back. Return to where the app was, recheck the agents,
|
|
// and pick the found one on the launch card for the person to press Start
|
|
// (FR-14, FR-17).
|
|
async function finishSetup(foundId) {
|
|
if (setupReturn === null) return;
|
|
const returnTo = setupReturn;
|
|
setupReturn = null;
|
|
setupCloseBtn.hidden = true;
|
|
currentUrl = null;
|
|
frameReady = false;
|
|
frame.src = 'about:blank';
|
|
invoke('console_stop').catch(() => {});
|
|
await loadAgentAvailability(true);
|
|
applyDefaultAgent(foundId || (appState && appState.lastAgent) || launchAgentEl.value);
|
|
if (returnTo === 'first-run' && appState) showFirstRun(appState);
|
|
else showLaunchCard();
|
|
}
|
|
|
|
// Re-read the agents from disk (a CLI installed or a custom agent added since),
|
|
// then redraw whatever shows them and pick the default again.
|
|
async function checkAgentsAgain() {
|
|
await loadAgentAvailability(true);
|
|
applyDefaultAgent((appState && appState.lastAgent) || launchAgentEl.value);
|
|
if (!firstRunEl.hidden && appState) renderFirstRun(appState);
|
|
}
|
|
|
|
function refreshLaunchCard() {
|
|
const kind = launchAgentEl.value;
|
|
const info = agentAvailability[kind];
|
|
const installed = info ? info.installed : true;
|
|
launchStartBtn.disabled = !installed;
|
|
launchMissingEl.hidden = installed;
|
|
launchMissingEl.replaceChildren();
|
|
if (!installed) {
|
|
if (!agentList.some((a) => a.installed)) {
|
|
launchMissingEl.append('No agent found. ', setupButton('launch-card'));
|
|
} else if (info && info.state === 'outside') {
|
|
// Found on the saved PATH, in npm's folder or an install folder, but
|
|
// not on PATH itself: setup, not a fresh install.
|
|
launchMissingEl.append(`${agentLabel(kind)} was found${info.folder ? ` in ${info.folder}` : ''}, but it is not on PATH. `, setupButton('launch-card'));
|
|
} else {
|
|
launchMissingEl.append(`${agentLabel(kind)} was not found on PATH.`);
|
|
if (info && !info.custom) {
|
|
launchMissingEl.append(' Install it: ');
|
|
const code = document.createElement('code');
|
|
code.textContent = info.installHint || '';
|
|
launchMissingEl.append(code, installPageButton(kind));
|
|
}
|
|
}
|
|
}
|
|
launchWarningEl.hidden = agentWarnings.length === 0;
|
|
launchWarningEl.textContent = agentWarnings.map((warning) => `agents.json: ${warning}`).join('\n');
|
|
// The model dropdown lists what the `plan2code` launcher would ask with:
|
|
// built-ins get the shipped + user models.json merge from Rust, customs
|
|
// their own agents.json models. An empty list hides the row, like the
|
|
// launcher's skipped model question; the first option passes no flag, so
|
|
// the agent runs on its own (last-used) model.
|
|
const models = (info && info.models) || [];
|
|
launchModelEl.replaceChildren();
|
|
const noModel = document.createElement('option');
|
|
noModel.value = '';
|
|
noModel.textContent = "Default (the agent's own model)";
|
|
launchModelEl.append(noModel);
|
|
for (const model of models) {
|
|
const option = document.createElement('option');
|
|
option.value = model.id;
|
|
option.textContent = model.label ? `${model.id}: ${model.label}` : model.id;
|
|
launchModelEl.append(option);
|
|
}
|
|
launchModelRowEl.hidden = models.length === 0;
|
|
// A model the launcher picked (--model) sticks only while it is listed.
|
|
if (appState && models.some((model) => model.id === appState.launchModel)) launchModelEl.value = appState.launchModel;
|
|
const levels = info && info.custom ? [] : EFFORT_OPTIONS[kind] || [];
|
|
launchEffortRow.hidden = levels.length === 0;
|
|
launchEffortEl.replaceChildren();
|
|
const def = document.createElement('option');
|
|
def.value = '';
|
|
def.textContent = 'Default';
|
|
launchEffortEl.append(def);
|
|
for (const level of levels) {
|
|
const option = document.createElement('option');
|
|
option.value = level;
|
|
option.textContent = level[0].toUpperCase() + level.slice(1);
|
|
launchEffortEl.append(option);
|
|
}
|
|
}
|
|
|
|
launchAgentEl.onchange = refreshLaunchCard;
|
|
launchBypassEl.onchange = () => {
|
|
launchBypassWarningEl.hidden = !launchBypassEl.checked;
|
|
};
|
|
|
|
function showLaunchCard() {
|
|
hideState();
|
|
hideFirstRun();
|
|
refreshLaunchCard();
|
|
launchCard.hidden = false;
|
|
}
|
|
|
|
function hideLaunchCard() {
|
|
launchCard.hidden = true;
|
|
}
|
|
|
|
// One row of the first-run checklist: a pass/fail mark, a title and a detail
|
|
// line (plain text or a built node, such as the CLI-by-CLI list).
|
|
function firstRunRow(pass, title, detail) {
|
|
const row = document.createElement('li');
|
|
row.className = `first-run-row ${pass ? 'is-pass' : 'is-fail'}`;
|
|
const mark = document.createElement('span');
|
|
mark.className = 'first-run-mark';
|
|
mark.textContent = pass ? '✓' : '!';
|
|
// Read out as words: a bare check or exclamation mark says nothing to a screen reader.
|
|
mark.setAttribute('role', 'img');
|
|
mark.setAttribute('aria-label', pass ? 'Ready' : 'Needs attention');
|
|
const body = document.createElement('div');
|
|
body.className = 'first-run-body';
|
|
const titleEl = document.createElement('div');
|
|
titleEl.className = 'first-run-title';
|
|
titleEl.textContent = title;
|
|
body.append(titleEl);
|
|
if (detail) {
|
|
const detailEl = document.createElement('div');
|
|
detailEl.className = 'first-run-detail';
|
|
if (typeof detail === 'string') detailEl.append(...commandNodes(detail));
|
|
else detailEl.append(detail);
|
|
body.append(detailEl);
|
|
}
|
|
row.append(mark, body);
|
|
return row;
|
|
}
|
|
|
|
// Node is always a pass here: `main()` on the Rust side already exits before
|
|
// the window opens on anything else (Task 1.7), so this row is a confirmation,
|
|
// never a way to recover from a real failure.
|
|
function renderFirstRun(state) {
|
|
firstRunListEl.replaceChildren();
|
|
const nodeDetail = `${state.nodeVersion || 'found'} (18 or newer)${state.nodeBinary ? `: ${state.nodeBinary}` : ''}`;
|
|
firstRunListEl.append(firstRunRow(true, 'Node.js', nodeDetail));
|
|
|
|
const agentsKnown = agentList;
|
|
const anyAgentInstalled = agentsKnown.length === 0 || agentsKnown.some((a) => a.installed);
|
|
const agentsDetail = document.createElement('span');
|
|
if (agentsKnown.length === 0) {
|
|
agentsDetail.textContent = 'Could not check.';
|
|
} else if (!anyAgentInstalled) {
|
|
agentsDetail.append('No agent found. ', setupButton('first-run'));
|
|
} else {
|
|
agentsKnown.forEach((a, i) => {
|
|
if (i > 0) agentsDetail.append(', ');
|
|
agentsDetail.append(`${a.label}: ${a.installed ? a.path : 'not found'}`);
|
|
});
|
|
}
|
|
firstRunListEl.append(firstRunRow(anyAgentInstalled, 'An agent CLI', agentsDetail));
|
|
|
|
firstRunListEl.append(firstRunRow(Boolean(state.projectDir), 'Project folder', state.projectDir || 'not chosen yet'));
|
|
|
|
const skillsOk = Boolean(state.skillsVersion);
|
|
const skillsDetail = skillsOk ? `v${state.skillsVersion}` : 'not found; run `plan2code update`';
|
|
firstRunListEl.append(firstRunRow(skillsOk, 'Plan2Code skills', skillsDetail));
|
|
|
|
firstRunStartBtn.disabled = !(anyAgentInstalled && state.projectDir && skillsOk);
|
|
}
|
|
|
|
function showFirstRun(state) {
|
|
hideState();
|
|
hideLaunchCard();
|
|
renderFirstRun(state);
|
|
firstRunEl.hidden = false;
|
|
}
|
|
|
|
function hideFirstRun() {
|
|
firstRunEl.hidden = true;
|
|
}
|
|
|
|
firstRunStartBtn.onclick = async () => {
|
|
hideFirstRun();
|
|
try {
|
|
await invoke('save_first_run_done');
|
|
} catch {
|
|
// Not remembered is not fatal: the checklist just shows again next launch.
|
|
}
|
|
showLaunchCard();
|
|
};
|
|
|
|
async function startAgent(event) {
|
|
if (event) event.preventDefault();
|
|
const kind = launchAgentEl.value;
|
|
const model = launchModelEl.value || null;
|
|
const info = agentAvailability[kind];
|
|
const effort = !(info && info.custom) && (EFFORT_OPTIONS[kind] || []).length > 0 ? launchEffortEl.value || null : null;
|
|
const mode = launchBypassEl.checked ? 'bypass' : 'checked';
|
|
setAgentStatus('');
|
|
beginWait('Waiting for the agent to open the dashboard...');
|
|
const { cols, rows } = terminal.size();
|
|
try {
|
|
await invoke('agent_start', { kind, model, effort, mode, cols, rows });
|
|
terminal.focus();
|
|
} catch (error) {
|
|
endWait();
|
|
setAgentError(error, 'start the agent');
|
|
showLaunchCard();
|
|
}
|
|
}
|
|
|
|
async function agentAction(command) {
|
|
try {
|
|
await invoke(command);
|
|
terminal.focus();
|
|
} catch (error) {
|
|
setAgentError(error, 'do that');
|
|
}
|
|
}
|
|
|
|
launchCard.addEventListener('submit', startAgent);
|
|
setupCloseBtn.onclick = () => finishSetup();
|
|
restartBtn.onclick = () => confirmRestart(() => agentAction('agent_restart'));
|
|
// Only ever enabled once the agent has ended: nothing active to lose, so no confirm.
|
|
changeAgentBtn.onclick = () => {
|
|
closeBarMenus();
|
|
showLaunchCard();
|
|
};
|
|
|
|
// The pane's shape: which edge it docks to, its share of the window when it
|
|
// is neither collapsed nor maximized (dragging and the settings file both
|
|
// deal in that share, never in pixels), and whether it is collapsed.
|
|
// Maximized is a transient view, never saved: the pane comes back at its
|
|
// last saved share on the next launch.
|
|
let paneDock = 'bottom';
|
|
let paneFraction = 0.25;
|
|
let paneCollapsed = false;
|
|
let paneMaximized = false;
|
|
|
|
const paneExtent = () => (paneDock === 'right' ? window.innerWidth : window.innerHeight);
|
|
|
|
function setButtonLabel(button, label, tip) {
|
|
button.setAttribute('aria-label', label);
|
|
button.title = tip;
|
|
}
|
|
|
|
// What a double-click on the splitter returns to: the share a first run starts
|
|
// with (docked right, wide enough to keep the console's aside beside it).
|
|
const defaultPaneFraction = () => (paneDock === 'right' ? defaultRightFraction(window.innerWidth, { minFraction: MIN_PANE, maxFraction: MAX_PANE }) : 0.25);
|
|
|
|
function applyPaneLayout() {
|
|
workspaceEl.classList.toggle('dock-right', paneDock === 'right');
|
|
termPanel.classList.toggle('collapsed', paneCollapsed);
|
|
termHandle.hidden = paneCollapsed;
|
|
const sizeProp = paneDock === 'right' ? 'width' : 'height';
|
|
const otherProp = paneDock === 'right' ? 'height' : 'width';
|
|
termPanel.style[otherProp] = '';
|
|
if (paneCollapsed) {
|
|
termPanel.style[sizeProp] = '';
|
|
} else {
|
|
const fraction = paneMaximized ? MAXIMIZED_PANE : paneFraction;
|
|
termPanel.style[sizeProp] = `${Math.round(paneExtent() * fraction)}px`;
|
|
}
|
|
// Icon buttons: what each does, in words, for a screen reader and a tooltip.
|
|
termDockBtn.dataset.dock = paneDock;
|
|
setButtonLabel(termDockBtn, paneDock === 'right' ? 'Dock the terminal at the bottom' : 'Dock the terminal on the right', paneDock === 'right' ? 'Dock at the bottom' : 'Dock on the right');
|
|
setButtonLabel(termMaximizeBtn, paneMaximized ? 'Restore the terminal size' : 'Make the terminal larger', paneMaximized ? 'Restore the size' : 'Make it larger');
|
|
termMaximizeBtn.setAttribute('aria-pressed', String(paneMaximized));
|
|
setButtonLabel(termCollapseBtn, paneCollapsed ? 'Show the terminal' : 'Collapse the terminal', tipWithShortcut(paneCollapsed ? 'Show the terminal' : 'Collapse', 'toggle-terminal', IS_MAC));
|
|
termCollapseBtn.setAttribute('aria-pressed', String(paneCollapsed));
|
|
// The splitter reads as a slider of the panel's share of the window.
|
|
termHandle.setAttribute('aria-orientation', paneDock === 'right' ? 'vertical' : 'horizontal');
|
|
const aria = splitterAria(paneMaximized ? MAXIMIZED_PANE : paneFraction, { min: MIN_PANE, max: paneMaximized ? MAXIMIZED_PANE : MAX_PANE });
|
|
termHandle.setAttribute('aria-valuenow', String(aria.now));
|
|
termHandle.setAttribute('aria-valuemin', String(aria.min));
|
|
termHandle.setAttribute('aria-valuemax', String(aria.max));
|
|
termHandle.setAttribute('aria-valuetext', `${aria.now}% of the window`);
|
|
updateBadge();
|
|
tellTerminalState();
|
|
}
|
|
|
|
// The console page's What to check lines make "terminal" a button while the
|
|
// pane is collapsed, so the page hears the state on its hello (`force`) and
|
|
// whenever it changes, never on every drag of the handle.
|
|
let toldCollapsed = null;
|
|
|
|
function tellTerminalState(force = false) {
|
|
if (!force && toldCollapsed === paneCollapsed) return;
|
|
toldCollapsed = paneCollapsed;
|
|
if (frame.contentWindow) frame.contentWindow.postMessage({ plan2code: 'terminal-state', collapsed: paneCollapsed }, '*');
|
|
}
|
|
|
|
function savePaneSettings() {
|
|
invoke('save_term_panel', { dock: paneDock, fraction: paneFraction, collapsed: paneCollapsed }).catch(() => {
|
|
// A settings file that cannot be written must not stop the pane from working.
|
|
});
|
|
}
|
|
|
|
termDockBtn.onclick = () => {
|
|
paneDock = paneDock === 'right' ? 'bottom' : 'right';
|
|
applyPaneLayout();
|
|
savePaneSettings();
|
|
};
|
|
termMaximizeBtn.onclick = () => {
|
|
paneMaximized = !paneMaximized;
|
|
applyPaneLayout();
|
|
};
|
|
termCollapseBtn.onclick = () => {
|
|
paneCollapsed = !paneCollapsed;
|
|
if (!paneCollapsed) terminal.focus();
|
|
applyPaneLayout();
|
|
savePaneSettings();
|
|
};
|
|
|
|
// Dragging the handle sets the panel's share of the window, along whichever
|
|
// edge it is docked to.
|
|
termHandle.addEventListener('pointerdown', (event) => {
|
|
event.preventDefault();
|
|
termHandle.setPointerCapture(event.pointerId);
|
|
termHandle.classList.add('is-dragging');
|
|
termHandle.focus();
|
|
});
|
|
termHandle.addEventListener('pointermove', (event) => {
|
|
if (!termHandle.hasPointerCapture(event.pointerId)) return;
|
|
const extent = paneExtent();
|
|
const wanted = paneDock === 'right' ? window.innerWidth - event.clientX : window.innerHeight - event.clientY;
|
|
const clamped = Math.min(Math.max(wanted, extent * MIN_PANE), extent * MAX_PANE);
|
|
paneFraction = clamped / extent;
|
|
paneMaximized = false;
|
|
applyPaneLayout();
|
|
});
|
|
function endHandleDrag(event) {
|
|
if (termHandle.hasPointerCapture(event.pointerId)) termHandle.releasePointerCapture(event.pointerId);
|
|
termHandle.classList.remove('is-dragging');
|
|
savePaneSettings();
|
|
}
|
|
termHandle.addEventListener('pointerup', endHandleDrag);
|
|
termHandle.addEventListener('pointercancel', endHandleDrag);
|
|
// Keyboard: arrows resize in 2% steps, Home and End go to the smallest and
|
|
// largest share (meter.js splitterFraction).
|
|
termHandle.addEventListener('keydown', (event) => {
|
|
const next = splitterFraction(event.key, paneMaximized ? MAXIMIZED_PANE : paneFraction, paneDock, { min: MIN_PANE, max: MAX_PANE });
|
|
if (next === null) return;
|
|
event.preventDefault();
|
|
paneFraction = next;
|
|
paneMaximized = false;
|
|
applyPaneLayout();
|
|
savePaneSettings();
|
|
});
|
|
// Double-click: back to the default share.
|
|
termHandle.addEventListener('dblclick', () => {
|
|
paneFraction = defaultPaneFraction();
|
|
paneMaximized = false;
|
|
applyPaneLayout();
|
|
savePaneSettings();
|
|
});
|
|
|
|
// When the pane is collapsed or small, the agent's own status line can keep
|
|
// redrawing while it is really waiting on a prompt no one is watching: a
|
|
// stretch of no new output at all is the giveaway.
|
|
let lastOutputAt = Date.now();
|
|
|
|
// The pill's press: show the terminal and put the keyboard in it. A pane that
|
|
// was only small (not collapsed) grows to a share where a prompt can be read.
|
|
termBadgeEl.onclick = () => {
|
|
if (paneCollapsed) {
|
|
// The click lays the pane out before it returns, so the terminal can take focus after it.
|
|
termCollapseBtn.click();
|
|
terminal.focus();
|
|
return;
|
|
}
|
|
if (!paneMaximized && paneFraction < SMALL_PANE * 2) {
|
|
paneFraction = Math.max(paneFraction, defaultPaneFraction());
|
|
applyPaneLayout();
|
|
savePaneSettings();
|
|
}
|
|
terminal.focus();
|
|
};
|
|
|
|
function updateBadge() {
|
|
const small = paneCollapsed || (!paneMaximized && paneFraction < SMALL_PANE);
|
|
const quiet = agentActive() && Date.now() - lastOutputAt >= QUIET_BADGE_MS;
|
|
termBadgeEl.hidden = !(small && quiet);
|
|
}
|
|
|
|
// The frame is "showing" only once the console page itself says so (it posts a
|
|
// hello to its parent when it draws). The frame's own load event also fires for
|
|
// an error page, so it proves nothing: a blocked or dead frame must not look
|
|
// like a loaded one.
|
|
const HELLO_WAIT_MS = 8000;
|
|
let currentUrl = null;
|
|
let frameReady = false;
|
|
let helloTimer = null;
|
|
// Nothing has shown here yet: no agent has opened the dashboard. No polling,
|
|
// no "reconnect" button makes sense until that first page lands.
|
|
let consoleKnown = false;
|
|
|
|
function loadFrame(url) {
|
|
currentUrl = url;
|
|
frameReady = false;
|
|
// The page going away takes its taskbar dot with it; the new one tells its own.
|
|
clearAttention();
|
|
// And a game it had in full screen.
|
|
setGameFull(false);
|
|
clearTimeout(helloTimer);
|
|
helloTimer = setTimeout(onNoHello, HELLO_WAIT_MS);
|
|
frame.src = url;
|
|
}
|
|
|
|
function clearAttention() {
|
|
invoke('clear_attention_cmd').catch(() => {});
|
|
}
|
|
|
|
// What the console page may ask of this window. Each is a named request with
|
|
// no free text, so the page can never type anything but "continue", and the
|
|
// taskbar's two take only their fixed words and a boolean (meter.js).
|
|
window.addEventListener('message', (event) => {
|
|
if (event.source !== frame.contentWindow) return;
|
|
const kind = event.data && event.data.plan2code;
|
|
if (kind === 'console-ready') {
|
|
frameReady = true;
|
|
pageFailures = 0;
|
|
clearTimeout(helloTimer);
|
|
hideState();
|
|
// The Desktop app switch in its User Preferences shows what app.json holds.
|
|
const on = !appState || appState.taskbarSignal !== false;
|
|
event.source.postMessage({ plan2code: 'taskbar-state', on }, '*');
|
|
tellTerminalState(true);
|
|
} else if (kind === 'attention') {
|
|
const signal = attentionSignal(event.data);
|
|
if (signal) invoke('set_attention', { signal }).catch(() => {});
|
|
} else if (kind === 'agent-found') {
|
|
const id = typeof event.data.id === 'string' ? event.data.id : '';
|
|
void finishSetup(id || null);
|
|
} else if (kind === 'taskbar') {
|
|
const on = taskbarSwitch(event.data);
|
|
if (on === null) return;
|
|
if (appState) appState.taskbarSignal = on;
|
|
invoke('set_taskbar_signal', { on }).catch(() => {});
|
|
} else if (kind === 'activities-full') {
|
|
const on = taskbarSwitch(event.data);
|
|
if (on !== null) setGameFull(on);
|
|
} else if (kind === 'shortcut') {
|
|
// A key the page swallowed (the console's frame has the keyboard): only an id from the table.
|
|
const id = shortcutFromMessage(event.data);
|
|
if (id) runShortcut(id);
|
|
} else if (kind === 'agent-continue') {
|
|
typeContinue();
|
|
} else if (kind === 'terminal-open') {
|
|
// The status line's terminal button: expands a collapsed pane, the same
|
|
// way its own button does (focus and the saved setting included).
|
|
if (paneCollapsed) termCollapseBtn.click();
|
|
} else if (kind === 'new-session') {
|
|
// The bar's own button, so the press is confirmed exactly the same way.
|
|
if (!restartBtn.hidden) restartBtn.click();
|
|
} else if (kind === 'looks') {
|
|
const looks = looksFromMessage(event.data);
|
|
if (looks) applyLooks(looks, { save: true });
|
|
} else if (kind === 'loop-facts') {
|
|
// The setup screen asks what agent a loop would use. The answer is facts
|
|
// only; the page never sends the app any setup value.
|
|
const source = event.source;
|
|
invoke('loop_facts')
|
|
.then((facts) => source.postMessage({ plan2code: 'loop-facts', facts }, '*'))
|
|
.catch(() => {});
|
|
} else if (kind === 'loop-resume' || kind === 'loop-ask' || kind === 'loop-fix' || kind === 'loop-finalize') {
|
|
// Fixed requests, no free text: the page answers with ok or the error.
|
|
const source = event.source;
|
|
const command = { 'loop-resume': 'loop_resume', 'loop-ask': 'loop_ask', 'loop-fix': 'loop_fix', 'loop-finalize': 'loop_finalize' }[kind];
|
|
invoke(command)
|
|
.then(() => source.postMessage({ plan2code: `${kind}-result`, ok: true, error: null }, '*'))
|
|
.catch((error) => source.postMessage({ plan2code: `${kind}-result`, ok: false, error: String(error) }, '*'));
|
|
} else if (kind === 'loop-dashboard') {
|
|
// The loop end screen's way home: a fresh dashboard session in the frame.
|
|
const source = event.source;
|
|
invoke('loop_dashboard')
|
|
.then((info) => {
|
|
source.postMessage({ plan2code: 'loop-dashboard-result', ok: true, error: null }, '*');
|
|
if (info && info.url) {
|
|
showState('Opening the dashboard...');
|
|
loadFrame(info.url);
|
|
}
|
|
})
|
|
.catch((error) => source.postMessage({ plan2code: 'loop-dashboard-result', ok: false, error: String(error) }, '*'));
|
|
} else if (kind === 'loop-notify-test') {
|
|
// Send a test: no values at all. The app reads the saved setup itself and
|
|
// asks the person to confirm in its own dialog.
|
|
const source = event.source;
|
|
invoke('loop_notify_test')
|
|
.then((sent) => source.postMessage({ plan2code: 'loop-notify-test-result', ok: true, sent, error: null }, '*'))
|
|
.catch((error) =>
|
|
source.postMessage({ plan2code: 'loop-notify-test-result', ok: false, sent: false, error: String(error) }, '*')
|
|
);
|
|
} else if (kind === 'loop-start') {
|
|
// Start: a spec folder name only. The app validates it, reads the saved
|
|
// setup itself and asks the person to confirm in its own dialog.
|
|
const source = event.source;
|
|
const spec = typeof event.data.spec === 'string' ? event.data.spec : '';
|
|
invoke('loop_start', { spec })
|
|
.then((started) => source.postMessage({ plan2code: 'loop-start-result', ok: true, started, error: null }, '*'))
|
|
.catch((error) =>
|
|
source.postMessage({ plan2code: 'loop-start-result', ok: false, error: String(error) }, '*')
|
|
);
|
|
}
|
|
});
|
|
|
|
// An Activities game in full screen: the console's frame is laid over the
|
|
// bar and the terminal (over, not instead of, so the terminal keeps its size
|
|
// and the agent sees no resize), and the window goes full screen. Off, both
|
|
// go back; the window leaves full screen only if this put it there.
|
|
let fullByGame = false;
|
|
|
|
function setGameFull(on) {
|
|
document.body.classList.toggle('console-full', on);
|
|
const win = window.__TAURI__.window.getCurrentWindow();
|
|
if (on) {
|
|
win
|
|
.isFullscreen()
|
|
.then((already) => {
|
|
if (already) return;
|
|
fullByGame = true;
|
|
return win.setFullscreen(true);
|
|
})
|
|
.catch(() => {});
|
|
} else if (fullByGame) {
|
|
fullByGame = false;
|
|
win.setFullscreen(false).catch(() => {});
|
|
}
|
|
}
|
|
|
|
// Its "Not running... type continue" line, pressed: the keystrokes
|
|
// continueKeys names, each on its own a moment after the last, so an agent
|
|
// that treats one burst of input as a paste still reads the Enter as a submit.
|
|
const ENTER_AFTER_MS = 120;
|
|
|
|
function typeContinue() {
|
|
if (!agentActive()) return;
|
|
continueKeys(agent.kind)
|
|
.reduce(
|
|
(typed, data, i) =>
|
|
typed
|
|
.then(() => (i ? new Promise((resolve) => setTimeout(resolve, ENTER_AFTER_MS)) : null))
|
|
.then(() => invoke('agent_input', { data })),
|
|
Promise.resolve()
|
|
)
|
|
.catch((error) => {
|
|
setAgentError(error, 'type continue');
|
|
});
|
|
}
|
|
|
|
// The theme and highlight color, as the console page last sent them (the
|
|
// resolved theme, and the four shades fill, soft, ink, line for each theme).
|
|
// The shell wears them: data-theme on <html> picks the tokens' light or dark
|
|
// set, the accent custom properties are the person's own, the xterm theme and
|
|
// the OS title bar follow. Both are kept for the next launch, which theme-early.js
|
|
// reads before the first paint.
|
|
const THEME_KEY = 'p2c-app:theme';
|
|
const ACCENT_KEY = 'p2c-app:accent';
|
|
const ACCENT_VARS = ['--accent', '--accent-soft', '--accent-ink', '--accent-line'];
|
|
|
|
function applyLooks({ theme, light, dark }, { save = false } = {}) {
|
|
const root = document.documentElement;
|
|
root.setAttribute('data-theme', theme);
|
|
root.style.colorScheme = theme;
|
|
const shades = theme === 'light' && light ? light : dark;
|
|
ACCENT_VARS.forEach((name, i) => root.style.setProperty(name, shades[i]));
|
|
if (save) {
|
|
try {
|
|
localStorage.setItem(THEME_KEY, theme);
|
|
localStorage.setItem(ACCENT_KEY, JSON.stringify({ light, dark }));
|
|
} catch {
|
|
// Not remembered is fine: the stylesheet's defaults show until a page loads.
|
|
}
|
|
}
|
|
// The terminal reads the tokens, so it goes last.
|
|
terminal.applyTheme();
|
|
setWindowTheme(theme);
|
|
}
|
|
|
|
// The OS title bar follows the shell's theme (Tauri's window theme). A platform
|
|
// that ignores it leaves the bar as it was.
|
|
function setWindowTheme(theme) {
|
|
try {
|
|
window.__TAURI__.window.getCurrentWindow().setTheme(theme).catch(() => {});
|
|
} catch {
|
|
// An older runtime without setTheme: the title bar keeps the system's look.
|
|
}
|
|
}
|
|
|
|
// A relaunch: theme-early.js already put the saved theme on <html> before the
|
|
// first paint; the terminal and the title bar catch up here.
|
|
terminal.applyTheme();
|
|
setWindowTheme(document.documentElement.getAttribute('data-theme') === 'light' ? 'light' : 'dark');
|
|
|
|
// No hello in time: ask the console why, and say so with a way forward.
|
|
async function onNoHello() {
|
|
if (frameReady || !consoleKnown || restarting) return;
|
|
// A page that does not answer cannot say it is done needing the person.
|
|
clearAttention();
|
|
// The next phase's console is on its way; the poll says so instead. Look
|
|
// again later all the same: dropped for good, a page that never said hello
|
|
// left its message on screen with no way out once the step moved on.
|
|
if (helloRetryAction({ loopRunning, loopStep }) === 'rearm') {
|
|
helloTimer = setTimeout(onNoHello, HELLO_WAIT_MS);
|
|
return;
|
|
}
|
|
let status = null;
|
|
try {
|
|
status = await invoke('console_status');
|
|
} catch {
|
|
// The status check itself failed; treat it as a console that is not answering.
|
|
}
|
|
if (!status || status.state !== 'running') {
|
|
showState('The console stopped, so the page could not show.', 'Reconnect the console', reconnectConsole);
|
|
} else {
|
|
// Counted per run of trouble: a hello or a new page starts it again.
|
|
pageFailures += 1;
|
|
const view = pageNotShownView(pageFailures);
|
|
const actions = { reload: reloadPage, reconnect: stopAndReconnect };
|
|
const secondary = view.secondary ? { label: view.secondary.label, onClick: actions[view.secondary.action] } : null;
|
|
const details = pageDetailsLine({ url: currentUrl || status.url, health: status.state });
|
|
showState(view.text, view.primary.label, actions[view.primary.action], undefined, { secondary, details });
|
|
}
|
|
}
|
|
|
|
// Times in a row the console ran but its page did not show (pageNotShownView).
|
|
let pageFailures = 0;
|
|
|
|
function reloadPage() {
|
|
showState('Reloading the page...');
|
|
loadFrame(currentUrl);
|
|
}
|
|
|
|
// Stop, then start: a console that runs but serves no page is started fresh
|
|
// on the same session, not just asked again.
|
|
async function stopAndReconnect() {
|
|
try {
|
|
await invoke('console_stop');
|
|
} catch {
|
|
// Nothing to stop is fine: reconnectConsole starts a fresh one either way.
|
|
}
|
|
await reconnectConsole();
|
|
}
|
|
|
|
// A waiting message that offers a way out after a countdown: the button shows
|
|
// disabled, counting down, then turns into `buttonLabel`'s plain retry.
|
|
let retryTimer = null;
|
|
|
|
function stopRetryCountdown() {
|
|
clearInterval(retryTimer);
|
|
retryTimer = null;
|
|
stateButton.disabled = false;
|
|
}
|
|
|
|
// One automatic Try reconnecting per run of trouble (cleared when a new page is announced).
|
|
let autoReconnected = false;
|
|
|
|
// What the message box shows now, as showState was asked for it (null once
|
|
// hidden).
|
|
let shownState = null;
|
|
|
|
// `secondary` is a second, plain button ({ label, onClick }); `details` a
|
|
// muted line under the buttons.
|
|
function showState(text, buttonLabel, onButton, onCancel, options = {}) {
|
|
const { tired = false, retryAfter = 0, autoRetry = false, secondary = null, details = '', rawDetails = '' } = options;
|
|
// One busy style for every wait: a spinner over the words when nothing can be pressed yet.
|
|
const busy = options.busy !== undefined ? options.busy : !buttonLabel && !onCancel;
|
|
// The poll repeats the same waiting message every tick: that must not
|
|
// restart a countdown that is already running (or its button).
|
|
if (retryAfter > 0 && !stateBox.hidden && stateText.textContent === text && stateButton.textContent.startsWith('Try reconnecting')) return;
|
|
shownState = { text, buttonLabel, onButton, onCancel, options };
|
|
stopRetryCountdown();
|
|
hideLaunchCard();
|
|
hideFirstRun();
|
|
// statePlannyEl is an <svg>: unlike HTMLElement, it does not reflect the
|
|
// `.hidden` property to the attribute, so toggling the property alone left
|
|
// `hidden` in the markup forever. The attribute itself always works.
|
|
statePlannyEl.toggleAttribute('hidden', !tired);
|
|
// Plain Planny is the first frame's "Starting Plan2Code"; the coffee break adds the mug.
|
|
statePlannyEl.classList.toggle('is-plain', !tired);
|
|
statePlannyEl.setAttribute('viewBox', tired ? '0 7 29 23' : '0 7 22 23');
|
|
stateText.textContent = text;
|
|
stateButton.hidden = !buttonLabel;
|
|
stateButton.textContent = buttonLabel || '';
|
|
stateButton.onclick = onButton || null;
|
|
stateCancelEl.hidden = !onCancel;
|
|
stateCancelEl.onclick = onCancel || null;
|
|
stateSecondaryEl.hidden = !secondary;
|
|
stateSecondaryEl.textContent = secondary ? secondary.label : '';
|
|
stateSecondaryEl.onclick = secondary ? secondary.onClick : null;
|
|
stateBusyEl.hidden = !busy;
|
|
// A friendly error keeps its raw text behind Details; a bug-report line (details) shows as it is.
|
|
stateDetailsEl.hidden = !details;
|
|
stateDetailsEl.textContent = details || rawDetails;
|
|
stateToggleEl.hidden = !rawDetails || Boolean(details);
|
|
stateToggleEl.setAttribute('aria-expanded', 'false');
|
|
stateBox.hidden = false;
|
|
if (retryAfter > 0 && buttonLabel) {
|
|
let left = retryAfter;
|
|
stateButton.disabled = true;
|
|
stateButton.textContent = retryLabel(left);
|
|
retryTimer = setInterval(() => {
|
|
left -= 1;
|
|
stateButton.textContent = retryLabel(left);
|
|
if (left <= 0) {
|
|
stopRetryCountdown();
|
|
// The button is on now: press it once for the person. If that try
|
|
// fails, the button stays for them.
|
|
if (autoRetry && onButton) {
|
|
autoReconnected = true;
|
|
onButton();
|
|
}
|
|
}
|
|
}, 1000);
|
|
}
|
|
}
|
|
|
|
// A raw error as a sentence with its next step and a Details link (meter.js friendlyError).
|
|
function showErrorState(raw, action, buttonLabel, onButton, onCancel) {
|
|
const friendly = friendlyError(raw, action);
|
|
showState(friendly.text, buttonLabel, onButton, onCancel, { rawDetails: friendly.details });
|
|
}
|
|
|
|
stateToggleEl.onclick = () => {
|
|
const open = stateDetailsEl.hidden;
|
|
stateDetailsEl.hidden = !open;
|
|
stateToggleEl.setAttribute('aria-expanded', String(open));
|
|
};
|
|
|
|
// While the agent starts and the dashboard has not opened: after ~12 s the pane stops saying
|
|
// "waiting" alone and says where to look (meter.js waitingView), and an agent that ended gets
|
|
// Change agent beside it.
|
|
let waitStartedAt = 0;
|
|
let waitTimer = null;
|
|
let waitKey = '';
|
|
|
|
function beginWait(text) {
|
|
waitStartedAt = Date.now();
|
|
waitKey = '';
|
|
showState(text, undefined, undefined, undefined, { waiting: true });
|
|
clearInterval(waitTimer);
|
|
waitTimer = setInterval(tickWait, 1000);
|
|
}
|
|
|
|
function endWait() {
|
|
clearInterval(waitTimer);
|
|
waitTimer = null;
|
|
}
|
|
|
|
function tickWait() {
|
|
// Gone from the screen (the dashboard came, or something else spoke): nothing left to time.
|
|
if (stateBox.hidden || !shownState || !shownState.options.waiting) {
|
|
endWait();
|
|
return;
|
|
}
|
|
const view = waitingView({ waitedMs: Date.now() - waitStartedAt, agentState: agent.state });
|
|
const key = view.still ? `${view.text}|${view.changeAgent}` : '';
|
|
if (!view.still || key === waitKey) return;
|
|
waitKey = key;
|
|
showState(view.text, 'Show the terminal', showTerminal, undefined, {
|
|
waiting: true,
|
|
busy: !view.changeAgent,
|
|
secondary: view.changeAgent ? { label: 'Change agent', onClick: showLaunchCard } : null,
|
|
});
|
|
}
|
|
|
|
function hideState() {
|
|
endWait();
|
|
stopRetryCountdown();
|
|
stateBox.hidden = true;
|
|
shownState = null;
|
|
}
|
|
|
|
let pollTimer = null;
|
|
|
|
// Only once the agent has opened a page: brings an idle or dead console back
|
|
// on its own session. The app never opens a dashboard on its own (the agent
|
|
// does, by running the skill), so there is nothing to start before that.
|
|
async function reconnectConsole() {
|
|
markConsoleAlive();
|
|
showState('Reconnecting to the console...');
|
|
try {
|
|
const info = await invoke('console_start');
|
|
loadFrame(info.url);
|
|
} catch (error) {
|
|
showErrorState(error, 'reach the console', 'Retry', reconnectConsole);
|
|
// An old console cannot be framed: the fix is the skills update, so offer it.
|
|
if (String(error).includes('too old')) setVersionState({ kind: 'too-old' });
|
|
}
|
|
}
|
|
|
|
// Health check on a timer. A console that dies after its page showed (it idles
|
|
// out, or something ended it) is brought back on the same session, a few times
|
|
// at most; before the page ever showed, the person decides with a button.
|
|
const RECONNECT_LIMIT = 3;
|
|
let reconnects = 0;
|
|
|
|
async function pollConsole() {
|
|
try {
|
|
const status = await invoke('console_status');
|
|
if (status.state === 'running') {
|
|
markConsoleAlive();
|
|
return;
|
|
}
|
|
const action = deadConsoleAction({ loopRunning, loopStep, frameReady, reconnects, limit: RECONNECT_LIMIT });
|
|
if (action === 'wait-for-phase') {
|
|
// Covers the old phase's page and its "Lost contact" until the new one
|
|
// says hello. Never over a question the box is already asking.
|
|
if (stateCancelEl.hidden) showState(loopDetailEl.textContent, 'Try reconnecting', reconnectConsole, undefined, { retryAfter: RETRY_AFTER_SECONDS, autoRetry: !autoReconnected });
|
|
return;
|
|
}
|
|
markConsoleDead();
|
|
if (action === 'reconnect') {
|
|
reconnects += 1;
|
|
showState('The console stopped. Reconnecting...');
|
|
await reconnectConsole();
|
|
} else if (action === 'no-hello') {
|
|
onNoHello();
|
|
}
|
|
} catch {
|
|
// A failed check is not proof the console died; look again next tick.
|
|
}
|
|
}
|
|
|
|
// Once, at start: when the app and the installed skills are on different versions the bar
|
|
// says so and offers Update skills. Nothing runs until that button is pressed.
|
|
async function checkVersions() {
|
|
try {
|
|
const status = await invoke('version_status');
|
|
if (!status.mismatch) return;
|
|
// Skills ahead of this app: another Update skills run cannot help, so
|
|
// that state offers no button.
|
|
setVersionState({ kind: status.skills_ahead ? 'ahead' : 'mismatch', skills: status.skills, app: status.app });
|
|
} catch {
|
|
// No version to compare is no reason to nag.
|
|
}
|
|
}
|
|
|
|
// At start, and again every few hours (the app stays open for days), never waited on: is a newer
|
|
// Plan2Code release out on GitHub? The Rust side asks (the same tag lookup the web console uses) and
|
|
// answers `{ latest, problem }`: the newer version, or a sentence when the check could not run (git
|
|
// missing), or neither when the app is current. An update already running is never replaced.
|
|
async function checkNewRelease() {
|
|
try {
|
|
setNewRelease(releaseAfterCheck(newRelease, await invoke('check_new_release')));
|
|
} catch {
|
|
// No answer is no reason to nag.
|
|
}
|
|
}
|
|
|
|
// "Update and restart": the installer runs unpinned (the newest release) through the same progress
|
|
// line as Update skills, then the app restarts itself, guarded by the quit check. A failure leaves
|
|
// this app running, with the reason in the bar and the old command as the fallback.
|
|
async function updateAndRestart() {
|
|
if (!newRelease || !newRelease.latest) return;
|
|
const latest = newRelease.latest;
|
|
setNewRelease({ latest, updating: '' });
|
|
const progress = new Channel();
|
|
progress.onmessage = (line) => {
|
|
if (line && newRelease && newRelease.updating !== undefined) setNewRelease({ latest, updating: line });
|
|
};
|
|
try {
|
|
await invoke('update_to_newest', { progress });
|
|
} catch (error) {
|
|
setNewRelease({ latest, failed: reasonSentence(error) });
|
|
return;
|
|
}
|
|
await restartApp(latest);
|
|
}
|
|
|
|
// The respawn itself. With an agent or a loop running the person is asked first (the quit check):
|
|
// "asking" leaves the app up, so the bar then offers Restart Plan2Code for when they are ready.
|
|
async function restartApp(latest = newRelease && newRelease.latest) {
|
|
if (latest) setNewRelease({ latest, updating: 'Restarting Plan2Code...' });
|
|
try {
|
|
const outcome = await invoke('restart_app', { confirmed: false });
|
|
if (outcome === 'asking' && latest) setNewRelease({ latest, restartNeeded: true });
|
|
} catch (error) {
|
|
if (latest) setNewRelease({ latest, failed: reasonSentence(error) });
|
|
else setAgentError(error, 'restart Plan2Code');
|
|
}
|
|
}
|
|
|
|
// After the restart: "Updated to vX", once, for a short while.
|
|
async function showUpdatedTo() {
|
|
try {
|
|
const status = await invoke('version_status');
|
|
const now = status.app || null;
|
|
// The same version after the restart: the installer kept the old app (no desktop app file in
|
|
// that release yet), so it is not "Updated to".
|
|
if (now && appState && appState.updatedFrom && now === appState.updatedFrom) {
|
|
notReplaced = now;
|
|
updatedTo = null;
|
|
} else {
|
|
updatedTo = now;
|
|
notReplaced = null;
|
|
}
|
|
} catch {
|
|
updatedTo = null;
|
|
notReplaced = null;
|
|
}
|
|
renderNextStep();
|
|
setTimeout(() => {
|
|
updatedTo = null;
|
|
notReplaced = null;
|
|
renderNextStep();
|
|
}, UPDATED_NOTE_MS);
|
|
}
|
|
|
|
// The About dialog and Check for updates, from the bar's menu.
|
|
async function showAbout() {
|
|
let status = null;
|
|
try {
|
|
status = await invoke('version_status');
|
|
} catch {
|
|
// The dialog still opens, with what it can say.
|
|
}
|
|
const lines = [{ kind: 'text', text: status && status.app ? `This is Plan2Code v${status.app}.` : 'Plan2Code desktop app.' }];
|
|
if (status && status.skills) lines.push({ kind: 'text', text: `The installed skills are v${status.skills}.` });
|
|
const notes = status && status.app && (await confirmModal({ title: 'About Plan2Code', lines, primary: 'Release notes', cancel: 'Close', safeFirst: true }));
|
|
if (notes) openLink(releaseNotesUrl(status.app));
|
|
else if (!status || !status.app) void confirmModal({ title: 'About Plan2Code', lines, cancel: 'Close', primary: null });
|
|
}
|
|
|
|
async function checkUpdatesNow() {
|
|
let result = null;
|
|
try {
|
|
result = await invoke('check_new_release');
|
|
} catch {
|
|
// Said below.
|
|
}
|
|
setNewRelease(releaseAfterCheck(newRelease, result));
|
|
if (result && result.latest) return;
|
|
const text = result ? result.problem || 'Plan2Code is up to date.' : 'Could not check for updates.';
|
|
void confirmModal({ title: 'Check for updates', lines: [{ kind: 'text', text }], cancel: 'Close', primary: null });
|
|
}
|
|
|
|
async function updateSkills() {
|
|
setVersionState({ kind: 'updating', line: 'Updating Plan2Code...' });
|
|
const progress = new Channel();
|
|
progress.onmessage = (line) => {
|
|
if (line && versionState && versionState.kind === 'updating') setVersionState({ kind: 'updating', line });
|
|
};
|
|
try {
|
|
const outcome = await invoke('update_skills', { progress });
|
|
setVersionState(
|
|
outcome.status.mismatch
|
|
? { kind: 'remains', skills: outcome.status.skills, app: outcome.status.app }
|
|
: { kind: 'updated' }
|
|
);
|
|
} catch (error) {
|
|
setVersionState({ kind: 'failed', error: String(error) });
|
|
}
|
|
}
|
|
|
|
// After an update: stop the old console first, so the new skills are really
|
|
// picked up, then bring a fresh one back on the same session.
|
|
async function restartConsole() {
|
|
try {
|
|
await invoke('console_stop');
|
|
} catch {
|
|
// Nothing to stop is fine: reconnectConsole starts a fresh one either way.
|
|
}
|
|
setVersionState(null);
|
|
await reconnectConsole();
|
|
}
|
|
|
|
// A page the agent's `console.mjs open` asked this window to show. Which page
|
|
// it is shows inside the frame itself (the console's own badge and title),
|
|
// not repeated here.
|
|
function showAnnounced(notice) {
|
|
endWait();
|
|
restarting = false;
|
|
// A new page is a new start: the budget is per run of trouble, not per launch.
|
|
reconnects = 0;
|
|
autoReconnected = false;
|
|
if (!consoleKnown) {
|
|
consoleKnown = true;
|
|
if (!pollTimer) pollTimer = setInterval(pollConsole, STATUS_POLL_MS);
|
|
}
|
|
markConsoleAlive();
|
|
if (notice.url !== currentUrl) {
|
|
// A new page gets its own Reload the page before "still did not load".
|
|
pageFailures = 0;
|
|
showState('Opening the page...');
|
|
loadFrame(notice.url);
|
|
}
|
|
}
|
|
|
|
window.__TAURI__.event.listen('console-page', (event) => showAnnounced(event.payload));
|
|
|
|
// "45s", "12m", "1h 12m": whole units, the largest two at most.
|
|
function formatElapsed(ms) {
|
|
const total = Math.max(0, Math.floor((Number(ms) || 0) / 1000));
|
|
if (total < 60) return `${total}s`;
|
|
const minutes = Math.floor(total / 60);
|
|
if (minutes < 60) return `${minutes}m`;
|
|
return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
|
|
}
|
|
|
|
// The Implementation Loop's banner across the window, drawn from the app's
|
|
// loop-state. It lives here and not in the console page because a loop runs
|
|
// across many sessions: the page changes under it, and this does not.
|
|
let loopTimer = null;
|
|
let loopStartedAt = 0;
|
|
|
|
function tickLoopElapsed() {
|
|
loopElapsedEl.textContent = formatElapsed(Date.now() - loopStartedAt);
|
|
}
|
|
|
|
function setLoopTitle(title) {
|
|
window.__TAURI__.window.getCurrentWindow().setTitle(title).catch(() => {});
|
|
}
|
|
|
|
// The app ending the loop's last agent ended that agent's console too, so the
|
|
// page holding the stop or finish card has to be brought back, at once and
|
|
// whatever the budget says: it is the one thing the person came back to read.
|
|
async function showLoopEnd() {
|
|
reconnects = 0;
|
|
try {
|
|
const status = await invoke('console_status');
|
|
if (status.state === 'dead') await reconnectConsole();
|
|
} catch {
|
|
// The poll looks again on its next tick.
|
|
}
|
|
}
|
|
|
|
// Change project and Change agent are off while a loop runs, with the reason on
|
|
// them; the app refuses them too.
|
|
function applyLoopLocks(state) {
|
|
const { locked, reason } = loopLocks(state);
|
|
for (const button of [changeProjectBtn, changeAgentBtn]) {
|
|
button.disabled = locked;
|
|
button.title = locked ? reason : button === changeProjectBtn ? tipWithShortcut('Change project', 'change-project', IS_MAC) : '';
|
|
}
|
|
}
|
|
|
|
// Asks the app what the loop is doing: a reloaded window has missed every
|
|
// loop-state event so far, and one sent between the first ask and the listener
|
|
// is caught by asking again once it listens.
|
|
async function syncLoopState() {
|
|
// The reply and the loop-state event travel apart: an event that landed while
|
|
// the question was out is newer than the answer, which then is dropped.
|
|
const seen = loopEventSeq;
|
|
try {
|
|
const state = await invoke('loop_state');
|
|
if (seen !== loopEventSeq) return;
|
|
// No loop and none drawn: nothing to redraw. One drawn that is gone: it ended.
|
|
if (state) applyLoopState(state);
|
|
else if (loopRunning) applyLoopState({ running: false });
|
|
} catch {
|
|
// The next loop-state event tells it.
|
|
}
|
|
}
|
|
|
|
function applyLoopState(state) {
|
|
if (!state || !state.running) {
|
|
const wasRunning = loopRunning;
|
|
loopRunning = false;
|
|
loopStep = '';
|
|
if (wasRunning) showLoopEnd();
|
|
clearInterval(loopTimer);
|
|
loopTimer = null;
|
|
loopBannerEl.hidden = true;
|
|
applyLoopLocks({ running: false });
|
|
setLoopTitle(windowTitleFor(projectPathEl.textContent));
|
|
// New Session's visibility is applyAgentState's rule alone.
|
|
applyAgentState(agent, { skipReset: true });
|
|
return;
|
|
}
|
|
if (!loopRunning) loopTypingNoted = false;
|
|
loopRunning = true;
|
|
const stepBefore = loopStep;
|
|
loopStep = state.step || '';
|
|
restartBtn.hidden = true;
|
|
applyLoopLocks(state);
|
|
const banner = loopBanner(state);
|
|
loopBannerEl.hidden = false;
|
|
loopBannerEl.dataset.tone = banner.tone;
|
|
// Only a change of words: this is a live region, and screen readers read it out.
|
|
if (loopTitleEl.textContent !== banner.title) loopTitleEl.textContent = banner.title;
|
|
if (loopDetailEl.textContent !== banner.detail) loopDetailEl.textContent = banner.detail;
|
|
// A phase starting: look at the console now, so its waiting message and
|
|
// countdown begin at once, not at the next status poll.
|
|
if (loopStep === 'Starting' && stepBefore !== 'Starting' && consoleKnown) void pollConsole();
|
|
loopHintEl.textContent = banner.hint;
|
|
loopSpecEl.textContent = state.specName || '';
|
|
loopPipsEl.replaceChildren(
|
|
...banner.pips.map((kind, i) => {
|
|
const pip = document.createElement('span');
|
|
pip.className = `loop-pip ${kind}`;
|
|
pip.title = `Phase ${i + 1}`;
|
|
return pip;
|
|
})
|
|
);
|
|
setLoopTitle(loopWindowTitle(projectPathEl.textContent, state));
|
|
const stopLabels = loopStopLabels(state);
|
|
loopStopAfterOn = !!state.stopAfterPhase;
|
|
loopStopAfterBtn.disabled = stopLabels.afterDisabled;
|
|
loopStopAfterBtn.textContent = stopLabels.afterText;
|
|
loopStopNowBtn.disabled = stopLabels.nowDisabled;
|
|
// A good state means the last press went through.
|
|
hideLoopError();
|
|
const retries = Number(state.retriesUsed) || 0;
|
|
loopRetriesEl.hidden = retries <= 0;
|
|
loopRetriesEl.textContent = retries === 1 ? '1 retry' : `${retries} retries`;
|
|
loopStartedAt = Number(state.startedAtMs) || Date.now();
|
|
tickLoopElapsed();
|
|
if (!loopTimer) loopTimer = setInterval(tickLoopElapsed, 1000);
|
|
}
|
|
|
|
let loopEventSeq = 0;
|
|
window.__TAURI__.event
|
|
.listen('loop-state', (event) => {
|
|
loopEventSeq += 1;
|
|
applyLoopState(event.payload);
|
|
})
|
|
.then(syncLoopState, () => {});
|
|
|
|
// A press that fails shows why next to the buttons, with a Retry for the same press.
|
|
let loopRetryAction = null;
|
|
let loopErrorRaw = '';
|
|
loopErrorEl.tabIndex = 0;
|
|
const openLoopError = () => {
|
|
void confirmModal({ title: 'What went wrong', lines: [{ kind: 'text', text: loopErrorEl.textContent }, ...(loopErrorRaw ? [{ kind: 'code', text: loopErrorRaw }] : [])], cancel: 'Close', primary: null });
|
|
};
|
|
loopErrorEl.addEventListener('click', openLoopError);
|
|
loopErrorEl.addEventListener('keydown', (event) => {
|
|
if (event.key === 'Enter' || event.key === ' ') {
|
|
event.preventDefault();
|
|
openLoopError();
|
|
}
|
|
});
|
|
function hideLoopError() {
|
|
loopErrorEl.hidden = true;
|
|
loopErrorEl.textContent = '';
|
|
loopErrorRaw = '';
|
|
loopRetryBtn.hidden = true;
|
|
loopRetryAction = null;
|
|
}
|
|
function pressLoop(command, args) {
|
|
const press = () =>
|
|
invoke(command, args).then(hideLoopError, (e) => {
|
|
// In plain words, with the raw text behind a press on the line.
|
|
const friendly = friendlyError(String(e && e.message ? e.message : e), 'do that');
|
|
loopErrorEl.textContent = friendly.text;
|
|
loopErrorEl.title = friendly.details;
|
|
loopErrorRaw = friendly.details;
|
|
loopErrorEl.hidden = false;
|
|
loopRetryBtn.hidden = false;
|
|
loopRetryAction = press;
|
|
});
|
|
return press();
|
|
}
|
|
loopRetryBtn.onclick = () => {
|
|
if (loopRetryAction) loopRetryAction();
|
|
};
|
|
loopStopAfterBtn.onclick = () => pressLoop('loop_stop_after_phase', { on: !loopStopAfterOn });
|
|
loopStopNowBtn.onclick = async () => {
|
|
const yes = await confirmModal({
|
|
title: 'End the agent now?',
|
|
lines: [{ kind: 'text', text: "This phase's changes stay uncommitted." }],
|
|
primary: 'Stop now',
|
|
danger: true,
|
|
});
|
|
if (yes) pressLoop('loop_stop_now');
|
|
};
|
|
|
|
// The right end of the bar: whether the console stopped answering and where
|
|
// the skills stand against this app, drawn as one next step (meter.js
|
|
// barNextSteps decides which, and its button), with the rest as "+N more".
|
|
let consoleDead = false;
|
|
let versionState = null;
|
|
let newRelease = null;
|
|
const NEXT_STEP_ACTIONS = { reconnect: reconnectConsole, 'restart-console': restartConsole, update: updateSkills, 'update-restart': () => updateAndRestart(), 'restart-app': () => restartApp() };
|
|
const UPDATED_NOTE_MS = 20000;
|
|
let updatedTo = null;
|
|
let notReplaced = null;
|
|
let nextStepAction = null;
|
|
|
|
function renderNextStep() {
|
|
const steps = barNextSteps({ consoleDead, version: versionState, newRelease, updatedTo, notReplaced });
|
|
nextStepEl.hidden = steps.length === 0;
|
|
const [first, ...rest] = steps;
|
|
nextStepTextEl.replaceChildren(...commandNodes(first ? first.text : ''));
|
|
nextStepTextEl.title = first ? plainCommandText(first.title) : '';
|
|
nextStepTextEl.className = first ? `is-${first.tone}${first.busy ? ' is-busy' : ''}` : '';
|
|
nextStepAction = first && first.action ? NEXT_STEP_ACTIONS[first.action] : null;
|
|
nextStepBtn.hidden = !nextStepAction;
|
|
nextStepBtn.disabled = false;
|
|
nextStepBtn.textContent = first && first.label ? first.label : '';
|
|
// "What's new": the release page, in the default browser.
|
|
const notes = first && first.link ? first.link : null;
|
|
nextStepNotesEl.hidden = !notes;
|
|
nextStepNotesEl.onclick = notes ? () => openLink(notes.url) : null;
|
|
nextStepMoreEl.hidden = rest.length === 0;
|
|
nextStepMoreEl.textContent = `+${rest.length} more`;
|
|
nextStepMoreEl.setAttribute('aria-label', `${rest.length} more ${rest.length === 1 ? 'step' : 'steps'}`);
|
|
renderMoreMenu(rest);
|
|
}
|
|
|
|
// The other pending steps, each with its full sentence (a failed update's
|
|
// last line included) and its own action, when it has one.
|
|
function renderMoreMenu(rest) {
|
|
moreMenu.replaceChildren(
|
|
...rest.map((step) => {
|
|
const row = document.createElement('div');
|
|
row.className = 'more-step';
|
|
const text = document.createElement('p');
|
|
text.className = `is-${step.tone}`;
|
|
text.replaceChildren(...commandNodes(step.title));
|
|
row.append(text);
|
|
const action = step.action ? NEXT_STEP_ACTIONS[step.action] : null;
|
|
if (action && step.label) {
|
|
const button = document.createElement('button');
|
|
button.type = 'button';
|
|
button.setAttribute('role', 'menuitem');
|
|
button.textContent = step.label;
|
|
button.onclick = () => {
|
|
closeBarMenus();
|
|
action();
|
|
};
|
|
row.append(button);
|
|
}
|
|
if (step.link) {
|
|
const link = document.createElement('button');
|
|
link.type = 'button';
|
|
link.setAttribute('role', 'menuitem');
|
|
link.textContent = step.link.label;
|
|
link.onclick = () => {
|
|
closeBarMenus();
|
|
openLink(step.link.url);
|
|
};
|
|
row.append(link);
|
|
}
|
|
return row;
|
|
})
|
|
);
|
|
if (rest.length === 0 && openBarMenu === moreMenu) closeBarMenus();
|
|
}
|
|
|
|
function setVersionState(next) {
|
|
versionState = next;
|
|
renderNextStep();
|
|
}
|
|
|
|
function setNewRelease(next) {
|
|
newRelease = next;
|
|
renderNextStep();
|
|
}
|
|
|
|
function markConsoleAlive() {
|
|
consoleDead = false;
|
|
renderNextStep();
|
|
}
|
|
|
|
function markConsoleDead() {
|
|
consoleDead = true;
|
|
renderNextStep();
|
|
}
|
|
|
|
nextStepBtn.onclick = () => {
|
|
if (!nextStepAction) return;
|
|
// Pressed once per step: whatever it starts draws the next state itself.
|
|
nextStepBtn.disabled = true;
|
|
nextStepAction();
|
|
};
|
|
|
|
function setProjectDir(dir) {
|
|
// The bar names the folder; its menu holds the full path.
|
|
projectNameEl.textContent = folderName(dir);
|
|
projectMenuBtn.title = dir;
|
|
projectPathEl.textContent = dir;
|
|
projectMenuBtn.hidden = !dir;
|
|
// So two or more windows read apart in the taskbar without opening each
|
|
// one: a setTitle that fails (an old Tauri runtime, say) just leaves the
|
|
// static "Plan2Code" title from tauri.conf.json, never breaks the start.
|
|
window.__TAURI__.window.getCurrentWindow().setTitle(windowTitleFor(dir)).catch(() => {});
|
|
}
|
|
|
|
// The state `main()` read at startup: the folder picker and the first-run
|
|
// checklist both need it once a folder lands, after the fact.
|
|
let appState = null;
|
|
|
|
// The open folder picker's way back to its caller (null while none is open).
|
|
let folderPickerResolve = null;
|
|
|
|
function hideFolderPicker() {
|
|
folderPickerEl.hidden = true;
|
|
folderPickerEl.classList.remove('is-dialog');
|
|
folderPickerListEl.replaceChildren();
|
|
}
|
|
|
|
function closeFolderPicker(dir) {
|
|
const resolve = folderPickerResolve;
|
|
folderPickerResolve = null;
|
|
hideFolderPicker();
|
|
if (resolve) resolve(dir);
|
|
}
|
|
|
|
// The picker's error in plain words; the raw text stays as its tooltip (meter.js friendlyError).
|
|
function setFolderPickerError(raw, action) {
|
|
const friendly = raw ? friendlyError(raw, action) : { text: '', details: '' };
|
|
folderPickerErrorEl.textContent = friendly.text;
|
|
folderPickerErrorEl.title = friendly.details;
|
|
folderPickerErrorEl.hidden = !friendly.text;
|
|
}
|
|
|
|
function folderPickerButtons() {
|
|
return [...folderPickerListEl.querySelectorAll('.folder-picker-row')];
|
|
}
|
|
|
|
// One picker for a bare start (`dialog: false`, full screen) and Change
|
|
// project (`dialog: true`, over the page, with Cancel and Escape). Choose a
|
|
// folder runs the OS dialog; a recent row opens that folder. Resolves with
|
|
// the folder opened, or null when the person cancels the dialog. A canceled
|
|
// OS dialog comes back here, and an error shows inline with the rows usable.
|
|
async function showFolderPicker({ dialog }) {
|
|
if (folderPickerResolve) closeFolderPicker(null);
|
|
stopRetryCountdown();
|
|
stateBox.hidden = true;
|
|
if (!dialog) {
|
|
hideLaunchCard();
|
|
hideFirstRun();
|
|
}
|
|
setFolderPickerError('');
|
|
folderPickerCancelBtn.hidden = !dialog;
|
|
folderPickerEl.classList.toggle('is-dialog', dialog);
|
|
if (dialog) folderPickerPanelEl.setAttribute('aria-modal', 'true');
|
|
else folderPickerPanelEl.removeAttribute('aria-modal');
|
|
// The project already open is left out by the command itself.
|
|
let recent = [];
|
|
try {
|
|
recent = (await invoke('recent_folders')) || [];
|
|
} catch (error) {
|
|
setFolderPickerError(error, 'read the recent folders');
|
|
}
|
|
folderPickerListEl.replaceChildren(
|
|
...folderPickerRows(recent).map((row) => {
|
|
const li = document.createElement('li');
|
|
const button = document.createElement('button');
|
|
button.type = 'button';
|
|
button.className = `folder-picker-row is-${row.kind}`;
|
|
const label = document.createElement('span');
|
|
label.className = 'folder-picker-label';
|
|
label.textContent = row.label;
|
|
button.append(label);
|
|
if (row.detail) {
|
|
const detail = document.createElement('span');
|
|
detail.className = 'folder-picker-detail';
|
|
detail.textContent = row.detail;
|
|
button.append(detail);
|
|
}
|
|
button.onclick = () => chooseFolderRow(row, button, dialog);
|
|
li.append(button);
|
|
return li;
|
|
})
|
|
);
|
|
folderPickerEl.hidden = false;
|
|
folderPickerButtons()[0].focus();
|
|
return new Promise((resolve) => {
|
|
folderPickerResolve = resolve;
|
|
});
|
|
}
|
|
|
|
// One row pressed: the OS dialog for Choose a folder (`change_project` from
|
|
// Change project, which tears the old project down), else that recent
|
|
// folder. Nothing chosen keeps the picker up, focus back on the row.
|
|
async function chooseFolderRow(row, button, dialog) {
|
|
const buttons = folderPickerButtons();
|
|
buttons.forEach((b) => { b.disabled = true; });
|
|
folderPickerCancelBtn.disabled = true;
|
|
setFolderPickerError('');
|
|
let dir = null;
|
|
try {
|
|
if (row.kind === 'browse') dir = await invoke(dialog ? 'change_project' : 'pick_project_folder');
|
|
else dir = await invoke('open_recent_folder', { dir: row.dir });
|
|
} catch (error) {
|
|
setFolderPickerError(error, row.kind === 'browse' ? 'open the folder picker' : `open ${row.dir}`);
|
|
}
|
|
buttons.forEach((b) => { b.disabled = false; });
|
|
folderPickerCancelBtn.disabled = false;
|
|
if (dir) {
|
|
closeFolderPicker(dir);
|
|
return;
|
|
}
|
|
button.focus();
|
|
}
|
|
|
|
folderPickerCancelBtn.onclick = () => closeFolderPicker(null);
|
|
// Escape is heard on the document: a click on the backdrop or the heading
|
|
// leaves focus on the page, where a listener on the picker never sees it.
|
|
document.addEventListener('keydown', (event) => {
|
|
if (event.defaultPrevented || event.key !== 'Escape' || folderPickerEl.hidden) return;
|
|
if (folderPickerCancelBtn.hidden || folderPickerCancelBtn.disabled) return;
|
|
event.preventDefault();
|
|
closeFolderPicker(null);
|
|
});
|
|
folderPickerEl.addEventListener('keydown', (event) => {
|
|
if (event.key !== 'ArrowDown' && event.key !== 'ArrowUp') return;
|
|
const buttons = folderPickerButtons();
|
|
const at = buttons.indexOf(document.activeElement);
|
|
if (at < 0) return;
|
|
event.preventDefault();
|
|
const next = event.key === 'ArrowDown' ? Math.min(at + 1, buttons.length - 1) : Math.max(at - 1, 0);
|
|
buttons[next].focus();
|
|
});
|
|
|
|
// A bare start: the picker, full screen, until a folder is opened.
|
|
async function chooseStartFolder() {
|
|
const dir = await showFolderPicker({ dialog: false });
|
|
if (!dir) return;
|
|
setProjectDir(dir);
|
|
if (appState) appState.projectDir = dir;
|
|
afterProjectKnown();
|
|
}
|
|
|
|
// Once a project folder is known: the first-run checklist (once, until it
|
|
// passes) or straight to the launch card.
|
|
function afterProjectKnown() {
|
|
if (appState && !appState.firstRunDone) {
|
|
showFirstRun(appState);
|
|
} else {
|
|
showLaunchCard();
|
|
}
|
|
}
|
|
|
|
// Switches to a folder picked in the folder picker's dialog: the Rust side
|
|
// tears the old project's agent and console down before the new one is
|
|
// remembered, so nothing from it carries over. Cancel (or Escape) leaves
|
|
// the current project as it was; the folder already open is not listed.
|
|
async function doChangeProject() {
|
|
try {
|
|
const dir = await showFolderPicker({ dialog: true });
|
|
if (!dir) {
|
|
// Cancel leaves the page as it was: a running agent gets the keyboard
|
|
// back, and a dashboard still on screen is never covered.
|
|
if (agentActive() || frameReady) hideState();
|
|
else afterProjectKnown();
|
|
if (agentActive()) terminal.focus();
|
|
return;
|
|
}
|
|
setProjectDir(dir);
|
|
if (appState) appState.projectDir = dir;
|
|
restarting = false;
|
|
currentUrl = null;
|
|
frameReady = false;
|
|
afterProjectKnown();
|
|
} catch (error) {
|
|
showErrorState(error, 'switch project', 'Try again', doChangeProject);
|
|
}
|
|
}
|
|
|
|
async function changeProject() {
|
|
if (agentActive()) {
|
|
const yes = await confirmModal({
|
|
title: 'Stop the running agent and switch to a different project?',
|
|
lines: [{ kind: 'text', text: 'What the agent was doing is not saved.' }],
|
|
primary: 'Change project',
|
|
danger: true,
|
|
});
|
|
if (!yes) return;
|
|
}
|
|
doChangeProject();
|
|
}
|
|
|
|
changeProjectBtn.onclick = () => {
|
|
closeBarMenus();
|
|
changeProject();
|
|
};
|
|
|
|
// The launcher passed `--agent`: start it at once, on its model, with the
|
|
// same bypass flags the terminal launcher itself always runs that agent with
|
|
// (it offers no permission-mode choice of its own).
|
|
async function autoStartAgent(state) {
|
|
launchAgentEl.value = state.autoStart;
|
|
if (typeof state.launchModel === 'string' && state.launchModel) launchModelEl.value = state.launchModel;
|
|
setAgentStatus('');
|
|
beginWait('Starting the agent...');
|
|
const { cols, rows } = terminal.size();
|
|
try {
|
|
await invoke('agent_start', {
|
|
kind: state.autoStart,
|
|
model: state.launchModel || null,
|
|
effort: null,
|
|
mode: 'bypass',
|
|
cols,
|
|
rows,
|
|
});
|
|
terminal.focus();
|
|
} catch (error) {
|
|
endWait();
|
|
setAgentError(error, 'start the agent');
|
|
showLaunchCard();
|
|
}
|
|
}
|
|
|
|
// A page that just mounted registers its output channel and, if an agent
|
|
// already ran before it (a reload, or this is the window's first paint
|
|
// after one survived a restart), gets its recent output replayed onto a
|
|
// clean xterm at once instead of starting blank.
|
|
async function recoverAfterReload(snapshot) {
|
|
applyAgentState(snapshot, { skipReset: true });
|
|
terminal.focus();
|
|
hideState();
|
|
consoleKnown = true;
|
|
if (!pollTimer) pollTimer = setInterval(pollConsole, STATUS_POLL_MS);
|
|
try {
|
|
const status = await invoke('console_status');
|
|
if (status.state === 'running' && status.url) {
|
|
loadFrame(status.url);
|
|
} else {
|
|
onNoHello();
|
|
}
|
|
} catch {
|
|
onNoHello();
|
|
}
|
|
}
|
|
|
|
// --- The one confirm dialog (A10) -------------------------------------------------------------
|
|
// Drawn here, outside the page's frame, so the page can never fake one. `lines` are
|
|
// { kind: 'text' | 'code' | 'callout', text }; the safe button comes first and has focus, the
|
|
// named danger verb last (meter.js confirmButtons). Resolves true for the primary, false for
|
|
// Cancel or Escape. A null `primary` makes it a plain notice with one Close button.
|
|
let confirmResolve = null;
|
|
let confirmReturnFocus = null;
|
|
// The id of the Rust request on screen ('' for the shell's own), so the Rust side can take it back.
|
|
let confirmShownId = '';
|
|
const shellParts = () => ['bar', 'loop-banner', 'workspace'].map((id) => document.getElementById(id)).filter(Boolean);
|
|
|
|
function confirmModal({ title, lines = [], primary = 'OK', cancel = 'Cancel', danger = false, safeFirst = true, id = '' }) {
|
|
if (confirmResolve) closeConfirm(false);
|
|
return new Promise((resolve) => {
|
|
confirmResolve = resolve;
|
|
confirmShownId = id;
|
|
confirmReturnFocus = document.activeElement;
|
|
confirmTitleEl.textContent = title;
|
|
confirmBodyEl.replaceChildren(
|
|
...lines.map((line) => {
|
|
const item = typeof line === 'string' ? { kind: 'text', text: line } : line;
|
|
if (item.kind === 'code') {
|
|
const pre = document.createElement('pre');
|
|
pre.textContent = item.text;
|
|
return pre;
|
|
}
|
|
const p = document.createElement('p');
|
|
if (item.kind === 'callout') p.className = 'confirm-callout';
|
|
p.replaceChildren(...commandNodes(item.text));
|
|
return p;
|
|
})
|
|
);
|
|
confirmCancelBtn.textContent = cancel;
|
|
confirmPrimaryBtn.hidden = !primary;
|
|
confirmPrimaryBtn.textContent = primary || '';
|
|
confirmPrimaryBtn.classList.toggle('is-danger', Boolean(danger));
|
|
const layout = confirmButtons({ safeFirst: primary ? safeFirst : true });
|
|
confirmActionsEl.replaceChildren(...layout.order.map((which) => (which === 'cancel' ? confirmCancelBtn : confirmPrimaryBtn)));
|
|
// The rest of the shell is out of reach while it asks.
|
|
for (const part of shellParts()) part.inert = true;
|
|
confirmModalEl.hidden = false;
|
|
(layout.focus === 'cancel' ? confirmCancelBtn : confirmPrimaryBtn).focus();
|
|
});
|
|
}
|
|
|
|
function closeConfirm(answer) {
|
|
const resolve = confirmResolve;
|
|
confirmResolve = null;
|
|
confirmShownId = '';
|
|
confirmModalEl.hidden = true;
|
|
for (const part of shellParts()) part.inert = false;
|
|
const back = confirmReturnFocus;
|
|
confirmReturnFocus = null;
|
|
if (back && back.isConnected && typeof back.focus === 'function') back.focus();
|
|
if (resolve) resolve(answer);
|
|
}
|
|
|
|
confirmCancelBtn.onclick = () => closeConfirm(false);
|
|
confirmPrimaryBtn.onclick = () => closeConfirm(true);
|
|
// Escape is heard on the document, in the capture phase, while the modal is up: a click on the scrim
|
|
// leaves focus on the page, where a listener on the modal never sees it, and nothing behind the modal
|
|
// (the folder picker, a bar menu) may take the same key.
|
|
document.addEventListener(
|
|
'keydown',
|
|
(event) => {
|
|
if (event.key !== 'Escape' || confirmModalEl.hidden) return;
|
|
event.preventDefault();
|
|
event.stopImmediatePropagation();
|
|
closeConfirm(false);
|
|
},
|
|
true
|
|
);
|
|
confirmModalEl.addEventListener('keydown', (event) => {
|
|
if (event.key === 'Tab') {
|
|
const buttons = [...confirmActionsEl.querySelectorAll('button')].filter((b) => !b.hidden);
|
|
const next = trapTab(event.shiftKey, buttons.indexOf(document.activeElement), buttons.length);
|
|
if (next === null) return;
|
|
event.preventDefault();
|
|
buttons[next].focus();
|
|
}
|
|
});
|
|
|
|
// The Rust side asks for a confirm too (the loop start, and the quit check outside Windows): it sends
|
|
// the same fields and waits for confirm_answer. Only the fields below are read. When it gives up
|
|
// waiting (confirm-cancel) the modal it asked for goes away too.
|
|
window.__TAURI__.event.listen('confirm-cancel', (event) => {
|
|
if (typeof event.payload === 'string' && event.payload && event.payload === confirmShownId) closeConfirm(false);
|
|
});
|
|
window.__TAURI__.event
|
|
.listen('confirm-request', async (event) => {
|
|
const req = event.payload || {};
|
|
if (typeof req.id !== 'string' || typeof req.title !== 'string') return;
|
|
const lines = Array.isArray(req.lines) ? req.lines.filter((l) => l && typeof l.text === 'string').map((l) => ({ kind: ['code', 'callout'].includes(l.kind) ? l.kind : 'text', text: l.text })) : [];
|
|
const yes = await confirmModal({
|
|
id: req.id,
|
|
title: req.title,
|
|
lines,
|
|
primary: typeof req.primary === 'string' ? req.primary : 'OK',
|
|
cancel: typeof req.cancel === 'string' ? req.cancel : 'Cancel',
|
|
danger: req.danger === true,
|
|
safeFirst: req.safeFirst !== false,
|
|
});
|
|
invoke('confirm_answer', { id: req.id, yes }).catch(() => {});
|
|
})
|
|
// Rust asks through the OS box until the page says it is listening.
|
|
.then(() => invoke('confirm_ready').catch(() => {}), () => {});
|
|
|
|
// --- Shortcuts and the bar's "..." menu (A11) -----------------------------------------------
|
|
function runShortcut(id) {
|
|
if (!confirmModalEl.hidden) return;
|
|
closeBarMenus();
|
|
if (id === 'toggle-terminal') {
|
|
termCollapseBtn.click();
|
|
if (paneCollapsed) frame.focus();
|
|
} else if (id === 'focus-console') {
|
|
frame.focus();
|
|
} else if (id === 'focus-terminal') {
|
|
showTerminal();
|
|
} else if (id === 'new-session') {
|
|
if (!restartBtn.hidden) restartBtn.click();
|
|
} else if (id === 'change-project') {
|
|
// Not over the bare start's own folder picker: Cancel there would leave no project at all.
|
|
if (!changeProjectBtn.disabled && folderPickerEl.hidden) changeProjectBtn.click();
|
|
} else if (id === 'preferences') {
|
|
// The console's own dialog: it opens when a page is showing.
|
|
if (frameReady && frame.contentWindow) frame.contentWindow.postMessage({ plan2code: 'open-preferences' }, '*');
|
|
}
|
|
}
|
|
|
|
// Keys pressed anywhere in the shell itself (the bar, the panes' edges). The terminal's own go through
|
|
// its key handler (and have the default prevented by then), the console frame's through a message.
|
|
document.addEventListener('keydown', (event) => {
|
|
if (event.defaultPrevented) return;
|
|
const inTerminal = Boolean(event.target && event.target.closest && event.target.closest('#term'));
|
|
const id = shortcutAction(event, { mac: IS_MAC, inTerminal });
|
|
if (!id) return;
|
|
event.preventDefault();
|
|
runShortcut(id);
|
|
});
|
|
|
|
document.getElementById('app-about').onclick = () => {
|
|
closeBarMenus();
|
|
void showAbout();
|
|
};
|
|
document.getElementById('app-check-updates').onclick = () => {
|
|
closeBarMenus();
|
|
void checkUpdatesNow();
|
|
};
|
|
// Help is the console's own dialog, so it needs a page on screen.
|
|
function openHelp() {
|
|
if (frameReady && frame.contentWindow) frame.contentWindow.postMessage({ plan2code: 'open-help' }, '*');
|
|
else void confirmModal({ title: 'Help', lines: [{ kind: 'text', text: 'Help opens with the dashboard. Start an agent first, then press ? in the dashboard.' }], cancel: 'Close', primary: null });
|
|
}
|
|
document.getElementById('app-help').onclick = () => {
|
|
closeBarMenus();
|
|
openHelp();
|
|
};
|
|
// The macOS menu bar's own items (main.rs build_mac_menu) do the same as the "..." menu.
|
|
window.__TAURI__.event.listen('app-menu', (event) => {
|
|
if (event.payload === 'about') void showAbout();
|
|
else if (event.payload === 'check-updates') void checkUpdatesNow();
|
|
else if (event.payload === 'help') openHelp();
|
|
});
|
|
document.getElementById('app-quit').onclick = () => {
|
|
closeBarMenus();
|
|
invoke('request_quit').catch((error) => setAgentError(error, 'quit'));
|
|
};
|
|
|
|
async function main() {
|
|
let state;
|
|
try {
|
|
state = await invoke('app_state');
|
|
} catch (error) {
|
|
showErrorState(error, 'read the app state', 'Retry', main);
|
|
return;
|
|
}
|
|
appState = state;
|
|
if (typeof state.launchModel === 'string' && state.launchModel) launchModelEl.value = state.launchModel;
|
|
if (state.termPanel) {
|
|
paneDock = state.termPanel.dock === 'right' ? 'right' : 'bottom';
|
|
paneFraction = state.termPanel.fraction;
|
|
paneCollapsed = Boolean(state.termPanel.collapsed);
|
|
} else {
|
|
// Nothing saved yet: start docked right, wide enough to keep the
|
|
// console's own side-by-side panels from stacking, where the window
|
|
// allows it.
|
|
paneDock = 'right';
|
|
paneFraction = defaultRightFraction(window.innerWidth, { minFraction: MIN_PANE, maxFraction: MAX_PANE });
|
|
savePaneSettings();
|
|
}
|
|
applyPaneLayout();
|
|
terminal.setFontSize(Number.isInteger(state.terminalFontSize) ? state.terminalFontSize : TERMINAL_FONT_DEFAULT);
|
|
terminal.setCopyOnSelect(Boolean(state.copyOnSelect));
|
|
termTitleEl.title = `Focus the terminal (${shortcutLabel('focus-terminal', IS_MAC)}); focus the dashboard (${shortcutLabel('focus-console', IS_MAC)})`;
|
|
if (state.updatedFrom) void showUpdatedTo();
|
|
await loadAgentAvailability();
|
|
applyDefaultAgent(state.lastAgent);
|
|
setInterval(updateBadge, BADGE_POLL_MS);
|
|
checkVersions();
|
|
checkNewRelease();
|
|
setInterval(checkNewRelease, UPDATE_RECHECK_MS);
|
|
|
|
let reattach = null;
|
|
try {
|
|
reattach = await invoke('agent_reattach', { onOutput: agentChannel });
|
|
} catch {
|
|
// Nothing to reattach to is not fatal: carry on as a plain first paint.
|
|
}
|
|
// A reloaded window learns of a running loop before it draws the agent.
|
|
await syncLoopState();
|
|
if (reattach && reattach.state !== 'idle') {
|
|
if (state.projectDir) setProjectDir(state.projectDir);
|
|
await recoverAfterReload(reattach);
|
|
return;
|
|
}
|
|
|
|
if (state.autoStart) {
|
|
if (state.projectDir) setProjectDir(state.projectDir);
|
|
await autoStartAgent(state);
|
|
return;
|
|
}
|
|
if (state.projectDir) {
|
|
setProjectDir(state.projectDir);
|
|
// The checklist's Node.js row needs the check's result, which the app now
|
|
// runs after the window opens.
|
|
if (!state.firstRunDone) await awaitNodeStatus(state);
|
|
afterProjectKnown();
|
|
} else {
|
|
chooseStartFolder();
|
|
}
|
|
}
|
|
|
|
// The Node.js check runs in the background so the window opens at once:
|
|
// `nodeChecked` is false until it finishes, and a `node-status` event carries
|
|
// the same fields. Waits for it (at most NODE_WAIT_MS) and folds it into `state`.
|
|
const NODE_WAIT_MS = 15000;
|
|
|
|
async function awaitNodeStatus(state) {
|
|
if (state.nodeChecked) return;
|
|
await new Promise((resolve) => {
|
|
let done = false;
|
|
const finish = (report) => {
|
|
if (done) return;
|
|
done = true;
|
|
if (report && typeof report === 'object') {
|
|
state.nodeChecked = true;
|
|
state.nodeVersion = report.version || null;
|
|
state.nodeBinary = report.binary || null;
|
|
state.nodeProblem = report.problem || null;
|
|
}
|
|
resolve();
|
|
};
|
|
window.__TAURI__.event.listen('node-status', (event) => finish(event.payload)).catch(() => finish(null));
|
|
setTimeout(() => finish(null), NODE_WAIT_MS);
|
|
// The check may have finished between the first read and the listener.
|
|
invoke('app_state')
|
|
.then((again) => {
|
|
if (again.nodeChecked) finish({ version: again.nodeVersion, binary: again.nodeBinary, problem: again.nodeProblem });
|
|
})
|
|
.catch(() => {});
|
|
});
|
|
}
|
|
|
|
main();
|