Files

1661 lines
64 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 { NEW_RELEASE_COMMAND, attentionSignal, barNextSteps, continueKeys, defaultRightFraction, folderName, lastAgentNotice, pickDefaultAgent, taskbarSwitch, windowTitleFor, deadConsoleAction, folderPickerRows, loopBanner, loopLocks, loopStopLabels, loopWindowTitle, helloRetryAction, retryLabel, RETRY_AFTER_SECONDS } from './meter.js';
const { invoke, Channel } = window.__TAURI__.core;
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 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 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 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 });
},
});
// 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' : '';
agentDotEl.className = `agent-dot${active ? (bypassActive ? ' is-warn' : ' is-ok') : ''}`;
agentEndedEl.hidden = !ended;
// 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 = ended ? 'Start a fresh agent on the same brief' : 'Replace the agent with a fresh one, on a fresh context window';
// 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(agent.reason);
// A failed Restart clears the screen too, so it says so again.
if (!wasEnded || freshScreen) {
terminal.write(`\r\n[${label || 'The agent'} ended: ${agent.reason}. 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).
function setAgentStatus(text, { error = false } = {}) {
agentStatusEl.textContent = text;
agentStatusEl.title = text;
agentStatusEl.classList.toggle('is-error', error && Boolean(text));
}
// 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, ` ended: ${agent.reason}`, document.createElement('br'), 'Nothing starts until you press New Session.');
} else {
agentMenuHeadEl.replaceChildren();
}
}
// The bar's two menus (project, agent). They hang outside the scrolling 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,
// a resize or a scroll of the row all close them.
let openBarMenu = null;
function closeBarMenus() {
for (const [button, menu] of [[projectMenuBtn, projectMenu], [agentMenuBtn, agentMenu]]) {
menu.hidden = true;
button.setAttribute('aria-expanded', 'false');
}
openBarMenu = null;
}
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;
}
projectMenuBtn.onclick = () => toggleBarMenu(projectMenuBtn, projectMenu);
agentMenuBtn.onclick = () => toggleBarMenu(agentMenuBtn, agentMenu);
document.addEventListener('pointerdown', (event) => {
if (!openBarMenu) return;
if (openBarMenu.contains(event.target) || projectMenuBtn.contains(event.target) || agentMenuBtn.contains(event.target)) return;
closeBarMenus();
});
document.addEventListener('keydown', (event) => {
if (event.key !== 'Escape' || !openBarMenu) return;
const trigger = openBarMenu === projectMenu ? projectMenuBtn : agentMenuBtn;
closeBarMenus();
trigger.focus();
});
window.addEventListener('blur', closeBarMenus);
window.addEventListener('resize', closeBarMenus);
barRowEl.addEventListener('scroll', closeBarMenus);
// 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;
function confirmRestart(onYes) {
if (agent.state !== 'running') {
onYes();
return;
}
showState(
'Restart the agent on a fresh context window?',
'New Session',
() => {
restarting = true;
currentUrl = null;
frameReady = false;
showState('The agent is restarting on a fresh context window. Please wait for the dashboard to load.');
onYes();
},
() => (frameReady ? hideState() : showState('No dashboard has loaded yet.')),
{ tired: true }
);
}
// 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) => {
setAgentStatus(`Could not open the install page: ${error}`, { error: true });
});
};
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) {
const text = String(error);
// A missing console.mjs means the skills install itself is gone (FR-16).
setAgentStatus(
text.includes('not installed') || text.includes('console.mjs')
? "Plan2Code's skills are missing: run `plan2code update`."
: `Could not open the setup page: ${text}`,
{ error: true }
);
}
}
// 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 ? '✓' : '!';
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.textContent = 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('');
showState('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) {
setAgentStatus(`Could not start the agent: ${error}`, { error: true });
showLaunchCard();
}
}
async function agentAction(command) {
try {
await invoke(command);
terminal.focus();
} catch (error) {
setAgentStatus(String(error), { error: true });
}
}
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 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`;
}
termDockBtn.textContent = paneDock === 'right' ? 'Dock bottom' : 'Dock right';
termMaximizeBtn.textContent = paneMaximized ? 'Restore' : 'Maximize';
termMaximizeBtn.setAttribute('aria-pressed', String(paneMaximized));
termCollapseBtn.textContent = paneCollapsed ? 'View Agent Terminal' : 'Collapse';
termCollapseBtn.setAttribute('aria-pressed', String(paneCollapsed));
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.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();
});
termHandle.addEventListener('pointerup', (event) => {
if (termHandle.hasPointerCapture(event.pointerId)) termHandle.releasePointerCapture(event.pointerId);
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();
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;
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 === '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') {
applyAccent(event.data.accent, { 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) => {
setAgentStatus(`Could not type continue: ${error}`, { error: true });
});
}
// The person's highlight color, as the console page last sent it (its dark
// shades: fill, soft, ink, line), so the bar's buttons light in it too. Kept
// here for the next launch, which paints the bar before any page has loaded.
const ACCENT_KEY = 'p2c-app:accent';
const ACCENT_VARS = ['--accent', '--accent-soft', '--accent-ink', '--accent-line'];
function applyAccent(shades, { save = false } = {}) {
if (!Array.isArray(shades) || shades.length !== ACCENT_VARS.length) return;
if (!shades.every((c) => typeof c === 'string' && /^#[0-9a-f]{6}$/i.test(c))) return;
ACCENT_VARS.forEach((name, i) => document.documentElement.style.setProperty(name, shades[i]));
if (!save) return;
try {
localStorage.setItem(ACCENT_KEY, JSON.stringify(shades));
} catch {
// Not remembered is fine: the stylesheet's default shows until a page loads.
}
}
try {
applyAccent(JSON.parse(localStorage.getItem(ACCENT_KEY)));
} catch {
// Nothing saved, or storage is blocked: the stylesheet's default stands.
}
// 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 {
showState('The console is running but its page did not show in this window.', 'Reload the page', () => {
showState('Reloading the page');
loadFrame(currentUrl);
});
}
}
// 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;
function showState(text, buttonLabel, onButton, onCancel, { tired = false, retryAfter = 0, autoRetry = false } = {}) {
// 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;
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);
stateText.textContent = text;
stateButton.hidden = !buttonLabel;
stateButton.textContent = buttonLabel || '';
stateButton.onclick = onButton || null;
stateCancelEl.hidden = !onCancel;
stateCancelEl.onclick = onCancel || null;
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);
}
}
function hideState() {
stopRetryCountdown();
stateBox.hidden = true;
}
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) {
showState(`The console could not be reached: ${error}`, '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.
}
}
// Once, at start, and 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 with the newer version, or
// nothing when the app is current or the lookup failed.
async function checkNewRelease() {
try {
const latest = await invoke('check_new_release');
if (latest) setNewRelease({ latest, copied: false });
} catch {
// No answer is no reason to nag.
}
}
async function copyUpdateCommand() {
if (!newRelease) return;
try {
await navigator.clipboard.writeText(NEW_RELEASE_COMMAND);
setNewRelease({ ...newRelease, copied: true });
} catch {
// The webview refused the clipboard: the bar spells the command out instead.
setNewRelease({ ...newRelease, manual: true });
}
}
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) {
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) {
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 : '';
}
}
// 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;
function hideLoopError() {
loopErrorEl.hidden = true;
loopErrorEl.textContent = '';
loopRetryBtn.hidden = true;
loopRetryAction = null;
}
function pressLoop(command, args) {
const press = () =>
invoke(command, args).then(hideLoopError, (e) => {
loopErrorEl.textContent = `Could not do that: ${String(e && e.message ? e.message : e)}`;
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 = () =>
showState(
"End the agent now? This phase's changes stay uncommitted.",
'Stop now',
() => {
frameReady ? hideState() : showState('No dashboard has loaded yet.');
pressLoop('loop_stop_now');
},
() => (frameReady ? hideState() : showState('No dashboard has loaded yet.')),
{ tired: true }
);
// 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, 'copy-update': copyUpdateCommand };
let nextStepAction = null;
function renderNextStep() {
const steps = barNextSteps({ consoleDead, version: versionState, newRelease });
nextStepEl.hidden = steps.length === 0;
const [first, ...rest] = steps;
nextStepTextEl.textContent = first ? first.text : '';
nextStepTextEl.title = first ? 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 : '';
nextStepMoreEl.hidden = rest.length === 0;
nextStepMoreEl.textContent = `+${rest.length} more`;
nextStepMoreEl.title = rest.map((step) => step.title).join('\n');
}
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);
}
function setFolderPickerError(text) {
folderPickerErrorEl.textContent = text || '';
folderPickerErrorEl.hidden = !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(`Could not read the recent folders: ${error}`);
}
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(row.kind === 'browse' ? `Could not open the folder picker: ${error}` : `Could not open ${row.dir}: ${error}`);
}
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.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) {
showState(`Could not switch project: ${error}`, 'Try again', doChangeProject);
}
}
function changeProject() {
if (agentActive()) {
showState(
'Stop the running agent and switch to a different project? What it was doing is not saved.',
'Change project',
doChangeProject,
() => (frameReady ? hideState() : showLaunchCard())
);
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('');
showState('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) {
setAgentStatus(`Could not start the agent: ${error}`, { error: true });
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();
}
}
async function main() {
let state;
try {
state = await invoke('app_state');
} catch (error) {
showState(`Could not read the app state: ${error}`, '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();
await loadAgentAvailability();
applyDefaultAgent(state.lastAgent);
setInterval(updateBadge, BADGE_POLL_MS);
checkVersions();
checkNewRelease();
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);
afterProjectKnown();
} else {
chooseStartFolder();
}
}
main();