loopable-cli 0.1.0

package/.output/server/_ssr/loops-APFcP0y6.mjs

@@ -0,0 +1,311 @@
+import { n as createServerFn } from "./ssr.mjs";
+import { d as and, f as eq, l as asc, p as inArray, v as sql } from "../_libs/drizzle-orm.mjs";
+import { a as connections, c as loops, h as signals, s as db } from "./client-CKkOfh-s.mjs";
+import { a as connectorManifest, i as connectorAction, s as connectorWorkflow } from "./connections-qnw2GVlP.mjs";
+import { n as agentManifest, r as listAgents } from "./agents-Btql102J.mjs";
+import { t as availableAgentIds } from "./runners-DtXs4Q8a.mjs";
+import { n as enqueueSignal } from "./tasks-vcoodp_D.mjs";
+import { t as createServerRpc } from "./createServerRpc-DPDrnFdH.mjs";
+import { randomUUID } from "node:crypto";
+//#region node_modules/.nitro/vite/services/ssr/assets/loops-APFcP0y6.js
+var NAME_LIMIT = 80;
+var PROMPT_LIMIT = 8e3;
+var GUIDANCE_LIMIT = 4e3;
+function toView(row) {
+	return {
+		id: row.id,
+		name: row.name,
+		enabled: row.enabled,
+		priority: row.priority,
+		connectorId: row.connectorId,
+		workflowId: row.workflowId,
+		settings: row.settings,
+		prompt: row.prompt,
+		guidance: row.guidance,
+		agentId: row.agentId,
+		actionConnectorId: row.actionConnectorId,
+		actionId: row.actionId,
+		actionTarget: row.actionTarget,
+		pollEveryMs: row.pollEveryMs,
+		createdAt: row.createdAt.toISOString(),
+		updatedAt: row.updatedAt.toISOString()
+	};
+}
+/**
+* Only the fields the chosen workflow declares survive, and each is coerced to
+* the kind it was declared as. A stored setting the connector no longer offers
+* would otherwise sit there narrowing things invisibly.
+*/
+function cleanConditions(fields, input) {
+	const cleaned = {};
+	for (const field of fields) {
+		const value = input[field.key];
+		switch (field.kind) {
+			case "boolean":
+				cleaned[field.key] = typeof value === "boolean" ? value : field.default;
+				break;
+			case "string_list":
+				cleaned[field.key] = Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim() !== "") : [];
+				break;
+			case "select":
+				cleaned[field.key] = typeof value === "string" && field.options.some((option) => option.value === value) ? value : field.default;
+				break;
+			default: cleaned[field.key] = typeof value === "string" ? value.trim() : "";
+		}
+	}
+	return cleaned;
+}
+function validate(draft) {
+	const manifest = connectorManifest(draft.connectorId);
+	if (!manifest) throw new Error(`Unknown connector: ${draft.connectorId}`);
+	const workflow = connectorWorkflow(draft.connectorId, draft.workflowId);
+	if (!workflow) throw new Error(`${manifest.name} does not offer ${draft.workflowId}.`);
+	const writer = connectorManifest(draft.actionConnectorId);
+	if (!writer) throw new Error(`Unknown connector: ${draft.actionConnectorId}`);
+	const action = connectorAction(draft.actionConnectorId, draft.actionId);
+	if (!action) throw new Error(`${writer.name} cannot ${draft.actionId}.`);
+	if (draft.agentId && !agentManifest(draft.agentId)) throw new Error(`Unknown agent: ${draft.agentId}`);
+	const name = draft.name.trim();
+	if (!name) throw new Error("Give the loop a name.");
+	if (name.length > NAME_LIMIT) throw new Error(`Keep the name under ${NAME_LIMIT} characters.`);
+	const prompt = draft.prompt.trim();
+	if (!prompt) throw new Error("Say what the agent should do.");
+	if (prompt.length > PROMPT_LIMIT) throw new Error(`Keep what you ask under ${PROMPT_LIMIT} characters.`);
+	const guidance = draft.guidance?.trim() || null;
+	if (guidance && guidance.length > GUIDANCE_LIMIT) throw new Error(`Keep the guidance under ${GUIDANCE_LIMIT} characters.`);
+	if (workflow.runsIn === "folder") {
+		const folder = draft.settings.folder;
+		if (typeof folder !== "string" || folder.trim() === "") throw new Error("Say which folder this should work in.");
+	}
+	return {
+		...draft,
+		name,
+		prompt,
+		guidance,
+		settings: cleanConditions(workflow.settings, draft.settings),
+		actionTarget: cleanConditions(action.target, draft.actionTarget)
+	};
+}
+async function listLoops() {
+	return (await db().select().from(loops).orderBy(asc(loops.priority)).all()).map(toView);
+}
+async function getLoop(id) {
+	const row = await db().select().from(loops).where(eq(loops.id, id)).get();
+	return row ? toView(row) : null;
+}
+async function createLoop(draft) {
+	const checked = validate(draft);
+	const last = await db().select({ value: sql`max(${loops.priority})` }).from(loops).get();
+	const id = randomUUID();
+	await db().insert(loops).values({
+		id,
+		name: checked.name,
+		enabled: checked.enabled,
+		priority: (last?.value ?? 0) + 1,
+		connectorId: checked.connectorId,
+		workflowId: checked.workflowId,
+		settings: checked.settings,
+		prompt: checked.prompt,
+		guidance: checked.guidance,
+		agentId: checked.agentId,
+		actionConnectorId: checked.actionConnectorId,
+		actionId: checked.actionId,
+		actionTarget: checked.actionTarget,
+		pollEveryMs: checked.pollEveryMs
+	}).run();
+	return await getLoop(id);
+}
+async function updateLoop(id, draft) {
+	if (!await getLoop(id)) throw new Error("Loop not found");
+	const checked = validate(draft);
+	await db().update(loops).set({
+		name: checked.name,
+		enabled: checked.enabled,
+		connectorId: checked.connectorId,
+		workflowId: checked.workflowId,
+		settings: checked.settings,
+		prompt: checked.prompt,
+		guidance: checked.guidance,
+		agentId: checked.agentId,
+		actionConnectorId: checked.actionConnectorId,
+		actionId: checked.actionId,
+		actionTarget: checked.actionTarget,
+		pollEveryMs: checked.pollEveryMs,
+		updatedAt: /* @__PURE__ */ new Date()
+	}).where(eq(loops.id, id)).run();
+	return await getLoop(id);
+}
+async function setLoopEnabled(id, enabled) {
+	if (!await getLoop(id)) throw new Error("Loop not found");
+	await db().update(loops).set({
+		enabled,
+		updatedAt: /* @__PURE__ */ new Date()
+	}).where(eq(loops.id, id)).run();
+	return await getLoop(id);
+}
+async function deleteLoop(id) {
+	await db().delete(loops).where(eq(loops.id, id)).run();
+}
+/**
+* The first matching loop wins, so a person has to be able to say which comes
+* first. Swapping with the neighbour keeps that to one obvious gesture.
+*/
+async function moveLoop(id, direction) {
+	const ordered = await db().select().from(loops).orderBy(asc(loops.priority)).all();
+	const index = ordered.findIndex((row) => row.id === id);
+	if (index === -1) throw new Error("Loop not found");
+	const target = direction === "up" ? index - 1 : index + 1;
+	if (target < 0 || target >= ordered.length) return ordered.map(toView);
+	const moving = ordered[index];
+	const neighbour = ordered[target];
+	await db().transaction(async (tx) => {
+		await tx.update(loops).set({ priority: neighbour.priority }).where(eq(loops.id, moving.id)).run();
+		await tx.update(loops).set({ priority: moving.priority }).where(eq(loops.id, neighbour.id)).run();
+	});
+	return await listLoops();
+}
+/**
+* A loop can be written before anything is connected or installed, so the page
+* says what is still missing rather than refusing to save.
+*/
+async function loopReadiness() {
+	const agents = await listAgents();
+	const connected = await db().selectDistinct({ connectorId: connections.connectorId }).from(connections).all();
+	const available = await availableAgentIds();
+	const host = await availableAgentIds(true);
+	const chosen = agents.find((agent) => agent.isDefault)?.agentId ?? null;
+	const defaultAgentId = (chosen && available.includes(chosen) ? chosen : null) ?? (available.length === 1 ? available[0] : null);
+	return {
+		connectedConnectorIds: connected.map((row) => row.connectorId),
+		defaultAgentId,
+		availableAgentIds: available,
+		hostAgentIds: host
+	};
+}
+function toBacklogItem(row) {
+	return {
+		key: row.key,
+		sourceKind: row.sourceKind,
+		sourceRef: row.sourceRef,
+		sourceTitle: row.sourceTitle,
+		sourceUrl: row.sourceUrl,
+		hold: row.hold,
+		seenAt: row.seenAt.toISOString()
+	};
+}
+/**
+* Everything a loop has noticed and never acted on, whether it was already
+* waiting when the loop was made or the connector held it back. They are one
+* list because they are one question: this was asked of you and nothing has
+* happened, do you want it run?
+*/
+var WAITING = ["backlog", "held"];
+/** What the loop page needs to say whether the loop is actually watching. */
+async function loopPollState(loopId) {
+	const loop = await db().select().from(loops).where(eq(loops.id, loopId)).get();
+	const backlog = await db().select().from(signals).where(and(eq(signals.loopId, loopId), inArray(signals.outcome, [...WAITING]))).orderBy(asc(signals.sourceRef)).all();
+	return {
+		polledAt: loop?.polledAt?.toISOString() ?? null,
+		pollError: loop?.pollError ?? null,
+		backlog: backlog.map(toBacklogItem)
+	};
+}
+/**
+* Run everything the loop is holding. Asked for explicitly, because it is the
+* one moment a loop does a month of work at once, and because something held
+* back for being too big is being run against the connector's advice.
+*/
+async function runBacklog(loopId) {
+	const loop = await db().select().from(loops).where(eq(loops.id, loopId)).get();
+	if (!loop) throw new Error("Loop not found");
+	const waiting = await db().select().from(signals).where(and(eq(signals.loopId, loopId), inArray(signals.outcome, [...WAITING]))).all();
+	for (const row of waiting) {
+		const task = await enqueueSignal({
+			loop,
+			signal: {
+				key: row.key,
+				kind: row.sourceKind,
+				ref: row.sourceRef,
+				title: row.sourceTitle,
+				url: row.sourceUrl,
+				payload: row.sourcePayload ?? void 0
+			}
+		});
+		await db().update(signals).set({
+			outcome: "queued",
+			taskId: task.id
+		}).where(and(eq(signals.loopId, loopId), eq(signals.key, row.key))).run();
+	}
+	return waiting.length;
+}
+/**
+* Saving is both making and changing, told apart by whether there is an id.
+* A loop chosen and not yet saved has none, and nothing on the server knew
+* about it until now.
+*/
+var edit = (data) => data;
+var getLoopsPage_createServerFn_handler = createServerRpc({
+	id: "6d5a90e9ec4ebf70d8e2ac4aff960533a5e68d21b289033cc7e0751d00554c93",
+	name: "getLoopsPage",
+	filename: "src/server/functions/loops.ts"
+}, (opts) => getLoopsPage.__executeServer(opts));
+var getLoopsPage = createServerFn({ method: "GET" }).handler(getLoopsPage_createServerFn_handler, async () => ({
+	loops: await listLoops(),
+	readiness: await loopReadiness()
+}));
+var getLoopReadiness_createServerFn_handler = createServerRpc({
+	id: "997d2dd097598c44811fe97def167b79d33e4349c51e783058da648e860c7c1f",
+	name: "getLoopReadiness",
+	filename: "src/server/functions/loops.ts"
+}, (opts) => getLoopReadiness.__executeServer(opts));
+var getLoopReadiness = createServerFn({ method: "GET" }).handler(getLoopReadiness_createServerFn_handler, async () => await loopReadiness());
+var getLoopById_createServerFn_handler = createServerRpc({
+	id: "81a1af559b2a373901872aa9f9a6546f2f3bda8157d81c21a36ba0d1d337613b",
+	name: "getLoopById",
+	filename: "src/server/functions/loops.ts"
+}, (opts) => getLoopById.__executeServer(opts));
+var getLoopById = createServerFn({ method: "GET" }).inputValidator((data) => data).handler(getLoopById_createServerFn_handler, async ({ data }) => await getLoop(data.id));
+var saveLoop_createServerFn_handler = createServerRpc({
+	id: "e91fc2fd51633c7ca9184fea4beb66fe775ed0b4e6323111a4690da916a78b00",
+	name: "saveLoop",
+	filename: "src/server/functions/loops.ts"
+}, (opts) => saveLoop.__executeServer(opts));
+var saveLoop = createServerFn({ method: "POST" }).inputValidator(edit).handler(saveLoop_createServerFn_handler, async ({ data }) => {
+	const { id, ...values } = data;
+	return id ? await updateLoop(id, values) : await createLoop(values);
+});
+var toggleLoop_createServerFn_handler = createServerRpc({
+	id: "3fc8a7de98be979f9820a4f5a0ca2e234ed8a7df8e692abb8c4437765474eca0",
+	name: "toggleLoop",
+	filename: "src/server/functions/loops.ts"
+}, (opts) => toggleLoop.__executeServer(opts));
+var toggleLoop = createServerFn({ method: "POST" }).inputValidator((data) => data).handler(toggleLoop_createServerFn_handler, async ({ data }) => await setLoopEnabled(data.id, data.enabled));
+var removeLoop_createServerFn_handler = createServerRpc({
+	id: "b5a89ca2d07f4ccf2827b5132ca52e7c7a42d584e702b0ab3963b2d5763c35b0",
+	name: "removeLoop",
+	filename: "src/server/functions/loops.ts"
+}, (opts) => removeLoop.__executeServer(opts));
+var removeLoop = createServerFn({ method: "POST" }).inputValidator((data) => data).handler(removeLoop_createServerFn_handler, async ({ data }) => {
+	await deleteLoop(data.id);
+	return await listLoops();
+});
+var reorderLoop_createServerFn_handler = createServerRpc({
+	id: "7d7d5f80a4f0d2b3bb659d7dc2a91ea5983880648b9d1aa24356e7340505930f",
+	name: "reorderLoop",
+	filename: "src/server/functions/loops.ts"
+}, (opts) => reorderLoop.__executeServer(opts));
+var reorderLoop = createServerFn({ method: "POST" }).inputValidator((data) => data).handler(reorderLoop_createServerFn_handler, async ({ data }) => await moveLoop(data.id, data.direction));
+var getLoopPollState_createServerFn_handler = createServerRpc({
+	id: "4fd3855e3e9ed954e102071a55b98d91651c9b1e353161f7223768ed6f2b8c28",
+	name: "getLoopPollState",
+	filename: "src/server/functions/loops.ts"
+}, (opts) => getLoopPollState.__executeServer(opts));
+var getLoopPollState = createServerFn({ method: "GET" }).inputValidator((data) => data).handler(getLoopPollState_createServerFn_handler, async ({ data }) => await loopPollState(data.id));
+var runLoopBacklog_createServerFn_handler = createServerRpc({
+	id: "65494cbfd06143dbd9a012808fbba21163d9902e387869503fb8b68b0674902b",
+	name: "runLoopBacklog",
+	filename: "src/server/functions/loops.ts"
+}, (opts) => runLoopBacklog.__executeServer(opts));
+var runLoopBacklog = createServerFn({ method: "POST" }).inputValidator((data) => data).handler(runLoopBacklog_createServerFn_handler, async ({ data }) => ({ queued: await runBacklog(data.id) }));
+//#endregion
+export { getLoopById_createServerFn_handler, getLoopPollState_createServerFn_handler, getLoopReadiness_createServerFn_handler, getLoopsPage_createServerFn_handler, removeLoop_createServerFn_handler, reorderLoop_createServerFn_handler, runLoopBacklog_createServerFn_handler, saveLoop_createServerFn_handler, toggleLoop_createServerFn_handler };

package/.output/server/_ssr/loops-xt2Bn7_q.mjs

@@ -0,0 +1,222 @@
+import { i as __toESM } from "../_runtime.mjs";
+import { U as require_jsx_runtime, W as require_react } from "../_libs/@base-ui/react+[...].mjs";
+import { f as Link, m as useRouter } from "../_libs/@tanstack/react-router+[...].mjs";
+import { a as connectorManifest, i as connectorAction, s as connectorWorkflow } from "./connections-qnw2GVlP.mjs";
+import { n as agentManifest } from "./agents-Btql102J.mjs";
+import { M as CircleAlert, R as ArrowUp, V as ArrowDown, i as Trash2, u as Plus } from "../_libs/lucide-react.mjs";
+import { n as toast } from "../_libs/sonner.mjs";
+import { C as Button$1, I as Badge, L as Card, O as toggleLoop, R as CardContent, T as reorderLoop, f as useLiveRefresh, s as Route$11, w as removeLoop, z as CardHeader } from "./router-3WmpE5b_.mjs";
+import { t as Switch$1 } from "./switch-ReNglgH6.mjs";
+import { t as ConnectorIcon } from "./connector-icon-DZXQLLFo.mjs";
+import { n as AlertDescription, r as AlertTitle, t as Alert } from "./alert-NEiOCTOl.mjs";
+import { n as issuesFor, t as gapsFor } from "./gaps-RAFSXLZf.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/loops-xt2Bn7_q.js
+var import_react = /* @__PURE__ */ __toESM(require_react());
+var import_jsx_runtime = require_jsx_runtime();
+function LoopsPage() {
+	const { loops, readiness } = Route$11.useLoaderData();
+	useLiveRefresh();
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
+		className: "flex flex-col gap-6",
+		children: [
+			/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("header", {
+				className: "flex items-start gap-4",
+				children: [/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
+					className: "flex-1",
+					children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("h1", {
+						className: "text-2xl font-semibold tracking-tight",
+						children: "Loops"
+					}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
+						className: "mt-1 text-sm text-muted-foreground",
+						children: "Each loop runs one workflow on its own and writes the result back. The first loop that matches something is the one that runs, so order matters."
+					})]
+				}), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Button$1, {
+					render: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Link, { to: "/loops/new" }),
+					children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Plus, {}), "New loop"]
+				})]
+			}),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Gaps, {
+				readiness,
+				loops
+			}),
+			loops.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Card, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(CardContent, {
+				className: "flex flex-col items-center gap-3 py-10 text-center",
+				children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
+					className: "text-sm text-muted-foreground",
+					children: "No loops yet, so nothing is being watched for."
+				}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button$1, {
+					variant: "outline",
+					render: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Link, { to: "/loops/new" }),
+					children: "See what Loopable can do"
+				})]
+			}) }) : null,
+			loops.map((loop, index) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LoopCard, {
+				loop,
+				readiness,
+				position: index + 1,
+				first: index === 0,
+				last: index === loops.length - 1
+			}, loop.id))
+		]
+	});
+}
+/** Says what a loop still needs, without standing in the way of writing one. */
+function Gaps({ readiness, loops }) {
+	const missing = gapsFor(readiness, loops);
+	if (missing.length === 0) return null;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Alert, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(AlertTitle, { children: "Loops can be written, but nothing will run yet" }), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(AlertDescription, {
+		className: "flex flex-col gap-1",
+		children: [missing.map((line) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: line }, line)), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", {
+			className: "mt-1 flex gap-3 text-xs",
+			children: [
+				/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Link, {
+					to: "/connectors",
+					className: "underline",
+					children: "Connectors"
+				}),
+				/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Link, {
+					to: "/agents",
+					className: "underline",
+					children: "Agents"
+				}),
+				/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Link, {
+					to: "/runners",
+					className: "underline",
+					children: "Runners"
+				})
+			]
+		})]
+	})] });
+}
+/**
+* Where this loop writes, in its own words rather than the workflow's. A loop
+* may have been pointed somewhere else since it was made, and the card is the
+* one place someone scanning a list would notice.
+*/
+function writesOf(loop) {
+	const action = connectorAction(loop.actionConnectorId, loop.actionId);
+	if (!action) return `it writes with ${loop.actionId}, which is no longer offered`;
+	const writer = connectorManifest(loop.actionConnectorId);
+	const where = loop.actionConnectorId === loop.connectorId ? "" : ` on ${writer?.name ?? loop.actionConnectorId}`;
+	return `it will ${action.name.toLowerCase()}${where}`;
+}
+function LoopCard({ loop, readiness, position, first, last }) {
+	const router = useRouter();
+	const manifest = connectorManifest(loop.connectorId);
+	const workflow = connectorWorkflow(loop.connectorId, loop.workflowId);
+	const agent = loop.agentId ? agentManifest(loop.agentId) : void 0;
+	const issues = issuesFor(readiness, loop);
+	const [busy, setBusy] = (0, import_react.useState)(false);
+	const run = async (work, message) => {
+		setBusy(true);
+		try {
+			await work();
+			await router.invalidate();
+			if (message) toast.success(message);
+		} catch (error) {
+			toast.error(error instanceof Error ? error.message : String(error));
+		} finally {
+			setBusy(false);
+		}
+	};
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Card, {
+		className: loop.enabled ? void 0 : "opacity-70",
+		children: [/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(CardHeader, {
+			className: "flex flex-row items-start gap-3",
+			children: [
+				/* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
+					className: "mt-0.5 w-5 text-sm text-muted-foreground",
+					children: position
+				}),
+				manifest ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ConnectorIcon, {
+					icon: manifest.icon,
+					accent: manifest.accent
+				}) : null,
+				/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
+					className: "flex-1",
+					children: [
+						/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
+							className: "flex flex-wrap items-center gap-2",
+							children: [
+								/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Link, {
+									to: "/loops/$loopId",
+									params: { loopId: loop.id },
+									className: "font-medium hover:underline",
+									children: loop.name
+								}),
+								loop.enabled ? null : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Badge, {
+									variant: "secondary",
+									children: "Off"
+								}),
+								issues.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Badge, {
+									variant: "outline",
+									children: "Cannot run"
+								}) : null
+							]
+						}),
+						/* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
+							className: "mt-1 text-sm text-muted-foreground",
+							children: workflow ? `When ${workflow.trigger}, ${writesOf(loop)}${agent ? `, using ${agent.name}` : ""}.` : `Built on ${loop.workflowId}, which is no longer offered.`
+						}),
+						issues.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("p", {
+							className: "mt-2 flex items-start gap-1.5 text-xs text-amber-700 dark:text-amber-500",
+							children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(CircleAlert, { className: "mt-0.5 size-3.5 shrink-0" }), issues[0]]
+						}) : null
+					]
+				}),
+				/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
+					className: "flex items-center gap-1",
+					children: [
+						/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button$1, {
+							variant: "ghost",
+							size: "icon",
+							"aria-label": "Move up",
+							disabled: busy || first,
+							onClick: () => run(() => reorderLoop({ data: {
+								id: loop.id,
+								direction: "up"
+							} })),
+							children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ArrowUp, {})
+						}),
+						/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button$1, {
+							variant: "ghost",
+							size: "icon",
+							"aria-label": "Move down",
+							disabled: busy || last,
+							onClick: () => run(() => reorderLoop({ data: {
+								id: loop.id,
+								direction: "down"
+							} })),
+							children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ArrowDown, {})
+						}),
+						/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Switch$1, {
+							checked: loop.enabled,
+							"aria-label": "Enabled",
+							disabled: busy,
+							onCheckedChange: (enabled) => run(() => toggleLoop({ data: {
+								id: loop.id,
+								enabled
+							} }), enabled ? `${loop.name} is on` : `${loop.name} is off`)
+						}),
+						/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button$1, {
+							variant: "ghost",
+							size: "icon",
+							"aria-label": "Delete",
+							disabled: busy,
+							onClick: () => run(() => removeLoop({ data: { id: loop.id } }), `Deleted ${loop.name}`),
+							children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Trash2, {})
+						})
+					]
+				})
+			]
+		}), loop.guidance ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CardContent, {
+			className: "border-t pt-4",
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
+				className: "line-clamp-2 text-sm text-muted-foreground",
+				children: loop.guidance
+			})
+		}) : null]
+	});
+}
+//#endregion
+export { LoopsPage as component };