@tea-agent/loop-agent 0.11.0 → 0.12.0

package/dist/worker/observe/static/router.js

@@ -0,0 +1,85 @@
+/** Hash routing for Observe UI (R5). */
+
+export function parseHashRoute(hashValue) {
+	const hash = (hashValue.replace(/^#/, "") || "/").split("?")[0] || "/";
+	const batchMatch = /^\/batch\/([^/]+)$/.exec(hash);
+	if (batchMatch) {
+		return { view: "batch", batchRunId: decodeURIComponent(batchMatch[1]) };
+	}
+	const runMatch = /^\/run\/([^/]+)$/.exec(hash);
+	if (runMatch) {
+		return { view: "run", workerRunId: decodeURIComponent(runMatch[1]) };
+	}
+	const dagMatch = /^\/dag\/([^/]+)$/.exec(hash);
+	if (dagMatch) {
+		return { view: "dag", dagRunId: decodeURIComponent(dagMatch[1]) };
+	}
+	const taskMatch = /^\/task\/([^/]+)$/.exec(hash);
+	if (taskMatch) {
+		return { view: "task", taskId: decodeURIComponent(taskMatch[1]) };
+	}
+	const featureMatch = /^\/feature\/([^/]+)$/.exec(hash);
+	if (featureMatch) {
+		return {
+			view: "feature",
+			featureId: decodeURIComponent(featureMatch[1]),
+		};
+	}
+	if (hash === "/pool") {
+		return { view: "pool" };
+	}
+	if (hash === "/failures") {
+		return { view: "failures" };
+	}
+	if (hash === "/dags") {
+		return { view: "dashboard", scrollTo: "dags" };
+	}
+	return { view: "dashboard" };
+}
+
+/** Active (non-terminal) statuses sort first; terminals by updatedAt desc. */
+
+export function parseRoute() {
+	return parseHashRouteWithFilters(location.hash);
+}
+
+export function navigate(path) {
+	location.hash = path.startsWith("#") ? path.slice(1) : path;
+}
+
+/**
+ * Parse optional filter query after a hash path: #/pool?status=failed
+ * Returns { filters: { status?, q? } } merged into route; unknown keys ignored.
+ * Base parseHashRoute shape is preserved for all existing views.
+ */
+export function parseHashFilters(hashValue) {
+	const raw = String(hashValue ?? "").replace(/^#/, "");
+	const qIndex = raw.indexOf("?");
+	if (qIndex < 0) return {};
+	const qs = raw.slice(qIndex + 1);
+	const params = new URLSearchParams(qs);
+	const filters = {};
+	const status = params.get("status");
+	const q = params.get("q");
+	if (status) filters.status = status;
+	if (q) filters.q = q;
+	return filters;
+}
+
+export function parseHashRouteWithFilters(hashValue) {
+	const raw = String(hashValue ?? "");
+	const withoutQuery = raw.replace(/^#/, "").split("?")[0];
+	const base = parseHashRoute("#" + (withoutQuery || "/"));
+	const filters = parseHashFilters(raw);
+	if (Object.keys(filters).length === 0) return base;
+	return { ...base, filters };
+}
+
+export function buildHashPath(path, filters = {}) {
+	const base = path.startsWith("#") ? path.slice(1) : path;
+	const params = new URLSearchParams();
+	if (filters.status) params.set("status", filters.status);
+	if (filters.q) params.set("q", filters.q);
+	const qs = params.toString();
+	return qs ? `${base}?${qs}` : base;
+}

package/dist/worker/observe/static/run-processing.js

@@ -0,0 +1,148 @@
+/** Run step/command/artifact processing and task history rows. */
+import {
+	STEP_LABELS,
+	ARTIFACT_LABELS,
+	STEP_ORDER,
+	ARTIFACT_KEYS,
+} from "./constants.js";
+import { badge } from "./format.js";
+import { navigate } from "./router.js";
+
+export function stepDisplayLabel(label) {
+	return STEP_LABELS[label] ?? label;
+}
+
+export function buildStepStates(events) {
+	const states = new Map();
+	for (const ev of events) {
+		if (ev.type === "step.started") {
+			states.set(ev.label, { status: "running", startedAt: ev.at });
+		} else if (ev.type === "step.finished") {
+			states.set(ev.label, {
+				status: ev.status === "failed" ? "failed" : "succeeded",
+				durationMs: ev.durationMs,
+			});
+		}
+	}
+
+	const ordered = [...STEP_ORDER];
+	for (const label of states.keys()) {
+		if (!ordered.includes(label)) ordered.push(label);
+	}
+
+	return ordered.map((label) => {
+		const state = states.get(label);
+		return {
+			label,
+			display: stepDisplayLabel(label),
+			status: state?.status ?? "pending",
+			durationMs: state?.durationMs,
+		};
+	});
+}
+
+export function stepMarker(status) {
+	switch (status) {
+		case "succeeded":
+			return "✓";
+		case "running":
+			return "●";
+		case "failed":
+			return "✗";
+		default:
+			return "○";
+	}
+}
+
+export function getCurrentCommand(events) {
+	const active = new Map();
+	for (const ev of events) {
+		if (ev.type === "command.started") {
+			active.set(ev.label, ev);
+		} else if (ev.type === "command.finished") {
+			active.delete(ev.label);
+		}
+	}
+	let latest = null;
+	for (const cmd of active.values()) {
+		if (!latest || cmd.at > latest.at) latest = cmd;
+	}
+	if (latest?.at) {
+		const elapsed = Date.now() - Date.parse(latest.at);
+		latest = { ...latest, elapsedMs: Number.isFinite(elapsed) ? elapsed : 0 };
+	}
+	return latest;
+}
+
+export function getOutputTail(events, commandLabel) {
+	if (!commandLabel) return "";
+	const chunks = [];
+	for (const ev of events) {
+		if (
+			ev.type === "command.output" &&
+			ev.label === commandLabel &&
+			ev.outputPreview
+		) {
+			chunks.push(ev.outputPreview);
+		}
+	}
+	return chunks.join("");
+}
+
+export function collectArtifacts(task, events) {
+	const arts = new Map();
+	const add = (label, artifactPath) => {
+		if (artifactPath && !arts.has(label)) arts.set(label, artifactPath);
+	};
+
+	if (task?.artifactRefs) {
+		for (const key of ARTIFACT_KEYS) {
+			add(ARTIFACT_LABELS[key] ?? key, task.artifactRefs[key]);
+		}
+	}
+
+	for (const ev of events) {
+		if (!ev.artifactRefs) continue;
+		for (const [key, artifactPath] of Object.entries(ev.artifactRefs)) {
+			add(ARTIFACT_LABELS[key] ?? key, artifactPath);
+		}
+	}
+
+	return arts;
+}
+
+export function findBatchRunIdForTask(snapshot, task) {
+	if (!snapshot || !task) return null;
+	const workerRunId = task.workerRunId;
+	if (!workerRunId) return null;
+	for (const batch of snapshot.batches ?? []) {
+		for (const t of batch.tasks ?? []) {
+			if (t.workerRunId === workerRunId) return batch.batchRunId;
+		}
+	}
+	return null;
+}
+
+export function taskRunHistoryRow(run) {
+	let runLink = run.workerRunId;
+	if (run.workerRunId) {
+		const a = document.createElement("a");
+		a.href = `#/run/${encodeURIComponent(run.workerRunId)}`;
+		a.textContent = run.workerRunId;
+		a.addEventListener("click", (e) => {
+			e.preventDefault();
+			navigate(`#/run/${encodeURIComponent(run.workerRunId)}`);
+		});
+		runLink = a;
+	}
+	return {
+		cells: [
+			runLink,
+			badge(run.status),
+			run.recordedAt ?? run.finishedAt ?? "—",
+			run.batchRunId ?? "—",
+			run.retryOfWorkerRunId ?? "—",
+			run.failureCategory ?? "—",
+		],
+	};
+}

package/dist/worker/observe/static/shell-chrome.js

@@ -0,0 +1,68 @@
+/** Shell chrome: view switching, breadcrumb, header refresh, relation bar. */
+import { UI_TEXT } from "./constants.js";
+import { clearNode, el } from "./dom.js";
+import { formatAgo } from "./format.js";
+import { navigate } from "./router.js";
+import { buildObjectRelations, renderObjectRelationBar } from "./relations.js";
+import { closeDagInspector } from "./views/dag-inspector.js";
+
+export function showView(name) {
+	document.body.dataset.view = name;
+	if (name !== "dag") closeDagInspector();
+	document.querySelectorAll("[data-view]").forEach((section) => {
+		section.hidden = section.dataset.view !== name;
+	});
+	let activeHref = "#/";
+	if (name === "failures") activeHref = "#/failures";
+	else if (name === "pool" || name === "task") activeHref = "#/pool";
+	else if (name === "feature") activeHref = "#/";
+	document.querySelectorAll(".nav-link").forEach((link) => {
+		link.classList.toggle(
+			"nav-link-active",
+			link.getAttribute("href") === activeHref,
+		);
+	});
+}
+
+export function setBreadcrumb(parts) {
+	const nav = document.getElementById("breadcrumb");
+	nav.hidden = parts.length <= 1;
+	clearNode(nav);
+	parts.forEach((part, i) => {
+		if (i > 0) nav.appendChild(document.createTextNode(" / "));
+		if (part.href) {
+			const a = document.createElement("a");
+			a.href = part.href;
+			a.textContent = part.label;
+			a.addEventListener("click", (e) => {
+				e.preventDefault();
+				navigate(part.href);
+			});
+			nav.appendChild(a);
+		} else {
+			nav.appendChild(document.createTextNode(part.label));
+		}
+	});
+}
+
+export function updateHeaderRefresh(generatedAt) {
+	const elRefresh = document.getElementById("header-refresh");
+	if (!elRefresh) return;
+	if (!generatedAt) {
+		elRefresh.textContent = "";
+		return;
+	}
+	elRefresh.textContent = `${formatAgo(generatedAt)} · ${UI_TEXT.nearRealtime}`;
+}
+
+export function mountRelationBar(containerId, ids, snapshot) {
+	const elBar = document.getElementById(containerId);
+	if (!elBar) return;
+	clearNode(elBar);
+	try {
+		const relations = buildObjectRelations(ids, snapshot);
+		elBar.appendChild(renderObjectRelationBar(relations, snapshot));
+	} catch {
+		elBar.appendChild(el("p", "empty", "关联投影暂时不可用。"));
+	}
+}

package/dist/worker/observe/static/state.js

@@ -0,0 +1,253 @@
+/** Shared mutable UI state singleton (Observe UI R5). */
+import {
+	ACTIVE_DETAIL_POLL_MS,
+	HIDDEN_POLL_MS,
+	DASHBOARD_POLL_MS,
+	TERMINAL_RUN_STATUSES,
+	OUTPUT_FOLLOW_LATEST_PX,
+} from "./constants.js";
+import { clearNode, el } from "./dom.js";
+
+/**
+ * Single mutable ownership bag. Import `{ uiState }` and mutate properties.
+ * Never assign through `import * as ns` live bindings (Chrome TypeError).
+ */
+export const uiState = {
+	dashboardTimer: null,
+	runPollTimer: null,
+	dagPollTimer: null,
+	poolTimer: null,
+	taskPollTimer: null,
+	runEventOffset: 0,
+	runEvents: [],
+	currentRunId: null,
+	currentBatchRunId: null,
+	currentDagRunId: null,
+	selectedDagNodeId: null,
+	sessionEventOffset: 0,
+	sessionEvents: [],
+	lastSnapshot: null,
+	dagInspectorOpen: false,
+	dagInspectorTab: "output",
+	dagInspectorWidth: null,
+	dagGraphViewportState: null,
+	dagTimelineViewportState: null,
+	dagNodeOutputViewportState: null,
+	runOutputViewportState: null,
+	pollingGeneration: 0,
+};
+
+/** Per-dagRunId graph viewport restore map (stable Map instance). */
+export const dagGraphViewportStates = new Map();
+
+export function isPageVisible() {
+	return (
+		typeof document === "undefined" || document.visibilityState !== "hidden"
+	);
+}
+
+export function detailPollDelay(status, isVisible) {
+	const normalizedStatus = (status ?? "").toLowerCase().replace(/-/g, "_");
+	if (TERMINAL_RUN_STATUSES.has(normalizedStatus)) return null;
+	return isVisible ? ACTIVE_DETAIL_POLL_MS : HIDDEN_POLL_MS;
+}
+
+export function dashboardPollDelay() {
+	return isPageVisible() ? DASHBOARD_POLL_MS : HIDDEN_POLL_MS;
+}
+
+export function updateDagGraphViewportState(
+	_previous,
+	dagRunId,
+	scrollLeft,
+	scrollTop,
+) {
+	return {
+		dagRunId,
+		scrollLeft: Math.max(0, Number(scrollLeft) || 0),
+		scrollTop: Math.max(0, Number(scrollTop) || 0),
+	};
+}
+
+export function captureDagGraphViewportState(previous, dagRunId, viewport) {
+	if (!viewport || viewport.dataset?.dagRunId !== dagRunId) return previous;
+	return updateDagGraphViewportState(
+		previous,
+		dagRunId,
+		viewport.scrollLeft,
+		viewport.scrollTop,
+	);
+}
+
+export function updateDagTimelineViewportState(
+	_previous,
+	dagRunId,
+	nodeId,
+	scrollLeft,
+	scrollTop,
+	followLatest,
+) {
+	return {
+		dagRunId,
+		nodeId,
+		scrollLeft: Math.max(0, Number(scrollLeft) || 0),
+		scrollTop: Math.max(0, Number(scrollTop) || 0),
+		followLatest: Boolean(followLatest),
+	};
+}
+
+// Unified follow-latest helper for DAG node output and Worker output scroll
+// regions. Returns true only when the user is parked within `threshold` px of
+// the bottom, mirroring the existing process-timeline behaviour.
+export function computeFollowLatest(
+	scrollTop,
+	scrollHeight,
+	clientHeight,
+	threshold = OUTPUT_FOLLOW_LATEST_PX,
+) {
+	const top = Number(scrollTop);
+	const height = Number(scrollHeight);
+	const client = Number(clientHeight);
+	if (
+		!Number.isFinite(top) ||
+		!Number.isFinite(height) ||
+		!Number.isFinite(client)
+	) {
+		return false;
+	}
+	if (height <= 0 || client <= 0) return false;
+	return height - top - client < Math.max(0, Number(threshold) || 0);
+}
+
+// Generalised viewport-state record keyed by `regionKey`, so the same helper
+// serves the DAG node inspector output ("dag:<runId>:<nodeId>:output") and the
+// Worker run output ("run:<runId>:output").
+export function updateDagOutputViewportState(
+	_previous,
+	regionKey,
+	scrollLeft,
+	scrollTop,
+	followLatest,
+) {
+	return {
+		regionKey,
+		scrollLeft: Math.max(0, Number(scrollLeft) || 0),
+		scrollTop: Math.max(0, Number(scrollTop) || 0),
+		followLatest: Boolean(followLatest),
+	};
+}
+
+// Poll-render decision helpers. Initial paints always rebuild the shell; a
+// non-initial refresh reuses the existing viewport/inspector DOM identity so
+// active pointer-capture targets (scrollbar / resize handle) survive.
+export function shouldReuseDagDetailShell(initial, hasExistingViewport) {
+	return !initial && Boolean(hasExistingViewport);
+}
+
+export function shouldPreserveDiagnosticsOpen(initial, existingOpen) {
+	if (initial) return false;
+	return Boolean(existingOpen);
+}
+
+// Detects an in-progress resize/scroll gesture so the poll renderer can defer
+// tearing down the interactive shell until the gesture releases.
+export function isInteractiveGestureActive(bodyClassList) {
+	const list = bodyClassList;
+	if (!list || typeof list.contains !== "function") return false;
+	return (
+		list.contains("is-resizing-dag-inspector") ||
+		list.contains("is-resizing-dag-graph")
+	);
+}
+
+export function stopTimers() {
+	uiState.pollingGeneration += 1;
+	if (uiState.dashboardTimer) {
+		clearTimeout(uiState.dashboardTimer);
+		uiState.dashboardTimer = null;
+	}
+	if (uiState.runPollTimer) {
+		clearTimeout(uiState.runPollTimer);
+		uiState.runPollTimer = null;
+	}
+	if (uiState.dagPollTimer) {
+		clearTimeout(uiState.dagPollTimer);
+		uiState.dagPollTimer = null;
+	}
+	if (uiState.poolTimer) {
+		clearTimeout(uiState.poolTimer);
+		uiState.poolTimer = null;
+	}
+	if (uiState.taskPollTimer) {
+		clearTimeout(uiState.taskPollTimer);
+		uiState.taskPollTimer = null;
+	}
+	uiState.currentRunId = null;
+	uiState.currentBatchRunId = null;
+	uiState.currentDagRunId = null;
+	uiState.selectedDagNodeId = null;
+	uiState.sessionEventOffset = 0;
+	uiState.sessionEvents = [];
+	uiState.runEventOffset = 0;
+	uiState.runEvents = [];
+}
+
+/** Pure descriptor for loading / empty / degraded / error (REQ-R5-05). */
+export function viewStateDescriptor(kind, message, options = {}) {
+	const classByKind = {
+		loading: "view-state view-state-loading",
+		empty: "view-state view-state-empty empty",
+		degraded: "view-state view-state-degraded projection-fault",
+		error: "view-state view-state-error",
+	};
+	const role =
+		kind === "error" || kind === "degraded"
+			? "alert"
+			: kind === "loading"
+				? "status"
+				: null;
+	return {
+		kind,
+		className: classByKind[kind] ?? "view-state",
+		role,
+		ariaLive: kind === "loading" ? "polite" : null,
+		message: message ?? "",
+		detail: options.detail ?? null,
+		messageClass:
+			kind === "empty" ? "empty" : kind === "loading" ? "muted" : null,
+	};
+}
+
+/** Distinguishable loading / empty / degraded / error panel states (REQ-R5-05). */
+export function renderViewState(kind, message, options = {}) {
+	const desc = viewStateDescriptor(kind, message, options);
+	const node = el("div", desc.className);
+	if (desc.role) node.setAttribute("role", desc.role);
+	if (desc.ariaLive) node.setAttribute("aria-live", desc.ariaLive);
+	node.appendChild(el("p", desc.messageClass, desc.message));
+	if (desc.detail) {
+		node.appendChild(el("p", "muted", desc.detail));
+	}
+	return node;
+}
+
+export function mountViewState(container, kind, message, options) {
+	if (!container) return null;
+	clearNode(container);
+	const node = renderViewState(kind, message, options);
+	container.appendChild(node);
+	return node;
+}
+
+export function setLastSnapshot(snapshot) {
+	uiState.lastSnapshot = snapshot;
+}
+
+export function setPollingGeneration(value) {
+	uiState.pollingGeneration = value;
+}
+
+export function bumpPollingGeneration() {
+	uiState.pollingGeneration += 1;
+	return uiState.pollingGeneration;
+}