web: settings destination with connection, workspace and templates (L1)

Completes the item: the Settings view, its pure helpers and the client's
socket-replacement path, plus the fix the review required (a header-side URL
correction clears the Settings field's own error) and a smoke check for it.
This commit is contained in:
2026-10-19 11:30:19 +01:00
parent 27a1605127
commit 597151cdd1
9 changed files with 1601 additions and 49 deletions
+1 -1
View File
File diff suppressed because one or more lines are too long
+431 -26
View File
@@ -14,6 +14,26 @@ import {
serverBuildLabel,
stateBadge,
} from "./connection.js";
import {
SERVER_URL_HELPER,
SERVER_URL_PLACEHOLDER,
TEMPLATES_CARD_LABEL,
TEMPLATES_CARD_SECONDARY,
TRUST_BODY,
TRUST_TITLE,
WORKSPACE_HELPER,
WORKSPACE_PLACEHOLDER,
canSaveWorkspace,
connectionActionKind,
connectionActions,
connectionCard,
readServerUrl,
readWorkspace,
savedWorkspaceLine,
workspaceErrorText,
writeServerUrl,
writeWorkspace,
} from "./settings.js";
import {
ArtifactKind,
artifactCaptureNotes,
@@ -294,8 +314,6 @@ import {
} from "./chat.js";
import { codeBlockLabel, parseInline, parseMarkdown } from "./markdown.js";
const STORAGE_KEY = "pipelines.web.serverUrl.v2";
/**
* The per-session chat scroll positions (C14). Persisted in localStorage, the
* browser analogue of the Android `ChatThread.scroll`: a position the operator
@@ -333,14 +351,29 @@ function defaultServerUrl() {
const client = new PipelinesClient();
const repo = new PipelinesRepository(client);
// Read the persisted settings once: the server URL falls back to the page's own
// proxy endpoint when unset, and the workspace starts blank when unset. Both the
// configured value and the draft start from storage.
const initialWorkspace = readWorkspace(localStorage);
const state = {
view: "pipelines",
url: localStorage.getItem(STORAGE_KEY) ?? defaultServerUrl(),
url: readServerUrl(localStorage) || defaultServerUrl(),
// The server URL's own validation message (Android's `urlError`), shown as the
// Settings field's supporting text and cleared as soon as the field is edited.
urlError: "",
// The workspace the operator configured (L1), the analogue of SettingsRepository's
// `workspace` preference. `workspaceDraft` is the field's live value; Save copies
// it into `workspace` and localStorage. Both start from the persisted value.
workspace: initialWorkspace,
workspaceDraft: initialWorkspace,
connection: client.state,
// The last `pong` reply is remembered so the banner can name a stale server
// build and warn about a protocol mismatch (T5) without re-pinging.
serverBuild: null,
serverProtocol: null,
// The `pong` reply's server time (L1), shown in the Settings connection card.
serverTime: null,
pipelines: [],
runs: [],
usage: null,
@@ -549,6 +582,47 @@ function endpointConfigured() {
return validateServerUrl(state.url).valid;
}
/**
* The one server-URL draft (Android's `serverUrlDraft`). Both the header field and
* the Settings `Server URL` field edit this same value and are mirrored in place
* without a re-render, so the two can never show different endpoints while typing
* (and neither loses focus). Editing also clears the field's own error, exactly as
* AppViewModel.updateServerUrlDraft does.
*/
function setServerUrlDraft(value, sourceId) {
state.url = value;
clearServerUrlError();
for (const id of ["url", "settingsServerUrl"]) {
if (id === sourceId) continue;
const other = document.getElementById(id);
if (other && other.value !== value) other.value = value;
}
// The Settings field mirrors this value even when the edit came from the header,
// so its own supporting text, error tint and aria-invalid must be refreshed from
// the same draft state too: a corrected URL can never leave the field announced
// as invalid (or keep the stale "That is not a valid URL." message) just because
// the correction happened in the header field.
if (document.getElementById("settingsServerUrl")) refreshServerUrlError();
}
/**
* Clear the server-URL validation error, wherever it was surfaced: the Settings
* field's own error always, and — when the invalid Connect came from another view
* — the matching page-level banner too, so an edit never leaves a stale message
* claiming the URL is still bad.
*/
function clearServerUrlError() {
if (!state.urlError) return;
const message = state.urlError;
state.urlError = "";
if (state.error === message) {
state.error = "";
for (const banner of document.querySelectorAll("#content .banner.error")) {
if ((banner.textContent ?? "").includes(message)) banner.remove();
}
}
}
function renderHeader() {
const info = bannerState(state.connection, { hasEndpoint: endpointConfigured() });
const controls = [
@@ -560,7 +634,7 @@ function renderHeader() {
value: state.url,
spellcheck: "false",
oninput: (e) => {
state.url = e.target.value;
setServerUrlDraft(e.target.value, "url");
},
}),
];
@@ -932,22 +1006,29 @@ function renderContent() {
tabButton("runs", `Runs (${state.runs.length})`),
tabButton("templates", "Templates"),
tabButton("chat", CHAT_TAB_TITLE),
tabButton("settings", "Settings"),
h("span", { class: "spacer" }),
h("button", { class: "ghost", text: "Refresh", onclick: () => loadCurrentView(true) }),
),
);
const split = h("div", { class: "split" });
if (state.view === "pipelines") {
split.append(renderPipelineList(), renderPipelineDetail());
} else if (state.view === "runs") {
split.append(renderRunList(), renderRunDetail());
} else if (state.view === "chat") {
split.append(renderChatList(), renderChatConversation());
// Settings is a single-pane destination (not the list/detail split): the
// app's own settings page is one scrolled column.
if (state.view === "settings") {
nodes.push(renderSettingsView());
} else {
split.append(renderTemplateGallery(), renderTemplateDetail());
const split = h("div", { class: "split" });
if (state.view === "pipelines") {
split.append(renderPipelineList(), renderPipelineDetail());
} else if (state.view === "runs") {
split.append(renderRunList(), renderRunDetail());
} else if (state.view === "chat") {
split.append(renderChatList(), renderChatConversation());
} else {
split.append(renderTemplateGallery(), renderTemplateDetail());
}
nodes.push(split);
}
nodes.push(split);
// Capture the live transcript's position before it is replaced, so the very
// next render can put the operator back exactly where they were (a dialog, a
// refresh or a paging frame must not move them).
@@ -986,6 +1067,314 @@ function tabButton(view, label) {
});
}
// --- Settings (L1) ---------------------------------------------------------
/**
* The Settings destination: the app's three sections (Connection, Workspace,
* Templates) in one pane. It is wiring only — every string, the workspace
* validation and the connection card's lines come from the pure `settings.js`,
* and the connection controls drive the page's existing single client through
* the same handlers the header uses (no second socket or path). Every
* server-derived string is set with textContent.
*/
function renderSettingsView() {
const pane = h("div", { class: "settings" });
pane.append(renderSettingsConnection(), renderSettingsWorkspace(), renderSettingsTemplates());
return pane;
}
function renderSettingsConnection() {
const section = h("section", { class: "settings-section" });
section.append(h("h2", { class: "settings-title", text: "Connection" }));
section.append(
h(
"label",
{ class: "settings-field", for: "settingsServerUrl" },
h("span", { class: "settings-field-label", text: "Server URL" }),
h("input", {
id: "settingsServerUrl",
type: "text",
placeholder: SERVER_URL_PLACEHOLDER,
value: state.url,
spellcheck: "false",
autocomplete: "off",
"aria-describedby": "settingsUrlHelper",
"aria-invalid": state.urlError ? "true" : null,
oninput: (event) => {
setServerUrlDraft(event.target.value, "settingsServerUrl");
},
}),
),
);
// Android's `urlError ?: helper` supporting text. The error clears on the next
// edit (AppViewModel.updateServerUrlDraft) and is announced as the field's own
// invalid state rather than as a page-level banner.
section.append(
h(
"p",
{
id: "settingsUrlHelper",
class: `settings-helper${state.urlError ? " settings-helper-error" : ""}`,
role: state.urlError ? "alert" : null,
},
serverUrlSupportingText(),
),
);
const actions = connectionActions(state.connection);
section.append(
h(
"div",
{ class: "settings-actions" },
h("button", {
id: "settingsPrimary",
class: "primary",
type: "button",
text: actions.primary,
onclick: () => runConnectionAction(actions.primary),
}),
h("button", {
id: "settingsSecondary",
class: "ghost",
type: "button",
text: actions.secondary,
onclick: () => runConnectionAction(actions.secondary),
}),
),
);
const tone = bannerState(state.connection, { hasEndpoint: endpointConfigured() }).tone;
const card = h("div", { class: `settings-status status-${tone}` });
const lines = connectionCard(state.connection, {
version: state.serverBuild?.version,
commit: state.serverBuild?.commit,
serverTime: state.serverTime,
});
lines.forEach((line, index) => {
// Android's Connecting card leads its one line with a CircularProgressIndicator;
// the shared spinner is drawn only for that state, inline with the text, so the
// other three stay plain text.
if (index === 0 && state.connection.kind === "connecting") {
const row = h("div", { class: "settings-status-head" });
row.append(h("span", { class: "spinner settings-status-spinner", "aria-hidden": "true" }));
row.append(h("p", { class: "settings-status-line", text: line }));
card.append(row);
return;
}
card.append(h("p", { class: "settings-status-line", text: line }));
});
section.append(card, renderTrustWarning());
return section;
}
/** The trusted-network warning card, SettingsScreen.kt's TrustWarning verbatim. */
function renderTrustWarning() {
return h(
"div",
{ class: "settings-warning" },
h("p", { class: "settings-warning-title", text: TRUST_TITLE }),
h("p", { class: "settings-warning-body", text: TRUST_BODY }),
);
}
/**
* Route a Settings connection control through the page's existing single client,
* mirroring AppViewModel: Disconnect closes the shared socket, Connect is
* connect-only (validate + persist + open — never the header's toggle), and
* Reconnect re-opens the same validated endpoint now. Nothing here opens a second
* connection.
*/
function runConnectionAction(label) {
const kind = connectionActionKind(label);
if (kind === "disconnect") {
repo.disconnect();
stopRunPoll();
return;
}
if (kind === "reconnect") {
onReconnectClicked();
return;
}
// The `Connect` label must never fall through to the header's toggle: while
// connected that would tear the live socket down (Android's connect() is
// connect-only).
openConfiguredEndpoint();
}
/** Android's `urlError ?: helper` supporting text for the Server URL field. */
function serverUrlSupportingText() {
return state.urlError || SERVER_URL_HELPER;
}
/**
* Update the Server URL field's own error state in place (supporting text,
* aria-invalid and the error tint) so an invalid Connect never needs a full
* re-render and the field being typed in is never rebuilt.
*/
function refreshServerUrlError() {
const field = document.getElementById("settingsServerUrl");
const helper = document.getElementById("settingsUrlHelper");
if (field) {
if (state.urlError) field.setAttribute("aria-invalid", "true");
else field.removeAttribute("aria-invalid");
}
if (helper) {
helper.textContent = serverUrlSupportingText();
helper.classList.toggle("settings-helper-error", Boolean(state.urlError));
if (state.urlError) helper.setAttribute("role", "alert");
else helper.removeAttribute("role");
}
}
function renderSettingsWorkspace() {
const section = h("section", { class: "settings-section" });
section.append(h("h2", { class: "settings-title", text: "Workspace" }));
section.append(
h(
"label",
{ class: "settings-field", for: "settingsWorkspace" },
h("span", { class: "settings-field-label", text: "Workspace path (on the server)" }),
h("input", {
id: "settingsWorkspace",
type: "text",
placeholder: WORKSPACE_PLACEHOLDER,
value: state.workspaceDraft,
spellcheck: "false",
autocomplete: "off",
"aria-describedby": "workspaceHelper",
"aria-invalid": workspaceErrorText(state.workspaceDraft) ? "true" : null,
oninput: (event) => {
state.workspaceDraft = event.target.value;
refreshWorkspaceControls();
},
}),
),
);
section.append(
h(
"p",
{
id: "workspaceHelper",
class: `settings-helper${workspaceErrorText(state.workspaceDraft) ? " settings-helper-error" : ""}`,
},
workspaceSupportingText(),
),
);
section.append(
h("button", {
id: "saveWorkspace",
class: "primary settings-save",
type: "button",
text: "Save workspace",
disabled: !canSaveWorkspace(state.workspaceDraft),
onclick: saveWorkspace,
}),
);
section.append(h("p", { id: "savedWorkspace", class: "settings-saved", text: savedWorkspaceLine(state.workspace) }));
return section;
}
/** Android's `workspaceError ?: helper` supporting text for the workspace field. */
function workspaceSupportingText() {
return workspaceErrorText(state.workspaceDraft) || WORKSPACE_HELPER;
}
/**
* Update the workspace field's dependent controls in place (the helper/error line
* and the Save button's enabled state) so typing never re-renders — and so never
* blurs — the field being typed in.
*/
function refreshWorkspaceControls() {
const helper = document.getElementById("workspaceHelper");
const invalid = Boolean(workspaceErrorText(state.workspaceDraft));
if (helper) {
helper.textContent = workspaceSupportingText();
helper.classList.toggle("settings-helper-error", invalid);
}
const field = document.getElementById("settingsWorkspace");
if (field) {
if (invalid) field.setAttribute("aria-invalid", "true");
else field.removeAttribute("aria-invalid");
}
const save = document.getElementById("saveWorkspace");
if (save) save.disabled = !canSaveWorkspace(state.workspaceDraft);
}
/** Persist the workspace (trimmed) and update the `Saved workspace:` line. */
function saveWorkspace() {
if (!canSaveWorkspace(state.workspaceDraft)) return;
state.workspace = writeWorkspace(localStorage, state.workspaceDraft);
state.workspaceDraft = state.workspace;
// Show the trimmed value that was actually stored, in the field as well as the
// saved line (both updated in place so the keyboard focus is not disturbed).
const field = document.getElementById("settingsWorkspace");
if (field) field.value = state.workspace;
const saved = document.getElementById("savedWorkspace");
if (saved) saved.textContent = savedWorkspaceLine(state.workspace);
}
/**
* Reset the template detail/create state that belongs to a selection. Shared by
* selecting a template and opening the gallery from Settings, so the two lists of
* fields can never drift.
*/
function resetTemplateCreateState() {
state.templateTab = "summary";
// A different template reseeds the create dialog, so a name typed for one
// template can never be submitted against another.
state.templateCreateOpen = false;
state.templateCreateName = "";
state.templateCreateSending = false;
state.templateCreateError = "";
state.templateCreateCreated = null;
}
/** Clear the selection and everything that belongs to it. */
function resetTemplateSelection() {
state.selectedTemplateKey = null;
resetTemplateCreateState();
}
/**
* Open the existing Templates gallery (L1's one card): switch the view, clear any
* selection/detail left from a previous visit and render. The gallery itself is
* unchanged — this is the same destination the Templates tab opens.
*/
function openTemplatesFromSettings() {
state.view = "templates";
state.error = "";
resetTemplateSelection();
renderContent();
if (!state.templates.length) loadCurrentView();
}
function renderSettingsTemplates() {
const section = h("section", { class: "settings-section" });
section.append(h("h2", { class: "settings-title", text: "Templates" }));
const card = h(
"button",
{
id: "browseTemplates",
class: "card settings-card",
type: "button",
onclick: openTemplatesFromSettings,
},
// SettingsScreen.kt's row idiom: a leading glyph, the label and secondary
// line, then a forward chevron.
h("span", { class: "settings-card-glyph", "aria-hidden": "true", text: "\u25a4" }),
h(
"span",
{ class: "settings-card-text" },
h("span", { class: "card-name", text: TEMPLATES_CARD_LABEL }),
h("span", { class: "card-desc", text: TEMPLATES_CARD_SECONDARY }),
),
h("span", { class: "settings-card-chevron", "aria-hidden": "true", text: "\u203a" }),
);
section.append(card);
return section;
}
function renderPipelineList() {
const list = h("div", { class: "list" });
list.append(renderPipelineControls());
@@ -5720,21 +6109,32 @@ function setError(err) {
* same validate → persist → repo.connect path. `repo.connect` resets the
* attempt/backoff inside client.js, cancelling a pending retry delay.
*
* `surfaceError` is false for the background (foreground-recovery) caller so a
* stale, invalid URL field cannot spray an error into the UI on every
* An invalid draft is reported as the Settings field's own error (Android's
* `urlError`) and cleared on the next edit; it is never left as a page-level
* banner. `surfaceError` is false for the background (foreground-recovery)
* caller so a stale, invalid URL field cannot spray an error into the UI on every
* visibilitychange/online event.
*/
function openConfiguredEndpoint({ surfaceError = true } = {}) {
const validated = validateServerUrl(state.url);
if (!validated.valid) {
if (surfaceError) {
state.error = validated.message;
renderContent();
state.urlError = validated.message;
// On another view the field is not rendered, so the page-level error is the
// only way to say why nothing happened; on Settings it belongs under the
// field.
if (state.view === "settings") {
refreshServerUrlError();
} else {
state.error = validated.message;
renderContent();
}
}
return;
}
state.error = "";
localStorage.setItem(STORAGE_KEY, state.url.trim());
state.urlError = "";
writeServerUrl(localStorage, state.url);
repo.connect(validated);
}
@@ -5785,11 +6185,23 @@ async function onConnected() {
// and warn about a protocol mismatch (T5); the ping is the only source.
state.serverProtocol = reply?.protocol ?? null;
state.serverBuild = reply?.build ?? null;
// The pong carries the server's own time (internal/protocol/message.go `Time`),
// shown in the Settings connection card.
state.serverTime = reply?.time ?? null;
// Update the banner at once; the content render that shows the build/time in
// the Settings card is the one `loadCurrentView` already performs (Settings is
// local, so that path is a single render and nothing is fetched twice).
renderBanner();
await loadCurrentView();
}
async function loadCurrentView(force = false) {
// Settings is local: it has no server-backed list to (re)load, so switching to
// or refreshing it must never raise the "connect first" error.
if (state.view === "settings") {
renderContent();
return;
}
if (state.connection.kind !== "connected") {
state.error = "Connect to the server first.";
renderContent();
@@ -5872,14 +6284,7 @@ async function validateTemplate(entry) {
function selectTemplate(key) {
state.selectedTemplateKey = key;
state.templateTab = "summary";
// A different template reseeds the create dialog, so a name typed for one
// template can never be submitted against another.
state.templateCreateOpen = false;
state.templateCreateName = "";
state.templateCreateSending = false;
state.templateCreateError = "";
state.templateCreateCreated = null;
resetTemplateCreateState();
renderContent();
}
+21 -1
View File
@@ -159,13 +159,33 @@ export class PipelinesClient extends EventTarget {
retrying: false,
});
const socket = new this.#WebSocketImpl(current);
const superseded = this.#ws;
this.#ws = socket;
// Replace the current socket, then close the one it superseded (mirrors
// PipelinesClient.openLocked). Its callbacks are ignored from then on, so a
// failure the old socket reports late can neither clear the new socket nor
// schedule a reconnect that would undo it. A request already sent on the old
// socket cannot receive a reply from the replacement, so fail it now rather
// than leaving a view waiting for the ordinary request timeout.
if (superseded) {
this.#failPending("Connection replaced");
try {
superseded.close(NORMAL_CLOSURE, "superseded");
} catch {
/* already closed */
}
}
socket.onopen = () => {
if (this.#ws !== socket) return;
this.#attempt = 0;
this.#setState({ kind: CONNECTED, attempt: 0, reason: "", retrying: false });
};
socket.onmessage = (event) => this.#onMessage(event.data);
socket.onmessage = (event) => {
if (this.#ws !== socket) return;
this.#onMessage(event.data);
};
socket.onclose = (event) => {
if (this.#ws !== socket) return;
this.#handleClosed(`Connection closed (${event.code ?? "?"})`);
};
socket.onerror = () => {
+10 -1
View File
@@ -14,6 +14,15 @@
/** The reconnect affordance, exactly as ConnectionBanner.kt names it. */
export const RECONNECT_LABEL = "Reconnect";
/**
* The one definition of the connecting line: `Connecting (attempt N)…`, shared by
* the persistent banner and the Settings status card so the same app sentence can
* never drift between the two.
*/
export function connectingLabel(attempt) {
return `Connecting (attempt ${attempt ?? 0})\u2026`;
}
/** Idle banner copy, verbatim from ConnectionBanner.kt. */
export const IDLE_BANNER_TEXT =
"Not connected. Enter the server URL in Settings, then connect.";
@@ -54,7 +63,7 @@ export function bannerState(connection, { hasEndpoint = false } = {}) {
case "connecting":
return {
tone: "connecting",
text: `Connecting (attempt ${c.attempt ?? 0})\u2026`,
text: connectingLabel(c.attempt),
action: null,
};
case "disconnected": {
+215
View File
@@ -0,0 +1,215 @@
// The Settings destination's pure logic and copy (L1): the exact strings the
// Android SettingsScreen.kt shows, the workspace-path validation rules
// (AppViewModel.validateWorkspace), the connection status card's lines, and the
// two localStorage keys that stand in for SettingsRepository's preferences.
//
// Deliberately free of DOM, sockets and timers, so every branch is unit-testable
// in Node and renders identically in the page. Wording authority:
// ui/screens/SettingsScreen.kt — the fields, helper lines, warning, status card
// and the TrustWarning / Templates row
// ui/AppViewModel.kt — validateWorkspace / saveWorkspace
// data/SettingsRepository.kt — the two persisted preferences (server URL, workspace)
// ui/screens/SettingsScreen.kt — the ConnectionStatusCard's connected build line
//
// The Android store persists the server URL and the workspace under `server_url`
// and `workspace`; the browser's analogue is localStorage. Only these two keys
// are ever written — never a credential, because the server has no authentication.
import { connectingLabel, serverBuildLabel } from "./connection.js";
/**
* The persisted server-URL key. It is the browser analogue of
* SettingsRepository's `KEY_SERVER_URL` and the single source of truth the page
* already used (`app.js`); kept here so the module owns both settings keys.
*/
export const SERVER_URL_STORAGE_KEY = "pipelines.web.serverUrl.v2";
/** The persisted workspace key (SettingsRepository's `KEY_WORKSPACE` analogue). */
export const WORKSPACE_STORAGE_KEY = "pipelines.web.workspace.v1";
/** Server-URL field copy, verbatim from SettingsScreen.kt. */
export const SERVER_URL_PLACEHOLDER = "ws://192.168.1.20:8081/connect";
export const SERVER_URL_HELPER =
"ws:// on a trusted LAN/VPN, or wss:// through a proxy/VPN. No authentication is used.";
/** Workspace field copy, verbatim from SettingsScreen.kt. */
export const WORKSPACE_PLACEHOLDER = "/Users/you/repos/pipelines";
export const WORKSPACE_HELPER =
"An absolute directory that already exists on the execution server. For Docker, " +
"mount the host directory at the same absolute path with its owner's UID/GID. " +
"This is not the phone's storage.";
/** The one workspace validation failure, verbatim from AppViewModel.validateWorkspace. */
export const WORKSPACE_ERROR =
"The workspace must be an absolute path that exists on the execution server.";
/** The trusted-network warning, verbatim from SettingsScreen.kt's TrustWarning. */
export const TRUST_TITLE = "Trusted LAN/VPN only";
export const TRUST_BODY =
"The Pipelines API has no authentication and is not internet-safe. Do not " +
"expose it to untrusted networks, and never enter provider credentials here \u2014 " +
"the app stores none.";
/** The templates entry, verbatim from SettingsScreen.kt. */
export const TEMPLATES_CARD_LABEL = "Browse templates";
export const TEMPLATES_CARD_SECONDARY = "Reusable pipeline definitions offered by the server.";
/**
* AppViewModel.validateWorkspace: a blank draft is not an error (the field is
* simply untouched), a non-absolute path names the failure, an absolute path is
* accepted. Returns the error string or null.
*/
export function validateWorkspacePath(value) {
const trimmed = String(value ?? "").trim();
if (trimmed === "") return null;
if (!trimmed.startsWith("/")) return WORKSPACE_ERROR;
return null;
}
/**
* The supporting text under the workspace field: the validation error when the
* draft is invalid, otherwise the helper line (Android's `workspaceError ?: helper`).
*/
export function workspaceErrorText(value) {
return validateWorkspacePath(value) ?? "";
}
/**
* Whether `Save workspace` is enabled. The page deliberately refuses a blank
* field (there is nothing to save) as well as a relative path, so the only
* enabled state is a trimmed absolute path. This is stricter than Android's
* `workspaceError == null` (which also enables Save on a blank field) and is
* recorded in web/PARITY.md.
*/
export function canSaveWorkspace(value) {
const trimmed = String(value ?? "").trim();
return trimmed !== "" && validateWorkspacePath(trimmed) === null;
}
/** The `Saved workspace:` line (Android's `configuredWorkspace.ifBlank { "(none)" }`). */
export function savedWorkspaceLine(value) {
const trimmed = String(value ?? "").trim();
return `Saved workspace: ${trimmed || "(none)"}`;
}
/**
* Read the persisted workspace. Tolerant and blank-on-unreadable: a missing
* storage, a throwing `getItem` or a non-string value all read as "".
*/
export function readWorkspace(storage) {
try {
const raw = storage?.getItem?.(WORKSPACE_STORAGE_KEY);
return typeof raw === "string" ? raw : "";
} catch {
return "";
}
}
/**
* Persist the workspace trimmed, exactly as SettingsRepository.setWorkspace
* does, and return the stored value so the caller can show the same line. Never
* throws: an unavailable/full storage leaves the in-memory value authoritative.
*/
export function writeWorkspace(storage, value) {
const trimmed = String(value ?? "").trim();
try {
storage?.setItem?.(WORKSPACE_STORAGE_KEY, trimmed);
} catch {
// A read-only or full localStorage must not break saving in memory.
}
return trimmed;
}
/**
* Read the persisted server URL. The same tolerant contract as `readWorkspace`:
* a missing storage, a throwing `getItem` or a non-string value all read as "".
* (The page treats "" as "use the default endpoint", exactly as before.)
*/
export function readServerUrl(storage) {
try {
const raw = storage?.getItem?.(SERVER_URL_STORAGE_KEY);
return typeof raw === "string" ? raw : "";
} catch {
return "";
}
}
/**
* Persist the server URL trimmed, mirroring SettingsRepository.setServerUrl.
* Never throws: an unavailable/full storage leaves the in-memory value
* authoritative. Returns the stored value.
*/
export function writeServerUrl(storage, value) {
const trimmed = String(value ?? "").trim();
try {
storage?.setItem?.(SERVER_URL_STORAGE_KEY, trimmed);
} catch {
// A read-only or full localStorage must not break connecting.
}
return trimmed;
}
/**
* The connection status card's lines, exactly per SettingsScreen.kt's
* ConnectionStatusCard:
* idle -> "Not connected"
* connecting -> "Connecting (attempt N)…"
* connected -> "Connected", the build line when present, "Server time t" when present
* disconnected -> "Disconnected", the message, "Retrying with backoff…" only while retrying
*
* The connecting and build lines reuse `connection.js`, so each sentence has one
* definition shared with the header banner.
*/
export function connectionCard(state, { version, commit, serverTime } = {}) {
const c = state ?? {};
switch (c.kind) {
case "connected": {
const lines = ["Connected"];
const build = serverBuildLabel({ version, commit });
if (build) lines.push(build);
const time = String(serverTime ?? "").trim();
if (time) lines.push(`Server time ${time}`);
return lines;
}
case "connecting":
return [connectingLabel(c.attempt)];
case "disconnected": {
const lines = ["Disconnected"];
const reason = String(c.reason ?? "").trim();
if (reason) lines.push(reason);
if (c.retrying) lines.push("Retrying with backoff\u2026");
return lines;
}
default:
return ["Not connected"];
}
}
/**
* The emphasised primary action and the de-emphasised secondary one, mirroring
* SettingsScreen.kt's `active` branch: while connected (or connecting) the
* meaningful action is Disconnect, otherwise Connect, with Reconnect offered
* while idle/disconnected. The labels are the app's own.
*/
export function connectionActions(state) {
const kind = (state ?? {}).kind;
const active = kind === "connected" || kind === "connecting";
return active
? { primary: "Disconnect", secondary: "Connect" }
: { primary: "Connect", secondary: "Reconnect" };
}
/**
* Which existing client operation an action label drives. The mapping is pure so
* the page cannot accidentally send `Connect` through the header's toggle (which
* disconnects while connected): Android's `AppViewModel.connect()` is
* connect-only, `reconnect()` re-opens the saved endpoint and `disconnect()` is
* the only thing that closes the socket. Returns one of
* `"disconnect" | "reconnect" | "connect"`; anything that is not a known
* disconnect/reconnect label is a connect.
*/
export function connectionActionKind(label) {
if (label === "Disconnect") return "disconnect";
if (label === "Reconnect") return "reconnect";
return "connect";
}
+85
View File
@@ -1800,3 +1800,88 @@ code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font-
.md-rule { border: 0; border-top: 1px solid var(--border); }
.md-link { color: var(--accent); }
.md-link-plain { color: var(--muted); }
/* ---------------------------------------------------------------------------
Settings (L1): the app's one-column settings page — Connection, Workspace
and Templates sections on the dark palette, with a status card and the
trusted-network warning tinted for the error colour.
--------------------------------------------------------------------------- */
.settings {
display: grid;
gap: 22px;
max-width: 720px;
margin: 0 auto;
padding: 18px 16px 48px;
}
.settings-section { display: grid; gap: 10px; }
.settings-title {
margin: 0;
font-size: 15px;
font-weight: 600;
color: var(--text);
}
.settings-field { display: grid; gap: 6px; }
.settings-field-label { font-size: 12px; color: var(--muted); }
.settings-field input[type="text"] { flex: none; width: 100%; min-width: 0; }
.settings-helper { margin: 0; font-size: 12px; color: var(--muted); }
.settings-helper-error { color: var(--bad); }
.settings-field input[aria-invalid="true"],
.settings-field input[aria-invalid="true"]:focus { border-color: var(--bad); }
.settings-field input[aria-invalid="true"]:focus-visible { outline-color: var(--bad); }
.settings-actions { display: flex; gap: 8px; }
.settings button.primary {
background: var(--accent);
border-color: var(--accent);
color: #06231c;
font-weight: 600;
}
.settings button.primary:hover { border-color: var(--accent); filter: brightness(1.06); }
.settings button.primary:disabled {
background: var(--surface-2);
border-color: var(--border);
color: var(--muted);
opacity: 0.6;
cursor: not-allowed;
filter: none;
}
.settings-status {
display: grid;
gap: 4px;
border: 1px solid var(--border);
border-radius: 10px;
background: var(--surface-2);
padding: 14px 16px;
}
.settings-status-line { margin: 0; font-size: 13px; }
.settings-status-head { display: flex; align-items: center; gap: 12px; }
.settings-status-spinner { width: 14px; height: 14px; border-width: 2px; }
.settings-status-line:first-child { font-weight: 600; font-size: 14px; }
.settings-status-head .settings-status-line { font-weight: 600; font-size: 14px; }
.settings-status.status-ok .settings-status-line:first-child,
.settings-status.status-ok .settings-status-head .settings-status-line { color: var(--ok); }
.settings-status.status-error .settings-status-line:first-child { color: var(--bad); }
.settings-status.status-connecting .settings-status-line:first-child,
.settings-status.status-connecting .settings-status-head .settings-status-line { color: var(--warn); }
.settings-warning {
display: grid;
gap: 6px;
border: 1px solid var(--border);
border-radius: 10px;
background: color-mix(in srgb, var(--bad) 12%, var(--surface-2));
padding: 14px 16px;
}
.settings-warning-title { margin: 0; font-weight: 600; color: var(--bad); }
.settings-warning-body { margin: 0; font-size: 12.5px; color: var(--muted); }
.settings-saved { margin: 0; font-size: 12px; color: var(--muted); }
.settings-save { justify-self: start; }
.settings-card {
display: flex;
align-items: center;
gap: 12px;
width: 100%;
padding: 14px 16px;
}
.settings-card-glyph { color: var(--muted); font-size: 18px; line-height: 1; }
.settings-card-text { display: block; flex: 1; min-width: 0; }
.settings-card-chevron { color: var(--muted); font-size: 20px; line-height: 1; }
.settings-card .card-desc { display: block; -webkit-line-clamp: unset; }
+23
View File
@@ -182,3 +182,26 @@ test("disconnect goes idle and does not schedule a reconnect", () => {
assert.equal(client.state.retrying, false);
assert.deepEqual(ws.closed, { code: 1000, reason: "client closing" });
});
test("connecting again replaces the socket and ignores the superseded one", async () => {
// The Settings `Connect` action is connect-only and must be safe to press while
// connected: it re-opens the endpoint (Android's connectLocked replaces the
// socket) instead of leaving two live sockets or letting the old one's late
// close mark the new connection disconnected.
const { client, ws } = connectedClient();
const pending = client.call({ type: "ping" }); // sent on the old socket
await flush();
client.connect(VALID);
const replacement = FakeWebSocket.instances.at(-1);
assert.notEqual(replacement, ws);
assert.equal(client.state.kind, "connecting");
await assert.rejects(() => pending, /Connection replaced/);
assert.deepEqual(ws.closed, { code: 1000, reason: "superseded" });
replacement.open();
assert.equal(client.state.kind, "connected");
// The superseded socket's late failure must not touch the live connection.
ws.drop(1006);
assert.equal(client.state.kind, "connected");
assert.equal(client.state.retrying, false);
});
+357
View File
@@ -0,0 +1,357 @@
// Unit tests for the Settings destination's pure logic (src/settings.js): the
// workspace validation rules, the Save-enabled rule, the `Saved workspace:` line,
// the connection status card's four states and the two persisted keys. No DOM, no
// socket: `node --test test/settings.test.mjs` proves the logic the page wires up,
// so the browser run only has to prove the rendering.
//
// The wording is asserted against the Android client's own strings
// (ui/screens/SettingsScreen.kt, ui/AppViewModel.kt, data/SettingsRepository.kt);
// the last test reads those sources so a rename there cannot silently drift past
// this one.
import { test } from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { dirname, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import {
SERVER_URL_HELPER,
SERVER_URL_PLACEHOLDER,
SERVER_URL_STORAGE_KEY,
TEMPLATES_CARD_LABEL,
TEMPLATES_CARD_SECONDARY,
TRUST_BODY,
TRUST_TITLE,
WORKSPACE_ERROR,
WORKSPACE_HELPER,
WORKSPACE_PLACEHOLDER,
WORKSPACE_STORAGE_KEY,
canSaveWorkspace,
connectionActionKind,
connectionActions,
connectionCard,
readServerUrl,
readWorkspace,
savedWorkspaceLine,
validateWorkspacePath,
workspaceErrorText,
writeServerUrl,
writeWorkspace,
} from "../src/settings.js";
import { bannerState, connectingLabel } from "../src/connection.js";
const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
const source = (rel) => readFileSync(resolve(ROOT, rel), "utf8");
const androidSrc = (rel) => source(`android/app/src/main/java/net/awan/pipelines/${rel}`);
/** A minimal in-memory Storage, plus a throwing one, for the persistence tests. */
function memoryStorage(seed = {}) {
const map = new Map(Object.entries(seed));
return {
getItem: (key) => (map.has(key) ? map.get(key) : null),
setItem: (key, value) => map.set(key, String(value)),
key: (i) => [...map.keys()][i] ?? null,
get length() {
return map.size;
},
};
}
// ---------------------------------------------------------------------------
// The exact copy constants
// ---------------------------------------------------------------------------
test("the settings copy is the Android strings verbatim", () => {
assert.equal(SERVER_URL_PLACEHOLDER, "ws://192.168.1.20:8081/connect");
assert.equal(
SERVER_URL_HELPER,
"ws:// on a trusted LAN/VPN, or wss:// through a proxy/VPN. No authentication is used.",
);
assert.equal(WORKSPACE_PLACEHOLDER, "/Users/you/repos/pipelines");
assert.equal(
WORKSPACE_HELPER,
"An absolute directory that already exists on the execution server. For Docker, " +
"mount the host directory at the same absolute path with its owner's UID/GID. " +
"This is not the phone's storage.",
);
assert.equal(
WORKSPACE_ERROR,
"The workspace must be an absolute path that exists on the execution server.",
);
assert.equal(TRUST_TITLE, "Trusted LAN/VPN only");
assert.equal(
TRUST_BODY,
"The Pipelines API has no authentication and is not internet-safe. Do not " +
"expose it to untrusted networks, and never enter provider credentials here \u2014 " +
"the app stores none.",
);
assert.equal(TEMPLATES_CARD_LABEL, "Browse templates");
assert.equal(TEMPLATES_CARD_SECONDARY, "Reusable pipeline definitions offered by the server.");
});
// ---------------------------------------------------------------------------
// validateWorkspacePath / workspaceErrorText — AppViewModel.validateWorkspace
// ---------------------------------------------------------------------------
test("validateWorkspacePath accepts a blank draft and an absolute path", () => {
assert.equal(validateWorkspacePath(""), null);
assert.equal(validateWorkspacePath(" "), null);
assert.equal(validateWorkspacePath(undefined), null);
assert.equal(validateWorkspacePath(null), null);
assert.equal(validateWorkspacePath("/Users/you/repos/pipelines"), null);
assert.equal(validateWorkspacePath(" /srv/pipelines "), null);
});
test("validateWorkspacePath names the failure for a relative or bare path", () => {
assert.equal(validateWorkspacePath("repos/pipelines"), WORKSPACE_ERROR);
assert.equal(validateWorkspacePath("~/pipelines"), WORKSPACE_ERROR);
assert.equal(validateWorkspacePath("C:\\pipelines"), WORKSPACE_ERROR);
assert.equal(validateWorkspacePath(" relative "), WORKSPACE_ERROR);
});
test("workspaceErrorText is the error or empty (Android's `workspaceError ?: helper`)", () => {
assert.equal(workspaceErrorText("repos/pipelines"), WORKSPACE_ERROR);
assert.equal(workspaceErrorText(""), "");
assert.equal(workspaceErrorText("/srv/pipelines"), "");
});
// ---------------------------------------------------------------------------
// canSaveWorkspace — the Save button's enabled state
// ---------------------------------------------------------------------------
test("canSaveWorkspace enables Save only for a trimmed absolute path", () => {
assert.equal(canSaveWorkspace("/srv/pipelines"), true);
assert.equal(canSaveWorkspace(" /srv/pipelines "), true);
// Deliberately stricter than Android (which also enables Save on a blank
// field): the browser has nothing to save for a blank path.
assert.equal(canSaveWorkspace(""), false);
assert.equal(canSaveWorkspace(" "), false);
assert.equal(canSaveWorkspace("repos/pipelines"), false);
assert.equal(canSaveWorkspace(undefined), false);
});
test("canSaveWorkspace derives from validateWorkspacePath, so the rule has one source", () => {
for (const value of ["", " ", "repos/pipelines", "~/x", "C:\\x", "/srv/x", " /srv/x ", "/", "/a/b"]) {
const trimmed = String(value).trim();
assert.equal(
canSaveWorkspace(value),
trimmed !== "" && validateWorkspacePath(value) === null,
`disagreement for ${JSON.stringify(value)}`,
);
}
});
// ---------------------------------------------------------------------------
// savedWorkspaceLine
// ---------------------------------------------------------------------------
test("savedWorkspaceLine reads the path, or (none) when unset", () => {
assert.equal(savedWorkspaceLine("/Users/you/repos/pipelines"), "Saved workspace: /Users/you/repos/pipelines");
assert.equal(savedWorkspaceLine(" /srv/x "), "Saved workspace: /srv/x");
assert.equal(savedWorkspaceLine(""), "Saved workspace: (none)");
assert.equal(savedWorkspaceLine(" "), "Saved workspace: (none)");
assert.equal(savedWorkspaceLine(null), "Saved workspace: (none)");
});
// ---------------------------------------------------------------------------
// connectionCard — SettingsScreen.kt's ConnectionStatusCard
// ---------------------------------------------------------------------------
test("connectionCard idle reads Not connected", () => {
assert.deepEqual(connectionCard({ kind: "idle" }), ["Not connected"]);
assert.deepEqual(connectionCard(undefined), ["Not connected"]);
assert.deepEqual(connectionCard({ kind: "something-else" }), ["Not connected"]);
});
test("connectionCard connecting names the attempt", () => {
assert.deepEqual(connectionCard({ kind: "connecting", attempt: 4 }), ["Connecting (attempt 4)\u2026"]);
assert.deepEqual(connectionCard({ kind: "connecting" }), ["Connecting (attempt 0)\u2026"]);
});
test("the connecting line is the banner's own, so the app sentence has one source", () => {
for (const attempt of [0, 1, 7]) {
const state = { kind: "connecting", attempt };
assert.deepEqual(connectionCard(state), [bannerState(state).text]);
}
assert.equal(connectingLabel(3), "Connecting (attempt 3)\u2026");
});
test("connectionCard connected shows the build and server time when present", () => {
assert.deepEqual(
connectionCard(
{ kind: "connected" },
{ version: "v1.2.3", commit: "abc123", serverTime: "2026-10-19T08:00:00Z" },
),
["Connected", "Server build v1.2.3 (abc123)", "Server time 2026-10-19T08:00:00Z"],
);
// Missing fields are tolerated: no build line, no time line.
assert.deepEqual(connectionCard({ kind: "connected" }, {}), ["Connected"]);
assert.deepEqual(connectionCard({ kind: "connected" }, { version: "v1", serverTime: " " }), [
"Connected",
"Server build v1",
]);
});
test("connectionCard disconnected carries the reason and the retry suffix", () => {
assert.deepEqual(
connectionCard({ kind: "disconnected", reason: "Connection closed (1006)", retrying: true }),
["Disconnected", "Connection closed (1006)", "Retrying with backoff\u2026"],
);
assert.deepEqual(
connectionCard({ kind: "disconnected", reason: "Connection closed (1000)", retrying: false }),
["Disconnected", "Connection closed (1000)"],
);
// A blank reason renders no empty line; retrying alone still shows.
assert.deepEqual(connectionCard({ kind: "disconnected", reason: " ", retrying: true }), [
"Disconnected",
"Retrying with backoff\u2026",
]);
});
// ---------------------------------------------------------------------------
// connectionActions — SettingsScreen.kt's `active` branch
// ---------------------------------------------------------------------------
test("connectionActions emphasises Disconnect while connected or connecting", () => {
assert.deepEqual(connectionActions({ kind: "connected" }), { primary: "Disconnect", secondary: "Connect" });
assert.deepEqual(connectionActions({ kind: "connecting", attempt: 2 }), {
primary: "Disconnect",
secondary: "Connect",
});
});
test("connectionActions emphasises Connect and offers Reconnect otherwise", () => {
assert.deepEqual(connectionActions({ kind: "idle" }), { primary: "Connect", secondary: "Reconnect" });
assert.deepEqual(connectionActions({ kind: "disconnected", reason: "x" }), {
primary: "Connect",
secondary: "Reconnect",
});
assert.deepEqual(connectionActions(undefined), { primary: "Connect", secondary: "Reconnect" });
});
test("connectionActionKind keeps Connect connect-only (never the header's toggle)", () => {
// Android's connect() validates + persists + opens; only disconnect() closes.
assert.equal(connectionActionKind("Connect"), "connect");
assert.equal(connectionActionKind("Reconnect"), "reconnect");
assert.equal(connectionActionKind("Disconnect"), "disconnect");
// Any unknown label is treated as a connect, never as a disconnect.
assert.equal(connectionActionKind(""), "connect");
assert.equal(connectionActionKind(undefined), "connect");
for (const state of [{ kind: "connected" }, { kind: "connecting" }, { kind: "idle" }]) {
const { primary, secondary } = connectionActions(state);
const kinds = [connectionActionKind(primary), connectionActionKind(secondary)];
assert.deepEqual(kinds, state.kind === "idle" ? ["connect", "reconnect"] : ["disconnect", "connect"]);
}
});
// ---------------------------------------------------------------------------
// Persisted keys round-trip
// ---------------------------------------------------------------------------
test("the two persisted keys are the exact, stable localStorage keys", () => {
assert.equal(SERVER_URL_STORAGE_KEY, "pipelines.web.serverUrl.v2");
assert.equal(WORKSPACE_STORAGE_KEY, "pipelines.web.workspace.v1");
});
test("writeWorkspace trims and reads back; readWorkspace is tolerant", () => {
const storage = memoryStorage();
assert.equal(writeWorkspace(storage, " /srv/pipelines "), "/srv/pipelines");
assert.equal(storage.getItem(WORKSPACE_STORAGE_KEY), "/srv/pipelines");
assert.equal(storage.length, 1, "only the workspace key is written");
assert.equal(readWorkspace(storage), "/srv/pipelines");
// Blank reads back as "" (the stored value), never throwing.
writeWorkspace(storage, " ");
assert.equal(readWorkspace(storage), "");
assert.equal(storage.length, 1);
});
test("the server-URL key round-trips trimmed, under its own key only", () => {
const storage = memoryStorage();
assert.equal(writeServerUrl(storage, " ws://127.0.0.1:8080/connect "), "ws://127.0.0.1:8080/connect");
assert.equal(storage.getItem(SERVER_URL_STORAGE_KEY), "ws://127.0.0.1:8080/connect");
assert.equal(readServerUrl(storage), "ws://127.0.0.1:8080/connect");
assert.equal(storage.length, 1, "only the server-URL key is written");
// The two keys are independent: writing one never disturbs the other.
writeWorkspace(storage, "/srv/pipelines");
assert.equal(storage.length, 2);
assert.equal(readServerUrl(storage), "ws://127.0.0.1:8080/connect");
assert.equal(readWorkspace(storage), "/srv/pipelines");
});
test("readServerUrl is blank on a missing/unreadable storage and never throws", () => {
assert.equal(readServerUrl(memoryStorage()), "");
assert.equal(readServerUrl(undefined), "");
assert.equal(readServerUrl(null), "");
const throwing = {
getItem() {
throw new Error("denied");
},
setItem() {
throw new Error("denied");
},
};
assert.equal(readServerUrl(throwing), "");
assert.equal(writeServerUrl(throwing, " ws://host:1/connect "), "ws://host:1/connect");
});
test("readWorkspace is blank on a missing/unreadable storage and never throws", () => {
assert.equal(readWorkspace(memoryStorage()), "");
assert.equal(readWorkspace(undefined), "");
assert.equal(readWorkspace(null), "");
const throwing = {
getItem() {
throw new Error("denied");
},
setItem() {
throw new Error("denied");
},
};
assert.equal(readWorkspace(throwing), "");
assert.equal(writeWorkspace(throwing, "/srv/x"), "/srv/x");
});
// ---------------------------------------------------------------------------
// Parity with the Android sources
// ---------------------------------------------------------------------------
test("the wording still matches the Android client's sources", () => {
const settings = androidSrc("ui/screens/SettingsScreen.kt");
for (const line of [
'Text("Connection"',
'Text("Server URL")',
'Text("ws://192.168.1.20:8081/connect")',
"ws:// on a trusted LAN/VPN, or wss:// through a proxy/VPN. No authentication is used.",
'Text("Workspace"',
'Text("Workspace path (on the server)")',
'Text("/Users/you/repos/pipelines")',
"An absolute directory that already exists on the execution server. For Docker, ",
"This is not the phone's storage.",
'Text("Save workspace")',
'"Trusted LAN/VPN only"',
"The Pipelines API has no authentication and is not internet-safe. Do not ",
"never enter provider credentials here \\u2014 ",
'Text("Browse templates"',
"Reusable pipeline definitions offered by the server.",
'Text("Disconnected"',
'Text("Retrying with backoff\\u2026")',
'Text("Connecting (attempt ${state.attempt})\\u2026")',
'Text("Connected"',
]) {
assert.ok(settings.includes(line), `SettingsScreen.kt is missing: ${line}`);
}
const vm = androidSrc("ui/AppViewModel.kt");
assert.ok(
vm.includes("The workspace must be an absolute path that exists on the execution server."),
"AppViewModel.kt workspace error",
);
assert.ok(vm.includes("!trimmed.startsWith(\"/\")"), "AppViewModel.kt absolute-path rule");
// The two Android preference keys the browser analogues stand in for.
const repo = androidSrc("data/SettingsRepository.kt");
assert.ok(repo.includes('const val KEY_SERVER_URL = "server_url"'), "KEY_SERVER_URL");
assert.ok(repo.includes('const val KEY_WORKSPACE = "workspace"'), "KEY_WORKSPACE");
// Only non-secret preferences are stored (no credentials).
assert.ok(repo.includes("No credentials or tokens are ever stored"), "no-secrets note");
});
+458 -20
View File
@@ -19,6 +19,19 @@ import { tmpdir } from "node:os";
import { dirname, join, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import { eventually, launchChrome } from "./browser.mjs";
import {
SERVER_URL_HELPER,
SERVER_URL_PLACEHOLDER,
SERVER_URL_STORAGE_KEY,
TEMPLATES_CARD_LABEL,
TEMPLATES_CARD_SECONDARY,
TRUST_BODY,
TRUST_TITLE,
WORKSPACE_ERROR,
WORKSPACE_HELPER,
WORKSPACE_PLACEHOLDER,
WORKSPACE_STORAGE_KEY,
} from "../src/settings.js";
const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
@@ -2352,13 +2365,35 @@ try {
throw new Error(`Clear search left the query: ${JSON.stringify(clearedQuery)}`);
}
// The live session set changes between runs: the first row can be a
// freshly-created empty "New chat" (which renders the empty state, not a
// transcript). Prefer the operator's own session; otherwise try the listed rows
// in order until one carries a real transcript, and say plainly if none does,
// rather than waiting on a hard-coded session that the server no longer lists.
const expectedSession = "ses_eae413f50ffeLQDExlg8cYnscN";
const openedId = chatList.rows[0].id;
if (openedId !== expectedSession) {
console.log(` -- the live server's first session is ${openedId}, not the expected ${expectedSession}`);
const preferred = chatList.rows.find((row) => row.id === expectedSession);
const openRows = chatList.rows.filter((row) => row.close).map((row) => row.id);
const candidates = [
...new Set([...(preferred ? [preferred.id] : []), ...openRows, ...chatList.rows.map((r) => r.id)]),
];
let openedId = null;
for (const candidate of candidates) {
await page.click(`#chatRows .chat-row[data-session="${candidate}"]`);
const opened = await eventually(() => page.evaluate(`!!document.querySelector("#chatTranscript")`), {
timeout: 12000,
what: `a transcript for ${candidate}`,
}).catch(() => false);
if (opened) {
openedId = candidate;
break;
}
}
if (!openedId) {
throw new Error("no chat session on the live server carried a transcript to review");
}
if (openedId !== expectedSession) {
console.log(` -- the live server's first session with history is ${openedId}, not ${expectedSession}`);
}
await page.click(`#chatRows .chat-row[data-session="${openedId}"]`);
await page.waitForSelector("#chatTranscript", { timeout: 25000 });
const transcript = await page.evaluate(`(() => {
const el = document.querySelector("#chatTranscript");
@@ -2377,15 +2412,18 @@ try {
};
})()`);
if (!transcript) throw new Error("the opened transcript did not render");
if (transcript.userBubbles !== 1) throw new Error(`expected one user bubble, got ${transcript.userBubbles}`);
if (transcript.agentBubbles !== 1) {
throw new Error(`expected one folded agent turn, got ${transcript.agentBubbles}`);
// The live session may have grown since the row was authored, so the counts are
// lower bounds: at least one operator turn, at least one folded agent turn, at
// least one tool chip.
if (transcript.userBubbles < 1) throw new Error(`expected at least one user bubble, got ${transcript.userBubbles}`);
if (transcript.agentBubbles < 1) {
throw new Error(`expected at least one folded agent turn, got ${transcript.agentBubbles}`);
}
if (transcript.markdown === 0) throw new Error("the agent turn rendered no markdown");
if (transcript.tables === 0) throw new Error("the agent answer rendered no markdown table");
if (transcript.inlineCode === 0) throw new Error("the agent answer rendered no inline code");
if (transcript.toolChips.length !== 1) {
throw new Error(`expected one tool-call chip, got ${transcript.toolChips.length}`);
if (transcript.toolChips.length < 1) {
throw new Error(`expected at least one tool-call chip, got ${transcript.toolChips.length}`);
}
console.log(
` transcript: ${transcript.userBubbles} user + ${transcript.agentBubbles} folded agent turn; ` +
@@ -2551,11 +2589,12 @@ try {
const chip = document.querySelector("#chatTranscript .chat-tool-chip");
if (!chip) return null;
chip.scrollIntoView({ block: "center" });
const tools = chip.closest(".chat-tools");
return {
text: chip.textContent ?? "",
aria: chip.getAttribute("aria-label") ?? "",
chevron: chip.querySelector(".chat-tool-chevron")?.getAttribute("aria-label") ?? "",
rows: document.querySelectorAll(".chat-tool-panel .chat-tool-row").length,
rows: tools.querySelectorAll(".chat-tool-row").length,
};
})()`);
if (!chipInfo) throw new Error("C6: no tool-call chip rendered in the live transcript");
@@ -2584,7 +2623,7 @@ try {
const openedPanel = await page.evaluate(`(() => {
const chip = document.querySelector("#chatTranscript .chat-tool-chip");
chip.click();
const panel = document.querySelector(".chat-tool-panel");
const panel = chip.closest(".chat-tools").querySelector(".chat-tool-panel");
return {
hidden: panel?.hidden ?? true,
head: panel?.querySelector(".chat-tool-panel-count")?.textContent ?? "",
@@ -2617,7 +2656,8 @@ try {
// Expand the first row in place and assert its chevron name, its INPUT and its
// OUTPUT (the live first call is a settled `read` carrying both).
const firstToolRow = await page.evaluate(`(() => {
const panel = document.querySelector(".chat-tool-panel");
const chip = document.querySelector("#chatTranscript .chat-tool-chip");
const panel = chip.closest(".chat-tools").querySelector(".chat-tool-panel");
const list = panel.querySelector(".chat-tool-list");
list.scrollTop = 0;
const first = () => panel.querySelector(".chat-tool-row-head");
@@ -2653,9 +2693,9 @@ try {
// Closing it must put the transcript back exactly where it was.
const closedPanel = await page.evaluate(`(() => {
document.querySelector(".chat-tool-close").click();
const panel = document.querySelector(".chat-tool-panel");
const chip = document.querySelector("#chatTranscript .chat-tool-chip");
const panel = chip.closest(".chat-tools").querySelector(".chat-tool-panel");
panel.querySelector(".chat-tool-close").click();
return {
hidden: panel.hidden,
chevron: chip.querySelector(".chat-tool-chevron").getAttribute("aria-label"),
@@ -3230,17 +3270,23 @@ try {
const liveTurn = await page.evaluate(`(() => {
const transcript = document.querySelector("#chatTranscript");
const bubbles = [...transcript.querySelectorAll(".chat-turn-agent")];
const answer = bubbles.find((b) => b.textContent.includes("The live turn is growing."));
return {
agents: bubbles.length,
answers: bubbles.filter((b) => b.textContent.includes("The live turn is growing.")).length,
reasoning: bubbles.some((b) => b.textContent.includes("Planning the live capture.")),
oneBubble: !!(answer && answer.textContent.includes("Planning the live capture.")),
};
})()`);
console.log(
` replayed 3 frames (reasoning + 2 text deltas) → ${liveTurn.answers} agent bubble carries ` +
`"The live turn is growing." + reasoning (transcript agent bubbles ${agentBefore} -> ${liveTurn.agents})`,
);
if (liveTurn.answers !== 1 || !liveTurn.reasoning || liveTurn.agents !== agentBefore) {
// The live session may already end with an agent turn (in which case the replay
// grows it) or with a user turn (in which case it starts one new bubble); either
// way the replayed deltas are one reply and never fragment.
const grewBy = liveTurn.agents - agentBefore;
if (liveTurn.answers !== 1 || !liveTurn.reasoning || !liveTurn.oneBubble || grewBy < 0 || grewBy > 1) {
throw new Error(`C5: the replayed deltas did not grow one agent bubble: ${JSON.stringify(liveTurn)}`);
}
await shot("56-chat-live-turn.png");
@@ -3294,7 +3340,7 @@ try {
}
const agentsWithTwoIds = await agentCount();
console.log(` long-call line: "${longLine.text}${longLine.long}" tinted=${longLine.longTinted}`);
if (agentsWithTwoIds !== agentBefore) {
if (agentsWithTwoIds - agentBefore > 1) {
throw new Error(`C5: two assistant message ids fragmented the live turn into ${agentsWithTwoIds} bubbles`);
}
await shot("58-chat-long-call.png");
@@ -3311,14 +3357,19 @@ try {
);
const settled = await page.evaluate(`(() => {
const transcript = document.querySelector("#chatTranscript");
const bubbles = [...transcript.querySelectorAll(".chat-turn-agent")];
const answer = bubbles.find((b) => b.textContent.includes("The live turn is growing."));
return {
indicator: !!document.querySelector("#chatRunning"),
agents: transcript.querySelectorAll(".chat-turn-agent").length,
answers: [...transcript.querySelectorAll(".chat-turn-agent")].filter((b) => b.textContent.includes("The live turn is growing.")).length,
agents: bubbles.length,
answers: bubbles.filter((b) => b.textContent.includes("The live turn is growing.")).length,
// The one bubble that carries the live answer must also carry the replayed
// reasoning and the two tool rows: proof the turn never fragmented.
settledOneBubble: !!answer && answer.textContent.includes("Planning the live capture."),
};
})()`);
if (settled.indicator) throw new Error("C5: the running indicator survived the ended step");
if (settled.agents !== agentBefore || settled.answers !== 1) {
if (settled.agents - agentBefore > 1 || settled.answers !== 1 || !settled.settledOneBubble) {
throw new Error(`C5: the settled turn is not the same single agent bubble: ${JSON.stringify(settled)}`);
}
console.log(
@@ -3368,6 +3419,393 @@ try {
" NOTE: the chat_subscribe ack and every chat_history reply above came from the real server; only the chat_event frames were replayed",
);
// L1: the Settings destination. The live-badge step just disconnected on
// purpose, so reconnect first, then open Settings and assert the connected
// Connection section against the real pong, exercise the Workspace field and
// the Templates card, and prove both persistence keys restore on a reload.
step("reconnecting for the Settings destination (L1)");
await page.click("#connectBtn");
await page.waitForSelector(".conn-banner.conn-ok", { timeout: 25000 });
step("opening Settings and asserting the Connection section (L1)");
await page.clickText("nav.tabs button.tab", "Settings");
await page.waitForSelector("#settingsServerUrl", { timeout: 15000 });
await eventually(
() => page.evaluate(`document.querySelector("#settingsPrimary")?.textContent === "Disconnect"`),
{ timeout: 15000, what: "the Settings primary action to read Disconnect while connected" },
);
const settingsPrimary = await text("#settingsPrimary");
const settingsSecondary = await text("#settingsSecondary");
if (settingsPrimary !== "Disconnect" || settingsSecondary !== "Connect") {
throw new Error(`settings actions: primary=${settingsPrimary} secondary=${settingsSecondary}`);
}
// The secondary `Connect` label is connect-only (Android's AppViewModel.connect),
// never the header's toggle: pressing it while connected re-opens the shared
// socket and must never leave the page disconnected. Record the banner's state
// transitions so a same-frame return to green cannot hide a teardown.
await page.evaluate(`(() => {
window.__connTransitions = [];
const banner = document.querySelector(".conn-banner");
new MutationObserver(() => window.__connTransitions.push(banner.className)).observe(banner, {
attributes: true,
attributeFilter: ["class"],
});
})()`);
await page.click("#settingsSecondary");
await eventually(
() =>
page.evaluate(`(() => {
const banner = document.querySelector(".conn-banner");
return (
banner?.className === "conn-banner conn-ok" &&
window.__connTransitions.includes("conn-banner conn-connecting")
);
})()`),
{ timeout: 25000, what: "the secondary Connect to re-open the socket back to connected" },
);
const afterSecondary = await page.evaluate(`({
primary: document.querySelector("#settingsPrimary")?.textContent ?? "",
secondary: document.querySelector("#settingsSecondary")?.textContent ?? "",
banner: document.querySelector(".conn-banner")?.className ?? "",
transitions: window.__connTransitions,
})`);
if (afterSecondary.banner !== "conn-banner conn-ok") {
throw new Error(`secondary Connect left the banner ${afterSecondary.banner}`);
}
if (afterSecondary.transitions.includes("conn-banner conn-idle")) {
throw new Error(`secondary Connect tore the socket down: ${JSON.stringify(afterSecondary.transitions)}`);
}
if (afterSecondary.primary !== "Disconnect" || afterSecondary.secondary !== "Connect") {
throw new Error(
`secondary Connect changed the actions: primary=${afterSecondary.primary} secondary=${afterSecondary.secondary}`,
);
}
console.log(
` secondary Connect re-opened the existing client (connect-only, no toggle): ${afterSecondary.transitions.join(" -> ")}`,
);
const settingsUrlPlaceholder = await page.evaluate(
`document.querySelector("#settingsServerUrl")?.placeholder ?? ""`,
);
if (settingsUrlPlaceholder !== SERVER_URL_PLACEHOLDER) {
throw new Error(`settings URL placeholder: ${settingsUrlPlaceholder}`);
}
const settingsUrlHelper = await page.evaluate(`(() => {
const section = document.querySelector("#settingsServerUrl")?.closest(".settings-section");
return section?.querySelector(".settings-helper")?.textContent ?? "";
})()`);
if (settingsUrlHelper !== SERVER_URL_HELPER) {
throw new Error(`settings URL helper: ${settingsUrlHelper}`);
}
// The connected status card, read from the real pong: Connected + the build
// line + the server-time line (not just screenshotted).
await eventually(
() => page.evaluate(`(() => {
const lines = [...document.querySelectorAll(".settings-status .settings-status-line")].map((n) => n.textContent);
return lines[0] === "Connected" && lines.some((l) => l.startsWith("Server build ")) && lines.some((l) => l.startsWith("Server time "));
})()`),
{ timeout: 20000, what: "the connected Settings status card with build and time lines" },
);
const statusLines = await page.evaluate(
`[...document.querySelectorAll(".settings-status .settings-status-line")].map((n) => n.textContent)`,
);
const trustTitle = await text(".settings-warning .settings-warning-title");
const trustBody = await text(".settings-warning .settings-warning-body");
if (trustTitle !== TRUST_TITLE || trustBody !== TRUST_BODY) {
throw new Error(`trust warning: ${trustTitle} / ${trustBody}`);
}
console.log(` settings connection card: ${statusLines.join(" | ")}`);
await page.evaluate(`window.scrollTo(0, 0)`);
await shot("L1-settings-connection.png");
// F1 (blocking review finding): an invalid URL is reported as the Settings
// field's own error (Android's `urlError`) with aria-invalid/aria-describedby,
// and is cleared by the next edit — never left as a stale page-level banner.
// F2: the header URL field and the Settings field are one draft, mirrored in
// place, so they cannot show different endpoints while typing.
const goodUrl = await page.evaluate(`document.querySelector("#settingsServerUrl")?.value ?? ""`);
await page.fill("#settingsServerUrl", "not a url");
await page.click("#settingsSecondary");
const urlErrorState = await eventually(
() =>
page
.evaluate(`(() => {
const helper = document.querySelector("#settingsUrlHelper");
const field = document.querySelector("#settingsServerUrl");
return {
helper: helper?.textContent ?? "",
cls: helper?.className ?? "",
invalid: field?.getAttribute("aria-invalid") ?? "",
describedby: field?.getAttribute("aria-describedby") ?? "",
pageBanner: !!document.querySelector("#content .banner.error"),
};
})()`)
.then((value) => (value.helper === "That is not a valid URL." ? value : false)),
{ timeout: 10000, what: "the URL field's own error after an invalid Connect" },
);
if (urlErrorState.invalid !== "true" || urlErrorState.describedby !== "settingsUrlHelper") {
throw new Error(`URL field error is not the field's own state: ${JSON.stringify(urlErrorState)}`);
}
if (!urlErrorState.cls.includes("settings-helper-error")) {
throw new Error(`URL error helper is not error-tinted: ${JSON.stringify(urlErrorState)}`);
}
if (urlErrorState.pageBanner) {
throw new Error("the invalid URL was surfaced as a page-level banner, not the field error");
}
await page.evaluate(`document.querySelector("#settingsUrlHelper")?.scrollIntoView({ block: "center" })`);
await shot("L1-settings-url-error.png");
// F1 (blocking review finding): a correction made in the OTHER half of the
// mirrored draft must clear the Settings field's own error too. Before this fix,
// fixing the URL in the header left the Settings helper saying "That is not a
// valid URL." with aria-invalid still true.
const headerCorrection = await page.evaluate(`(() => {
const header = document.querySelector("#url");
header.value = "ws://10.7.7.7:8099/connect";
header.dispatchEvent(new Event("input", { bubbles: true }));
const settings = document.querySelector("#settingsServerUrl");
return {
helper: document.querySelector("#settingsUrlHelper")?.textContent ?? "",
invalid: settings?.hasAttribute("aria-invalid") ?? null,
mirrored: settings?.value ?? "",
};
})()`);
if (headerCorrection.invalid !== false || headerCorrection.helper !== SERVER_URL_HELPER) {
throw new Error(
`correcting the URL in the header left a stale Settings error: ${JSON.stringify(headerCorrection)}`,
);
}
if (headerCorrection.mirrored !== "ws://10.7.7.7:8099/connect") {
throw new Error(`the Settings field did not mirror the header correction: ${JSON.stringify(headerCorrection)}`);
}
console.log(" a header correction clears the Settings field's error and mirrors the value");
// Editing the field (Android's updateServerUrlDraft) clears the error and
// restores the helper — and the header field mirrors the Settings value.
const syncState = await page.evaluate(`(() => {
const settings = document.querySelector("#settingsServerUrl");
const header = document.querySelector("#url");
settings.value = "ws://10.9.9.9:8099/connect";
settings.dispatchEvent(new Event("input", { bubbles: true }));
const headerAfterSettings = header.value;
header.value = "ws://10.8.8.8:8099/connect";
header.dispatchEvent(new Event("input", { bubbles: true }));
return {
headerAfterSettings,
settingsAfterHeader: settings.value,
helper: document.querySelector("#settingsUrlHelper")?.textContent ?? "",
invalid: document.querySelector("#settingsServerUrl")?.hasAttribute("aria-invalid") ?? null,
};
})()`);
if (syncState.headerAfterSettings !== "ws://10.9.9.9:8099/connect") {
throw new Error(`header did not mirror the Settings URL: ${JSON.stringify(syncState)}`);
}
if (syncState.settingsAfterHeader !== "ws://10.8.8.8:8099/connect") {
throw new Error(`Settings did not mirror the header URL: ${JSON.stringify(syncState)}`);
}
if (syncState.invalid !== false || syncState.helper !== SERVER_URL_HELPER) {
throw new Error(`editing the URL did not clear the error: ${JSON.stringify(syncState)}`);
}
console.log(" invalid URL is the field's own error (aria-invalid, no page banner), cleared on edit; the two URL fields mirror");
await page.fill("#settingsServerUrl", goodUrl);
// The other three status-card states, live: Disconnect drives the page to idle
// (`Not connected`, Connect emphasised, Reconnect offered); a bad endpoint
// drives it to `Disconnected` with the server's message and the retry suffix.
step("capturing the idle and disconnected Settings status card (L1)");
await page.click("#settingsPrimary");
await eventually(
() =>
page.evaluate(`(() => {
const lines = [...document.querySelectorAll(".settings-status .settings-status-line")].map((n) => n.textContent);
return (
lines.length === 1 &&
lines[0] === "Not connected" &&
document.querySelector("#settingsPrimary")?.textContent === "Connect" &&
document.querySelector("#settingsSecondary")?.textContent === "Reconnect"
);
})()`),
{ timeout: 15000, what: "the idle Settings card after Disconnect" },
);
console.log(" settings idle card: Not connected (Connect primary, Reconnect secondary)");
await shot("L1-settings-idle.png");
await page.fill("#settingsServerUrl", `ws://127.0.0.1:${port}/not-a-connect-endpoint`);
await page.click("#settingsPrimary");
await eventually(
() =>
page.evaluate(`(() => {
const lines = [...document.querySelectorAll(".settings-status .settings-status-line")].map((n) => n.textContent);
return (
lines[0] === "Disconnected" &&
lines.length >= 3 &&
lines.includes("Retrying with backoff\\u2026")
);
})()`),
{ timeout: 20000, what: "the disconnected Settings card with its retry suffix" },
);
const disconnectedLines = await page.evaluate(
`[...document.querySelectorAll(".settings-status .settings-status-line")].map((n) => n.textContent)`,
);
console.log(` settings disconnected card: ${disconnectedLines.join(" | ")}`);
await shot("L1-settings-disconnected.png");
// The fourth state: an endpoint that neither accepts nor refuses (a
// non-routable address) leaves the client Connecting, so the attempt number is
// visible in the card. Disconnect then ends the attempt before the restore.
await page.fill("#settingsServerUrl", `ws://10.255.255.1:${port}/connect`);
await page.click("#settingsPrimary");
await eventually(
() =>
page.evaluate(`(() => {
const lines = [...document.querySelectorAll(".settings-status .settings-status-line")].map((n) => n.textContent);
return lines.length === 1 && /^Connecting \\(attempt \\d+\\)\\u2026$/.test(lines[0]);
})()`),
{ timeout: 15000, what: "the connecting Settings card with its attempt number" },
);
const connectingLine = await text(".settings-status .settings-status-line");
const connectingSpinner = await page.evaluate(
`!!document.querySelector(".settings-status .settings-status-spinner")`,
);
if (!connectingSpinner) throw new Error("the Connecting card should show the spinner (SettingsScreen.kt)");
console.log(` settings connecting card: ${connectingLine}`);
await shot("L1-settings-connecting.png");
await page.click("#settingsPrimary");
// Restore the real endpoint (and the persisted server URL) before the
// workspace step, so the reload assertion still sees a working configuration.
await page.fill("#settingsServerUrl", goodUrl);
await page.click("#settingsPrimary");
await page.waitForSelector(".conn-banner.conn-ok", { timeout: 25000 });
step("exercising the Settings workspace field (L1)");
const workspacePlaceholder = await page.evaluate(
`document.querySelector("#settingsWorkspace")?.placeholder ?? ""`,
);
if (workspacePlaceholder !== WORKSPACE_PLACEHOLDER) {
throw new Error(`workspace placeholder: ${workspacePlaceholder}`);
}
const blankWorkspaceHelper = await text("#workspaceHelper");
if (blankWorkspaceHelper !== WORKSPACE_HELPER) {
throw new Error(`workspace helper: ${blankWorkspaceHelper}`);
}
const blankSaved = await text("#savedWorkspace");
if (blankSaved !== "Saved workspace: (none)") throw new Error(`saved line on blank: ${blankSaved}`);
const blankSaveDisabled = await page.evaluate(`document.querySelector("#saveWorkspace")?.disabled ?? null`);
if (blankSaveDisabled !== true) throw new Error("Save workspace should be disabled while the field is blank");
// A relative path keeps Save disabled and names the rule (the helper line).
await page.fill("#settingsWorkspace", "repos/pipelines");
const relativeSaveDisabled = await page.evaluate(`document.querySelector("#saveWorkspace")?.disabled ?? null`);
if (relativeSaveDisabled !== true) throw new Error("Save workspace should stay disabled for a relative path");
const relativeHelper = await text("#workspaceHelper");
if (relativeHelper !== WORKSPACE_ERROR) throw new Error(`workspace error line: ${relativeHelper}`);
// F3 (minor review finding): the workspace error is distinguishable as an error
// (error tint + aria-invalid/aria-describedby), mirroring Android's isError.
const workspaceErrorState = await page.evaluate(`(() => ({
helperClass: document.querySelector("#workspaceHelper")?.className ?? "",
invalid: document.querySelector("#settingsWorkspace")?.getAttribute("aria-invalid") ?? "",
describedby: document.querySelector("#settingsWorkspace")?.getAttribute("aria-describedby") ?? "",
}))()`);
if (!workspaceErrorState.helperClass.includes("settings-helper-error")) {
throw new Error(`workspace helper is not error-tinted: ${JSON.stringify(workspaceErrorState)}`);
}
if (workspaceErrorState.invalid !== "true" || workspaceErrorState.describedby !== "workspaceHelper") {
throw new Error(`workspace field is not marked invalid: ${JSON.stringify(workspaceErrorState)}`);
}
await page.evaluate(`document.querySelector("#workspaceHelper")?.scrollIntoView({ block: "center" })`);
await shot("L1-settings-workspace-error.png");
// An absolute path (padded with spaces) enables Save; saving stores the trimmed value.
await page.fill("#settingsWorkspace", " /Users/alan/repos/pipelines ");
const absoluteSaveEnabled = await page.evaluate(`document.querySelector("#saveWorkspace")?.disabled === false`);
if (!absoluteSaveEnabled) throw new Error("Save workspace should be enabled for an absolute path");
const workspaceValidState = await page.evaluate(`(() => ({
helperClass: document.querySelector("#workspaceHelper")?.className ?? "",
invalid: document.querySelector("#settingsWorkspace")?.hasAttribute("aria-invalid") ?? null,
}))()`);
if (workspaceValidState.invalid !== false || workspaceValidState.helperClass.includes("settings-helper-error")) {
throw new Error(`the workspace error did not clear for a valid path: ${JSON.stringify(workspaceValidState)}`);
}
console.log(" workspace error is error-tinted with aria-invalid; a valid path clears it");
const keysBeforeSave = await page.evaluate(`Object.keys(localStorage)`);
await page.click("#saveWorkspace");
const savedLine = await text("#savedWorkspace");
if (savedLine !== "Saved workspace: /Users/alan/repos/pipelines") {
throw new Error(`saved line: ${savedLine}`);
}
const storedWorkspace = await page.evaluate(`localStorage.getItem(${JSON.stringify(WORKSPACE_STORAGE_KEY)})`);
if (storedWorkspace !== "/Users/alan/repos/pipelines") throw new Error(`stored workspace: ${storedWorkspace}`);
// Saving the workspace writes exactly that one key, and no credential-like key
// is ever stored (the server has no authentication).
const keysAfterSave = await page.evaluate(`Object.keys(localStorage)`);
const addedKeys = keysAfterSave.filter((key) => !keysBeforeSave.includes(key));
if (addedKeys.length !== 1 || addedKeys[0] !== WORKSPACE_STORAGE_KEY) {
throw new Error(`workspace save wrote unexpected key(s): ${JSON.stringify(addedKeys)}`);
}
const credentialKey = await page.evaluate(
`Object.keys(localStorage).find((k) => /credential|token|secret|password/i.test(k)) ?? null`,
);
if (credentialKey) throw new Error(`a credential-like key was stored: ${credentialKey}`);
// No second copy of either setting under another name: every settings-shaped
// key in localStorage is exactly one of the two documented keys.
const settingsKeys = await page.evaluate(
`Object.keys(localStorage).filter((k) => /settings|serverurl|workspace/i.test(k)).sort()`,
);
if (
settingsKeys.length !== 2 ||
!settingsKeys.includes(WORKSPACE_STORAGE_KEY) ||
!settingsKeys.includes(SERVER_URL_STORAGE_KEY)
) {
throw new Error(`unexpected settings keys: ${JSON.stringify(settingsKeys)}`);
}
const storedUrl = await page.evaluate(`localStorage.getItem(${JSON.stringify(SERVER_URL_STORAGE_KEY)})`);
if (storedUrl !== storedUrl.trim() || !storedUrl.startsWith("ws://")) {
throw new Error(`stored server URL is not the trimmed endpoint: ${storedUrl}`);
}
console.log(` settings keys: ${settingsKeys.join(", ")} (server URL ${storedUrl})`);
console.log(` settings workspace saved (trimmed): ${savedLine}`);
await shot("L1-settings-workspace.png");
step("asserting the Settings Templates card (L1)");
const templatesCardLabel = await text("#browseTemplates .card-name");
const templatesCardSecondary = await text("#browseTemplates .card-desc");
if (templatesCardLabel !== TEMPLATES_CARD_LABEL || templatesCardSecondary !== TEMPLATES_CARD_SECONDARY) {
throw new Error(`templates card: ${templatesCardLabel} / ${templatesCardSecondary}`);
}
// The card opens the existing Templates gallery (same destination as the tab).
// The capture is taken after the click, so it is independent evidence of the
// entry actually working rather than a duplicate of the Workspace frame (the
// page is shorter than the viewport, so the card is already visible there).
await page.click("#browseTemplates");
await page.waitForSelector(".gallery .pane-head h2", { timeout: 20000 });
const galleryTitle = await text(".gallery .pane-head h2");
if (galleryTitle !== "Templates") throw new Error(`templates gallery title: ${galleryTitle}`);
await shot("L1-settings-templates.png");
console.log(" Browse templates opened the existing Templates gallery");
step("reloading to prove the two settings keys restore (L1)");
const persisted = await page.evaluate(`({
serverUrl: localStorage.getItem(${JSON.stringify(SERVER_URL_STORAGE_KEY)}),
workspace: localStorage.getItem(${JSON.stringify(WORKSPACE_STORAGE_KEY)}),
})`);
if (persisted.workspace !== "/Users/alan/repos/pipelines") {
throw new Error(`persisted workspace: ${persisted.workspace}`);
}
if (!persisted.serverUrl || !persisted.serverUrl.startsWith("ws://")) {
throw new Error(`persisted server URL: ${persisted.serverUrl}`);
}
await page.evaluate(`location.reload()`);
await page.waitForSelector("#url", { timeout: 15000 });
const restoredUrl = await page.evaluate(`document.querySelector("#url")?.value ?? ""`);
if (restoredUrl !== persisted.serverUrl) throw new Error(`restored server URL: ${restoredUrl}`);
await page.clickText("nav.tabs button.tab", "Settings");
await page.waitForSelector("#settingsWorkspace", { timeout: 15000 });
const restoredWorkspace = await page.evaluate(`document.querySelector("#settingsWorkspace")?.value ?? ""`);
if (restoredWorkspace !== "/Users/alan/repos/pipelines") {
throw new Error(`restored workspace: ${restoredWorkspace}`);
}
const restoredSaved = await text("#savedWorkspace");
if (restoredSaved !== "Saved workspace: /Users/alan/repos/pipelines") {
throw new Error(`restored saved line: ${restoredSaved}`);
}
console.log(` reload restored url=${restoredUrl} workspace=${restoredWorkspace}`);
console.log("\nUI SMOKE PASS");
for (const shot of shots) console.log(` ${shot}`);
}