@wular/coder 0.4.6 → 0.4.8

package/dist/dash/standalone/server/modules-server-server-react-server/src/server/dash/app/dash/[org]/tasks/[id]/task-view.8a5908c42647923f.js

@@ -0,0 +1,604 @@
+"use client";
+import "./task-view.38b1b7ef3976ba71.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.8e150ef2bc6a5f4e.js";
+import { LogView } from "../../../../../../../core/task/log-view.871cbff2605b5cfd.js";
+import { client } from "../../../../../utils/client.d25e6dcc6704eb60.js";
+import { formatDate, formatDuration, reasonText } from "../../../../../utils/format.6a7d1beaf4d09d9c.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 { useOrg } from "../../../../../comps/nav/org.813dc34bd23a336f.js";
+import { iAgent, iCheck, iClock, iDown, iFolder, iPlug, iRight, iTerminal } from "../../../../../comps/ui/icons.868385119bf2de28.js";
+import { Badge } from "../../../../../comps/ui/badge.3d9163a51e6f6d6e.js";
+import { Card, Loading } from "../../../../../comps/ui/card.6227f43fc0ae4bd1.js";
+import { Collapse } from "../../../../../comps/ui/collapse.dab7f208cbbe6a33.js";
+import { Icon } from "../../../../../comps/ui/icon.0874ca2f58f7db14.js";
+import { Menu } from "../../../../../comps/ui/menu.0f064f75822888be.js";
+import { Back, PageHead } from "../../../../../comps/frame/page-head.e5d2185c1cdac740.js";
+import { backFrom } from "../../../../../comps/frame/heads.20414ddcb2d08bcd.js";
+import { markdown } from "../../agents/agent/instructions.6558ffd02a59ad53.js";
+import { Status } from "../list/status.16190fdd5fd7daad.js";
+import { folderName, sourceLabel, taskActive, taskTitle } from "../list/task.af5001e51d2f612b.js";
+import { useAction } from "../../../../../utils/action.568346602027ac74.js";
+import { Approval, TaskActions } from "./task-actions.ece7ec732352ce70.js";
+import { Activity, RunPreview, runSummary } from "./activity.ed49ee2686d1ee41.js";
+import { toastError, useTaskEvents, watchTask } from "../../../../../comps/frame/task-toasts.4282affa47415a36.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();
+	const org = useOrg();
+	return /* @__PURE__ */ _jsx(Back, {
+		...backFrom(search.get("from"), {
+			href: "/dash/[org]/tasks",
+			params: { org },
+			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 org = useOrg();
+	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/[org]/agents/[slug]",
+					params: {
+						org,
+						slug: task.task.agent
+					},
+					search: { from: `/dash/${org}/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 [at, setAt] = useState();
+	const [sent, setSent] = useState([]);
+	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 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 sender = useAction({ toast: "Not sent" });
+	const asker = useAction({ toast: "Not sent" });
+	const sending = Boolean(sender.pending);
+	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]);
+	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);
+	// 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) return;
+			setTask(full);
+			if (taskActive(full)) setStreaming(true);
+		}).catch((reason) => toastError("Task not refreshed", 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.
+	const nextRound = () => {
+		const next = ++roundNow.current;
+		setRound(next);
+		setStreaming(true);
+		void client.tasks.get(task.task.id).then(({ turns }) => {
+			if (roundNow.current === next) setTask((current) => taskActive(current) ? {
+				...current,
+				turns
+			} : current);
+		}).catch((reason) => console.error("coder dashboard: task turns", reason));
+	};
+	// 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)) nextRound();
+			// 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
+	);
+	// 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) => toastError("Activity not loaded", 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) {
+						toastError("Live updates stopped", "Reload the page to see new activity.");
+						return;
+					}
+					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;
+				}
+				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);
+			setTab("conversation");
+			void asker.run(kind, () => client.tasks.ask(task.task.id, text)).then((ok) => {
+				setAsking((count) => count - 1);
+				if (!ok) setSent((value) => value.filter((message) => message.text !== text || message.kind !== kind));
+			});
+			return;
+		}
+		const ok = await sender.run(kind, () => client.tasks.steer(task.task.id, text));
+		if (!ok) return;
+		input.current.value = "";
+		if (kind === "continue") {
+			nextRound();
+			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
+			}]);
+			openActivity();
+		}
+	};
+	const openActivity = (to) => {
+		setAt(to);
+		setTab("activity");
+	};
+	const activityLink = /* @__PURE__ */ _jsxs("button", {
+		type: "button",
+		class: "btn ghost sm",
+		onClick: () => openActivity("end"),
+		children: ["Activity", /* @__PURE__ */ _jsx(Icon, { d: iRight })]
+	});
+	const run = rows.filter((row) => row.at >= (task.startedAt ?? 0));
+	const foot = !live && task.startedAt && task.finishedAt ? /* @__PURE__ */ _jsxs("p", {
+		class: "run-foot",
+		children: [runSummary(run, task.finishedAt - task.startedAt), activityLink]
+	}) : null;
+	// 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)),
+		/* @__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: () => key === "activity" ? openActivity() : setTab(key),
+					children: label
+				}, key);
+			})
+		}),
+		tab === "activity" ? /* @__PURE__ */ _jsx(Activity, {
+			rows,
+			live,
+			tz,
+			at
+		}) : /* @__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__ */ _jsxs(Card, {
+						title: "Result",
+						children: [/* @__PURE__ */ _jsx(ResultBody, { value: turn.result }), last ? foot : null]
+					}) : last && live ? /* @__PURE__ */ _jsx(Card, {
+						title: "Result",
+						actions: activityLink,
+						children: /* @__PURE__ */ _jsx(RunPreview, {
+							rows: run,
+							startedAt: task.startedAt,
+							onOpen: openActivity
+						})
+					}) : null,
+					turn.error ? /* @__PURE__ */ _jsxs(Card, {
+						tone: "danger",
+						title: "Error",
+						children: [/* @__PURE__ */ _jsx("div", {
+							class: "body prose",
+							children: turn.error
+						}), last && !turn.result ? foot : null]
+					}) : 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."
+		}),
+		/* @__PURE__ */ _jsx("div", {
+			class: "approval-dock",
+			children: task.approval ? /* @__PURE__ */ _jsx(Approval, { task }) : null
+		})
+	] });
+}
+/** 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/[org]/tasks/composer-data.ff108c0ef82a4d7b.js

@@ -0,0 +1,69 @@
+import { localServer } from "../../../../api/types.9f59e6c761d6aac4.js";
+import { modelsByEngine } from "../settings/model-options.2eacf7f8ac0032df.js";
+import { DEFAULT_ENGINE } from "../../../../../../core/defaults.e6ce0944639198a2.js";
+export const PLACEHOLDER = "What should the agent do? Type / for flows and reviews.";
+export const CHOICE = {
+	repo: "",
+	cwd: "",
+	agent: "",
+	engine: "",
+	model: "",
+	effort: "",
+	permissions: "",
+	runner: ""
+};
+/** No agent picked yet, or one this workspace no longer runs, falls back to the server's default agent, else the first. */
+export function usableAgent(choice, lists) {
+	const ids = lists.agents.map(([id]) => id);
+	if (!ids.length || ids.includes(choice.agent)) return choice;
+	return {
+		...choice,
+		agent: lists.defaultAgent ?? ids[0]
+	};
+}
+/** 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])];
+};
+/** 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({
+	cursor: "",
+	limit: 1,
+	fields: "id"
+}).catch(() => undefined), api.me().catch(() => undefined)]).then(([credentials, me]) => credentials?.items.length === 0 && !(me && localServer(me)));
+/** What the composer offers and falls back to, read in one request. */
+export async function loadComposer(api) {
+	const options = await api.composer();
+	const preferred = options.agents.find((agent) => agent.default)?.id;
+	const data = {
+		agents: options.agents.map(({ id, name }) => [id, name]),
+		...preferred ? { defaultAgent: preferred } : {},
+		// Built-in agents always exist, so an empty list means every agent is disabled.
+		...options.agents.length ? {} : { agentsOff: true },
+		models: modelsByEngine(options.models),
+		runners: runnerOptions(options.runners),
+		flows: options.flows,
+		folders: options.folders
+	};
+	const defaults = {
+		engine: options.engine ?? DEFAULT_ENGINE,
+		engines: options.engines
+	};
+	return {
+		data,
+		defaults,
+		connectLabel: options.connectLabel ?? "Connect repositories"
+	};
+}