@wular/coder 0.4.3 → 0.4.5

package/dist/dash/standalone/server/modules-server-server-react-server/src/server/dash/app/dash/tasks/[id]/task-view.97433b52e6f7175c.js

@@ -0,0 +1,593 @@
+"use client";
+import "./task-view.c2288044c9032a89.css.pnext-asset.js";
+import { Fragment } from "../../../../../../../../../node_modules/preact/dist/preact.mjs";
+import { useEffect, useMemo, useRef, useState } from "../../../../../../../../../node_modules/preact/hooks/dist/hooks.mjs";
+import { serverEvents } from "../../../../../../client/index.2feb1c162fab6033.js";
+import { LogView } from "../../../../../../core/task/log-view.d6aae19495a81adb.js";
+import { client } from "../../../../utils/client.f37a313f4811ddb8.js";
+import { formatDate, formatDuration, reasonText } from "../../../../utils/format.ba382c381ea40e77.js";
+import { Link } from "../../../../../../../../../node_modules/@wular/pnext/src/api/link.tsx";
+import { useSearchParams } from "../../../../../../../../../node_modules/@wular/pnext/src/api/client-navigation.ts";
+import { iAgent, iCheck, iClock, iDown, iFolder, iPlug, iTerminal } from "../../../../comps/ui/icons.e17bdd0b5504787f.js";
+import { Badge } from "../../../../comps/ui/badge.e52db98d78836f9a.js";
+import { Card, Loading } from "../../../../comps/ui/card.e6876039e375b849.js";
+import { Collapse } from "../../../../comps/ui/collapse.730d674a8f7eeeae.js";
+import { Icon } from "../../../../comps/ui/icon.93605083edf7efe3.js";
+import { Menu } from "../../../../comps/ui/menu.3b3026ecd4dc31f0.js";
+import { Back, PageHead } from "../../../../comps/frame/page-head.857951b5dc1ad827.js";
+import { backFrom } from "../../../../comps/frame/heads.5407f7793f985b16.js";
+import { markdown } from "../../agents/agent/instructions.403838f7cb218391.js";
+import { Status } from "../list/status.d78e769ff1411932.js";
+import { folderName, sourceLabel, taskActive, taskTitle } from "../list/task.674ebeabafa0a7e1.js";
+import { Approval, TaskActions, useAction } from "./task-actions.f2be118dd5a02896.js";
+import { Activity } from "./activity.b23683e6be363068.js";
+import { toastError, useTaskEvents, watchTask } from "../../../../comps/frame/task-toasts.b14bb1f66ed75e75.js";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "../../../../../../../../../node_modules/preact/jsx-runtime/dist/jsxRuntime.mjs";
+const TABS = ["Conversation", "Activity"];
+function messageOf(value, fallback) {
+	if (typeof value === "string") return value;
+	if (!value || typeof value !== "object") return fallback;
+	const record = value;
+	for (const key of [
+		"output",
+		"answer",
+		"message"
+	]) if (typeof record[key] === "string") return record[key];
+	return fallback;
+}
+const isFindings = (json) => typeof json === "object" && json !== null && Array.isArray(json.findings) && json.findings.every((f) => typeof f === "object" && f !== null && "file" in f && "summary" in f);
+/** A review.s findings, one per changed line, worst first. */
+function Findings({ findings }) {
+	if (!findings.length) return /* @__PURE__ */ _jsx("p", {
+		class: "body muted",
+		children: "No findings."
+	});
+	return /* @__PURE__ */ _jsx("ul", {
+		class: "findings",
+		children: findings.map((f, index) => /* @__PURE__ */ _jsxs("li", {
+			class: `finding ${f.severity}`,
+			children: [
+				/* @__PURE__ */ _jsxs("p", {
+					class: "finding-head",
+					children: [
+						/* @__PURE__ */ _jsx("span", {
+							class: "sev",
+							children: f.severity
+						}),
+						/* @__PURE__ */ _jsxs("span", {
+							class: "loc",
+							children: [
+								f.file,
+								":",
+								f.line
+							]
+						}),
+						f.category ? /* @__PURE__ */ _jsx("span", {
+							class: "cat",
+							children: f.category
+						}) : null
+					]
+				}),
+				/* @__PURE__ */ _jsx("p", {
+					class: "finding-sum",
+					children: f.summary
+				}),
+				f.failure_scenario ? /* @__PURE__ */ _jsx("p", {
+					class: "finding-why muted",
+					children: f.failure_scenario
+				}) : null
+			]
+		}, index))
+	});
+}
+function ResultBody({ value }) {
+	const text = messageOf(value, "Result received.");
+	let json;
+	if (/^\s*[[{]/.test(text)) try {
+		json = JSON.parse(text);
+	} catch {}
+	if (isFindings(json)) return /* @__PURE__ */ _jsx(Findings, { findings: json.findings });
+	if (json && typeof json === "object") return /* @__PURE__ */ _jsx("pre", {
+		class: "body json",
+		children: JSON.stringify(json, null, 2)
+	});
+	return /* @__PURE__ */ _jsx("div", {
+		class: "body md",
+		children: markdown(text)
+	});
+}
+/** Back to where the task was opened from: a `back` path, a `from` list, or Tasks. */
+function TaskBack() {
+	const search = useSearchParams();
+	return /* @__PURE__ */ _jsx(Back, {
+		...backFrom(search.get("from"), {
+			href: "/dash/tasks",
+			params: {},
+			label: "Tasks"
+		}),
+		back: search.get("back")
+	});
+}
+/** The task's one-row head: back, title, status, source and agent, its actions, and a muted line with created time, source, folder, and the agent with its model. */
+function TaskHead({ task, tz }) {
+	const live = taskActive(task);
+	const { engine, model, effort } = {
+		...task.task.definition,
+		...task.task.usage
+	};
+	const source = task.task.event?.integration ?? task.task.source;
+	const kind = task.task.event?.type ?? (task.task.flow !== "default" ? task.task.flow : undefined);
+	return /* @__PURE__ */ _jsx(PageHead, {
+		back: /* @__PURE__ */ _jsx(TaskBack, {}),
+		title: taskTitle(task).split("\n")[0],
+		meta: /* @__PURE__ */ _jsxs(_Fragment, { children: [/* @__PURE__ */ _jsx(Status, { status: task.status }), task.archivedAt ? /* @__PURE__ */ _jsx(Badge, { children: "archived" }) : null] }),
+		lead: /* @__PURE__ */ _jsxs(_Fragment, { children: [
+			/* @__PURE__ */ _jsxs("span", {
+				class: "fact",
+				title: `Created ${formatDate(task.createdAt, tz)}`,
+				children: [
+					/* @__PURE__ */ _jsx(Icon, { d: iClock }),
+					formatDate(task.createdAt, tz, true),
+					task.startedAt && task.finishedAt ? `, ran ${formatDuration(task.finishedAt - task.startedAt)}` : null
+				]
+			}),
+			/* @__PURE__ */ _jsxs("span", {
+				class: "fact",
+				title: "Source",
+				children: [/* @__PURE__ */ _jsx(Icon, { d: task.task.event ? iPlug : iTerminal }), kind ? `${sourceLabel(source)} ${kind}` : sourceLabel(source)]
+			}),
+			task.task.cwd ? /* @__PURE__ */ _jsxs("span", {
+				class: "fact",
+				title: task.task.cwd,
+				children: [/* @__PURE__ */ _jsx(Icon, { d: iFolder }), folderName(task.task.cwd)]
+			}) : null,
+			/* @__PURE__ */ _jsxs("span", {
+				class: "fact",
+				children: [/* @__PURE__ */ _jsxs(Link, {
+					class: "agent-link",
+					href: "/dash/agents/[slug]",
+					params: { slug: task.task.agent },
+					search: { from: `/dash/tasks/${task.task.id}` },
+					children: [/* @__PURE__ */ _jsx(Icon, { d: iAgent }), task.task.agent]
+				}), engine ? /* @__PURE__ */ _jsx("span", {
+					class: "fact-dim",
+					title: "Engine, model and effort",
+					children: [
+						engine,
+						model,
+						effort
+					].filter(Boolean).join("/")
+				}) : null]
+			})
+		] }),
+		actions: /* @__PURE__ */ _jsx(TaskActions, {
+			task,
+			live
+		})
+	});
+}
+/** Display rows for the lines so far; new lines extend them or complete an earlier call. */
+function useDisplayRows(lines) {
+	const view = useRef();
+	return useMemo(() => {
+		const state = view.current ??= {
+			log: new LogView(),
+			rows: [],
+			seen: 0
+		};
+		for (const line of lines.slice(state.seen)) for (const row of state.log.reduce(line)) {
+			if (row.seq > (state.rows.at(-1)?.seq ?? -1)) state.rows.push(row);
+			else state.rows[state.rows.findLastIndex(({ seq }) => seq === row.seq)] = row;
+		}
+		state.seen = lines.length;
+		return [...state.rows];
+	}, [lines]);
+}
+/** A task as a conversation with its activity; the box at the bottom steers, asks, or continues. */
+export function TaskView({ initial, tz }) {
+	const [task, setTask] = useState(initial);
+	const [lines, setLines] = useState(initial.logs ?? []);
+	const [complete, setComplete] = useState((initial.logs?.length ?? 0) < LOG_CHUNK);
+	const [tab, setTab] = useState("conversation");
+	const [sent, setSent] = useState([]);
+	const [sending, setSending] = useState(false);
+	const [asking, setAsking] = useState(0);
+	// Answers already there at open have no known question; later ones pair with this session's asks in order.
+	const knownAnswers = useRef(task.answer?.length ?? 0);
+	const [ask, setAsk] = useState(false);
+	const [status, setStatus] = useState("");
+	const after = useRef(initial.logs?.at(-1)?.seq ?? -1);
+	const input = useRef(null);
+	const reply = useRef(null);
+	// The jump button floats above the reply box, however tall it grows.
+	useEffect(() => {
+		const form = reply.current;
+		const page = form?.closest(".page");
+		if (!form || !page) return;
+		const observer = new ResizeObserver(() => page.style.setProperty("--reply", `${form.offsetHeight}px`));
+		observer.observe(form);
+		return () => observer.disconnect();
+	}, [task.task.flow]);
+	const action = useAction(task.task.id);
+	const live = taskActive(task);
+	const replies = task.task.flow === "default";
+	const rows = useDisplayRows(lines);
+	useEffect(() => watchTask(task.task.id, task.status, taskTitle(task)), [task.status]);
+	useEffect(() => {
+		if (action.error) toastError("Not sent", action.error);
+	}, [action.error]);
+	const pending = useRef([]);
+	const append = (more) => {
+		const fresh = more.filter((line) => line.seq > after.current);
+		if (!fresh.length) return;
+		after.current = fresh.at(-1).seq;
+		// Lines that land together render once.
+		if (pending.current.push(...fresh) === fresh.length) setTimeout(() => {
+			const batch = pending.current.splice(0);
+			setLines((value) => [...value, ...batch]);
+		});
+	};
+	useEffect(() => {
+		if (live && replies) input.current?.focus();
+	}, []);
+	const [visible, setVisible] = useState(true);
+	useEffect(() => {
+		const sync = () => setVisible(document.visibilityState === "visible");
+		sync();
+		addEventListener("visibilitychange", sync);
+		return () => removeEventListener("visibilitychange", sync);
+	}, []);
+	// Logs stream from when the task runs until the stream ends them, which waits for logs still arriving.
+	const [streaming, setStreaming] = useState(live);
+	useEffect(() => {
+		if (live) setStreaming(true);
+	}, [live]);
+	// Each turn's reads apply to it alone: a continue, here or from elsewhere, starts the next.
+	const [round, setRound] = useState(0);
+	const roundNow = useRef(0);
+	roundNow.current = round;
+	const reload = () => {
+		const started = roundNow.current;
+		void client.tasks.get(task.task.id).then(({ logs: _logs, ...full }) => {
+			if (roundNow.current === started) setTask(full);
+		}).catch((reason) => setStatus(reasonText(reason)));
+	};
+	// A running stream follows its own cursor; a stopped page fetches the lines it missed.
+	const catchUp = () => {
+		reload();
+		if (!streaming) setComplete(false);
+	};
+	// A new turn's prompt, from this page or elsewhere; its state comes from the events stream.
+	useEffect(() => {
+		if (!round) return;
+		void client.tasks.get(task.task.id).then(({ turns }) => {
+			if (roundNow.current === round) setTask((current) => taskActive(current) ? {
+				...current,
+				turns
+			} : current);
+		}).catch(() => {});
+	}, [round]);
+	// The head follows the browser's events stream; a finish brings the full task.
+	useTaskEvents(
+		(event) => {
+			if (event.id !== task.task.id || event.deleted) return;
+			if (live && !taskActive(event)) reload();
+			// A new run, even one that finished and was continued between two events.
+			const rerun = live && task.startedAt !== undefined && event.startedAt !== task.startedAt;
+			if (taskActive(event) && (!live || rerun)) {
+				setRound((value) => value + 1);
+				setStreaming(true);
+			}
+			// A turn continued and finished elsewhere while this page heard nothing of it.
+			if (!live && !taskActive(event) && event.finishedAt !== task.finishedAt) {
+				reload();
+				setComplete(false);
+			}
+			setTask((current) => ({
+				...current,
+				status: event.status,
+				approval: event.approval ?? undefined,
+				archivedAt: event.archivedAt,
+				startedAt: event.startedAt,
+				finishedAt: event.finishedAt,
+				...event.result === undefined ? {} : {
+					result: event.result ?? undefined,
+					error: event.error ?? undefined,
+					answer: event.answer ?? undefined
+				}
+			}));
+		},
+		// Missed events: refetch the task and catch up its logs from the cursor.
+		catchUp,
+		() => document.visibilityState === "visible" && catchUp()
+	);
+	// Older lines a chunk at a time, then the stream follows the run.
+	useEffect(() => {
+		if (complete) return;
+		void client.tasks.logs(task.task.id, after.current, LOG_CHUNK).then((more) => {
+			append(more);
+			if (more.length < LOG_CHUNK) setComplete(true);
+		}).catch((reason) => setStatus(reasonText(reason)));
+	}, [complete, lines.length]);
+	// A hidden tab holds no log stream and resumes from its cursor.
+	useEffect(() => {
+		if (!complete || !streaming || !visible) return;
+		const abort = new AbortController();
+		const follow = async () => {
+			while (!abort.signal.aborted) {
+				try {
+					const response = await client.tasks.stream(task.task.id, after.current, abort.signal);
+					if (!response.ok || !response.body) {
+						setStatus("Live updates stopped.");
+						return;
+					}
+					setStatus("");
+					for await (const event of serverEvents(response.body)) {
+						if (abort.signal.aborted) return;
+						if (event.event === "log") append([JSON.parse(event.data)]);
+						else if (event.event === "end") return setStreaming(false);
+					}
+				} catch {
+					if (abort.signal.aborted) return;
+				}
+				setStatus("Reconnecting.");
+				await new Promise((done) => setTimeout(done, 1e3));
+			}
+		};
+		void follow();
+		return () => abort.abort();
+	}, [
+		complete,
+		streaming,
+		visible,
+		round
+	]);
+	const turns = task.turns ?? [{
+		prompt: task.task.prompt ?? task.task.event?.text ?? taskTitle(task),
+		result: task.result,
+		error: task.error,
+		finishedAt: task.finishedAt
+	}];
+	const send = async () => {
+		const text = input.current?.value.trim();
+		if (!text || sending) return;
+		const kind = live ? ask ? "ask" : "steer" : "continue";
+		if (kind === "ask") {
+			// A question never blocks the box: it shows at once and its answer lands under it.
+			input.current.value = "";
+			setSent((value) => [...value, {
+				kind,
+				text,
+				turn: turns.length - 1
+			}]);
+			setAsking((count) => count + 1);
+			void action.run(kind, { question: text }).then((ok) => {
+				setAsking((count) => count - 1);
+				if (ok) return setTab("conversation");
+				setSent((value) => value.filter((message) => message.text !== text || message.kind !== kind));
+			});
+			return;
+		}
+		setSending(true);
+		const ok = await action.run(kind, { text }).finally(() => setSending(false));
+		if (!ok) return;
+		input.current.value = "";
+		if (kind === "continue") {
+			setRound((value) => value + 1);
+			setTask((current) => ({
+				...current,
+				status: "queued",
+				result: undefined,
+				error: undefined,
+				startedAt: undefined,
+				finishedAt: undefined,
+				turns: [...turns.map((turn, index) => index === turns.length - 1 ? {
+					...turn,
+					finishedAt: turn.finishedAt ?? Date.now()
+				} : turn), { prompt: text }]
+			}));
+		} else {
+			setSent((value) => [...value, {
+				kind,
+				text,
+				turn: turns.length - 1
+			}]);
+			setTab("activity");
+		}
+	};
+	// The menu hands focus back to its button as it closes, so the box takes it after.
+	const pickMode = (next) => {
+		setAsk(next);
+		setTimeout(() => input.current?.focus());
+	};
+	const result = task.result;
+	return /* @__PURE__ */ _jsxs(_Fragment, { children: [
+		/* @__PURE__ */ _jsx(TaskHead, {
+			task,
+			tz
+		}),
+		task.fallbacks?.map((fallback, index) => /* @__PURE__ */ _jsxs("p", {
+			class: "flash",
+			role: "status",
+			children: [
+				fallback.engine,
+				" was unavailable. ",
+				fallback.detail,
+				" This task is using ",
+				fallback.next,
+				"."
+			]
+		}, index)),
+		task.approval ? /* @__PURE__ */ _jsx(Approval, { task }) : null,
+		/* @__PURE__ */ _jsx("nav", {
+			class: "tabs",
+			role: "tablist",
+			"aria-label": "Task",
+			children: TABS.map((label) => {
+				const key = label.toLowerCase();
+				return /* @__PURE__ */ _jsx("button", {
+					type: "button",
+					role: "tab",
+					"aria-selected": tab === key,
+					"aria-current": tab === key ? "page" : undefined,
+					onClick: () => setTab(key),
+					children: label
+				}, key);
+			})
+		}),
+		status ? /* @__PURE__ */ _jsx("p", {
+			class: "flash err",
+			role: "status",
+			children: status
+		}) : null,
+		tab === "activity" ? /* @__PURE__ */ _jsx(Activity, {
+			rows,
+			live,
+			tz
+		}) : /* @__PURE__ */ _jsx("div", {
+			class: "convo",
+			children: turns.map((turn, index) => {
+				const last = index === turns.length - 1;
+				return /* @__PURE__ */ _jsxs(Fragment, { children: [
+					/* @__PURE__ */ _jsxs("div", {
+						class: "turn prompt",
+						children: [/* @__PURE__ */ _jsx("p", {
+							class: "who",
+							children: "Prompt"
+						}), /* @__PURE__ */ _jsx(Collapse, {
+							class: "prose",
+							children: turn.prompt
+						})]
+					}),
+					last ? (task.answer ?? []).slice(0, knownAnswers.current).map((answer, index) => /* @__PURE__ */ _jsxs("div", {
+						class: "turn answer",
+						children: [/* @__PURE__ */ _jsx("p", {
+							class: "who",
+							children: "Answer"
+						}), /* @__PURE__ */ _jsx("div", {
+							class: "prose",
+							children: messageOf(answer, "Answer received.")
+						})]
+					}, `a${index}`)) : null,
+					sent.filter((message) => message.turn === index).map((message, index) => {
+						const asked = message.kind === "ask" ? sent.filter((each) => each.kind === "ask").indexOf(message) : -1;
+						const answer = asked < 0 ? undefined : task.answer?.[knownAnswers.current + asked];
+						return /* @__PURE__ */ _jsxs("div", {
+							class: asked < 0 ? "turn you" : "turn you qa",
+							children: [
+								/* @__PURE__ */ _jsx("p", {
+									class: "who",
+									children: message.kind === "ask" ? "You asked" : "You steered"
+								}),
+								/* @__PURE__ */ _jsx("div", {
+									class: "prose",
+									children: message.text
+								}),
+								asked < 0 ? null : /* @__PURE__ */ _jsxs("div", {
+									class: "answer",
+									children: [/* @__PURE__ */ _jsx("p", {
+										class: "who",
+										children: "Answer"
+									}), answer === undefined ? /* @__PURE__ */ _jsx(Loading, {
+										inline: true,
+										dots: true,
+										label: "Answering without interrupting the run."
+									}) : /* @__PURE__ */ _jsx("div", {
+										class: "prose",
+										children: messageOf(answer, "Answer received.")
+									})]
+								})
+							]
+						}, index);
+					}),
+					turn.result ? /* @__PURE__ */ _jsx(Card, {
+						title: "Result",
+						children: /* @__PURE__ */ _jsx(ResultBody, { value: turn.result })
+					}) : last && live ? /* @__PURE__ */ _jsx(Card, {
+						title: "Result",
+						children: /* @__PURE__ */ _jsx("div", {
+							class: "body waiting",
+							children: /* @__PURE__ */ _jsx(Loading, {
+								inline: true,
+								dots: true,
+								label: "The result appears here when the task finishes."
+							})
+						})
+					}) : null,
+					turn.error ? /* @__PURE__ */ _jsx(Card, {
+						tone: "danger",
+						title: "Error",
+						children: /* @__PURE__ */ _jsx("div", {
+							class: "body prose",
+							children: turn.error
+						})
+					}) : null
+				] }, index);
+			})
+		}),
+		replies ? /* @__PURE__ */ _jsx("form", {
+			ref: reply,
+			class: "reply",
+			onSubmit: (event) => {
+				event.preventDefault();
+				void send();
+			},
+			children: /* @__PURE__ */ _jsxs("div", {
+				class: "reply-box",
+				children: [
+					live ? /* @__PURE__ */ _jsxs(Menu, {
+						summary: /* @__PURE__ */ _jsxs(_Fragment, { children: [ask ? "Ask" : "Steer", /* @__PURE__ */ _jsx(Icon, { d: iDown })] }),
+						summaryClass: "mode",
+						label: "Send as",
+						align: "up",
+						wide: true,
+						children: [/* @__PURE__ */ _jsxs("button", {
+							type: "button",
+							class: "pop-item rich",
+							role: "menuitemradio",
+							"aria-checked": !ask,
+							onClick: () => pickMode(false),
+							children: [/* @__PURE__ */ _jsxs("span", {
+								class: "grow",
+								children: ["Steer", /* @__PURE__ */ _jsx("small", { children: "Change course while it works." })]
+							}), /* @__PURE__ */ _jsx(Icon, { d: iCheck })]
+						}), /* @__PURE__ */ _jsxs("button", {
+							type: "button",
+							class: "pop-item rich",
+							role: "menuitemradio",
+							"aria-checked": ask,
+							onClick: () => pickMode(true),
+							children: [/* @__PURE__ */ _jsxs("span", {
+								class: "grow",
+								children: ["Ask", /* @__PURE__ */ _jsx("small", { children: "A question that does not interrupt it." })]
+							}), /* @__PURE__ */ _jsx(Icon, { d: iCheck })]
+						})]
+					}) : null,
+					/* @__PURE__ */ _jsx("textarea", {
+						ref: input,
+						rows: 1,
+						"aria-label": "Message",
+						autofocus: live,
+						placeholder: live ? ask ? "Ask about the run without interrupting it." : "Steer the agent while it works." : "Continue the conversation.",
+						onKeyDown: (event) => {
+							if (event.key !== "Enter" || event.shiftKey || event.isComposing) return;
+							event.preventDefault();
+							void send();
+						}
+					}),
+					/* @__PURE__ */ _jsx("button", {
+						class: "btn sm",
+						disabled: sending,
+						"aria-busy": sending || asking > 0,
+						children: "Send"
+					})
+				]
+			})
+		}) : /* @__PURE__ */ _jsx("p", {
+			class: "muted no-reply",
+			children: "This flow takes no follow-ups."
+		})
+	] });
+}
+/** Lines per request when a task's log loads or follows. */
+export const LOG_CHUNK = 500;

package/dist/dash/standalone/server/modules-server-server-react-server/src/server/dash/app/dash/tasks/composer-data.e2d442d6ecbaa6d3.js

@@ -0,0 +1,63 @@
+import { localServer } from "../../../api/types.0cf02e7714d7c1a2.js";
+import { NO_MODELS, modelsByEngine } from "../settings/model-options.2ca6c87aedf3588c.js";
+export const PLACEHOLDER = "What should the agent do? Type / for flows and reviews.";
+export const CHOICE = {
+	repo: "",
+	cwd: "",
+	agent: "coder",
+	engine: "",
+	model: "",
+	effort: "",
+	permissions: "",
+	runner: ""
+};
+/** The composer's last choice, from its cookie. */
+export function savedChoice(cookie) {
+	const raw = cookie.match(/(?:^|; )compose=([^;]*)/)?.[1];
+	try {
+		return raw ? JSON.parse(decodeURIComponent(raw)) : {};
+	} catch {
+		return {};
+	}
+}
+/** Defaults first, then by name. */
+export const sortedRunners = (rows) => [...rows].sort((a, b) => Number(b.default) - Number(a.default) || a.name.localeCompare(b.name));
+/** Runners as [id, name]; unset is the requester's default, named. */
+export const runnerOptions = (rows) => {
+	const own = rows.find((row) => row.default);
+	return [["", own ? `Default · ${own.name}` : "Default"], ...sortedRunners(rows).filter((row) => row !== own).map((row) => [row.id, row.name])];
+};
+/** Every agent as [id, name]; a failed read leaves the list empty. */
+export const agentChoices = (api) => api.agents.list().then((rows) => (Array.isArray(rows) ? rows : rows.items).map((agent) => [agent.id, agent.name]), () => []);
+/** No credential can run a task yet; a local server runs on the machine's own sign-ins. */
+export const credentialMissing = (api) => Promise.all([api.credentials.list().catch(() => undefined), api.me().catch(() => undefined)]).then(([credentials, me]) => credentials?.length === 0 && !(me && localServer(me)));
+/** What the composer offers and falls back to, read in one go. */
+export async function loadComposer(api, agents = agentChoices(api)) {
+	const [config, catalog, ids, repos, models, runners, flows, folders] = await Promise.all([
+		api.config.get().catch(() => undefined),
+		api.integrations.list().catch(() => []),
+		agents,
+		api.repositories.list().catch(() => []),
+		api.models.list().catch(() => NO_MODELS),
+		api.runners.list().then((rows) => rows.items, () => []),
+		api.flows.list().catch(() => []),
+		api.folders.list().catch(() => undefined)
+	]);
+	const data = {
+		agents: ids,
+		repos: repos.map((entry) => entry.repo),
+		models: modelsByEngine(models),
+		runners: runnerOptions(runners),
+		flows: flows.map((flow) => flow.name),
+		folders
+	};
+	const defaults = {
+		engine: config?.effective.chain?.[0] ?? "claude",
+		engines: config?.effective.engines ?? {}
+	};
+	return {
+		data,
+		defaults,
+		connectLabel: catalog.find((entry) => entry.repositories)?.installLabel ?? "Connect repositories"
+	};
+}