@abot-ai/runtime 1.1.0 → 1.3.0

package/dist/src/web-ui/app/lib/dashboard-presentation.js

@@ -0,0 +1,126 @@
+import { formatTime, textOf } from "./text-format.js";
+import { isSessionReadStateUnavailable } from "./session-read-state.js";
+
+function timestampValue(value) {
+  if (value === null || value === undefined || value === "") return 0;
+  const normalized =
+    typeof value === "string" && /^\d+$/u.test(value) ? Number(value) : value;
+  const timestamp = new Date(normalized).getTime();
+  return Number.isFinite(timestamp) ? timestamp : 0;
+}
+
+function dashboardKnownUnreadCount(session) {
+  const count = Number(session.unreadCount);
+  if (Number.isFinite(count) && count > 0) return Math.floor(count);
+  return session.hasUnread === true ? 1 : 0;
+}
+
+export function dashboardUnreadCount(session) {
+  if (isSessionReadStateUnavailable(session)) return null;
+  return dashboardKnownUnreadCount(session);
+}
+
+function compareConversationRecency(left, right) {
+  return timestampValue(right.updatedAt) - timestampValue(left.updatedAt);
+}
+
+export function projectDashboardConversations(sessions = [], recentLimit = 6) {
+  const unique = new Map();
+  for (const session of [...sessions].sort(compareConversationRecency)) {
+    const id = textOf(session.id);
+    if (!id || unique.has(id)) continue;
+    unique.set(id, {
+      id,
+      title: textOf(session.displayName || session.title || id),
+      preview: textOf(session.lastMessagePreview),
+      updatedAt: session.updatedAt,
+      unreadCount: dashboardUnreadCount(session),
+      readStateUnavailable: isSessionReadStateUnavailable(session),
+      hasKnownUnreadMessages: dashboardKnownUnreadCount(session) > 0,
+    });
+  }
+  const conversations = [...unique.values()];
+  const unread = conversations.filter(
+    (session) => session.hasKnownUnreadMessages,
+  );
+  const read = conversations.filter(
+    (session) => !session.hasKnownUnreadMessages,
+  );
+  const availableReadSlots = Math.max(0, recentLimit - unread.length);
+  return {
+    conversations: [...unread, ...read.slice(0, availableReadSlots)],
+    totalCount: conversations.length,
+    hasUnavailableReadState: conversations.some(
+      (session) => session.readStateUnavailable,
+    ),
+    unreadCount: unread.reduce(
+      (total, session) => total + (session.unreadCount ?? 0),
+      0,
+    ),
+  };
+}
+
+const runOutcomes = {
+  pending: { label: "Waiting to run", tone: "neutral" },
+  running: { label: "Running", tone: "active" },
+  succeeded: { label: "Completed", tone: "success" },
+  failed: { label: "Failed", tone: "failed" },
+  cancelled: { label: "Cancelled", tone: "neutral" },
+  interrupted: { label: "Interrupted", tone: "failed" },
+  missed: { label: "Missed", tone: "neutral" },
+};
+
+function activityTimestamp(run) {
+  return run.scheduledAt;
+}
+
+export function projectDashboardActivity(runs = [], limit = 6) {
+  const ordered = [...runs].sort(
+    (left, right) =>
+      timestampValue(activityTimestamp(right)) -
+      timestampValue(activityTimestamp(left)),
+  );
+  const unique = new Map();
+  for (const run of ordered) {
+    const id = textOf(run.id);
+    if (!id || unique.has(id)) continue;
+    const outcome = runOutcomes[run.status] || {
+      label: "Status unavailable",
+      tone: "neutral",
+    };
+    unique.set(id, {
+      id,
+      title: textOf(run.title) || "Scheduled task",
+      sessionId: textOf(run.sessionId),
+      requestId: textOf(run.requestId),
+      timestamp: activityTimestamp(run),
+      statusLabel: outcome.label,
+      tone: outcome.tone,
+    });
+  }
+  return [...unique.values()].slice(0, limit);
+}
+
+export function dashboardTimePresentation(value, now = Date.now()) {
+  const timestamp = timestampValue(value);
+  if (!timestamp) return null;
+  const elapsed = now - timestamp;
+  const date = new Date(timestamp);
+  const presentation = {
+    dateTime: date.toISOString(),
+    title: formatTime(timestamp),
+    label: date.toLocaleDateString(undefined, {
+      month: "short",
+      day: "numeric",
+    }),
+  };
+  if (elapsed < 0) return { ...presentation, label: formatTime(timestamp) };
+  if (elapsed < 60000) return { ...presentation, label: "Just now" };
+  if (elapsed < 3600000)
+    return { ...presentation, label: `${Math.floor(elapsed / 60000)}m ago` };
+  if (elapsed < 86400000)
+    return { ...presentation, label: `${Math.floor(elapsed / 3600000)}h ago` };
+  if (elapsed < 604800000)
+    return { ...presentation, label: `${Math.floor(elapsed / 86400000)}d ago` };
+  return presentation;
+}

package/dist/src/web-ui/app/lib/event-presentation.js

@@ -1,5 +1,15 @@
 import { textOf } from "./text-format.js";
 
+function canMergeEventTimelineEntries(previous, event, name, summary) {
+  if (!previous) return false;
+  if (previous.name !== name) return false;
+  if (previous.summary !== summary) return false;
+  if (previous.tone !== event.tone) return false;
+  if (textOf(previous.requestId) !== textOf(event.requestId)) return false;
+  if (textOf(previous.stage) !== textOf(event.stage)) return false;
+  return textOf(previous.phase) === textOf(event.phase);
+}
+
 export function buildEventTimelineEntries(events) {
   const entries = [];
   for (const event of events) {
@@ -7,13 +17,15 @@ export function buildEventTimelineEntries(events) {
     if (!name) continue;
     const summary = textOf(event.summary);
     const previous = entries[entries.length - 1];
-    if (
-      previous &&
-      previous.name === name &&
-      previous.summary === summary &&
-      previous.tone === event.tone
-    ) {
+    if (canMergeEventTimelineEntries(previous, event, name, summary)) {
       previous.count = (previous.count || 1) + (event.count || 1);
+      if (typeof event.eventSequence === "number")
+        previous.eventSequence = Math.max(
+          previous.eventSequence ?? 0,
+          event.eventSequence,
+        );
+      if (typeof event.lastSeqNo === "number")
+        previous.lastSeqNo = event.lastSeqNo;
       continue;
     }
     entries.push({
@@ -241,8 +253,17 @@ export function eventKeyFor(message, label, tone) {
   const tool = textOf(message.tool);
   const approvalId = textOf(message.approvalId);
   const status = textOf(message.status);
+  const stage = textOf(message.stage);
   const phase = textOf(message.phase);
-  return [requestId, name, label, tone, tool, approvalId, status, phase]
-    .filter(Boolean)
-    .join("|");
+  return JSON.stringify([
+    requestId,
+    name,
+    label,
+    tone,
+    tool,
+    approvalId,
+    status,
+    stage,
+    phase,
+  ]);
 }

package/dist/src/web-ui/app/lib/message-markdown.d.ts

@@ -0,0 +1,5 @@
+export declare function renderMarkdown(raw: unknown): string;
+export declare function extractMessageLinks(raw: unknown): Array<{
+  url: string;
+  label: string;
+}>;

package/dist/src/web-ui/app/lib/message-markdown.js

@@ -0,0 +1,99 @@
+import MarkdownIt from "../vendor/markdown-it.js";
+import { safeLinkHref } from "./message-url-policy.js";
+import { parseWebSourceUrl } from "./source-url-policy.js";
+
+const markdown = new MarkdownIt({
+  html: false,
+  breaks: true,
+  linkify: true,
+  typographer: false,
+});
+
+markdown.linkify.set({ fuzzyLink: true });
+
+// Leave parsing to the Markdown grammar, then apply the stricter display
+// policy. Rejecting a valid Markdown token during parsing can make linkify
+// reinterpret only a fragment of its destination as an unrelated URL.
+markdown.renderer.rules.link_open = (tokens, index, options, env, renderer) => {
+  const token = tokens[index];
+  if (!safeLinkHref(token.attrGet("href"))) {
+    const closing = tokens
+      .slice(index + 1)
+      .find((item) => item.type === "link_close");
+    if (closing) closing.hidden = true;
+    return "";
+  }
+  token.attrSet("target", "_blank");
+  token.attrSet("rel", "noopener noreferrer");
+  return renderer.renderToken(tokens, index, options);
+};
+markdown.renderer.rules.table_open = () =>
+  '<div class="markdown-table-scroll" role="region" aria-label="Message table" tabindex="0"><table>\n';
+markdown.renderer.rules.table_close = () => "</table></div>\n";
+
+function isImageInsideLink(tokens, index) {
+  const boundary = tokens
+    .slice(0, index)
+    .findLast(
+      (token) => token.type === "link_open" || token.type === "link_close",
+    );
+  return boundary?.type === "link_open";
+}
+
+// Remote images use the bounded preview path too: rendering a message must
+// never issue an unchecked image request to an arbitrary host.
+markdown.renderer.rules.image = (tokens, index) => {
+  const token = tokens[index];
+  const label = markdown.utils.escapeHtml(token.content || "Image");
+  if (isImageInsideLink(tokens, index)) return label;
+  const href = safeLinkHref(token.attrGet("src"));
+  if (!href) return label;
+  return `<a href="${markdown.utils.escapeHtml(href)}" target="_blank" rel="noopener noreferrer">${label}</a>`;
+};
+
+function messageSource(raw) {
+  if (typeof raw === "string") return raw;
+  if (typeof raw === "number" || typeof raw === "boolean") return String(raw);
+  return "";
+}
+
+export function renderMarkdown(raw) {
+  return markdown.render(messageSource(raw));
+}
+
+function inlineLinkLabel(tokens, start) {
+  const label = [];
+  for (let index = start + 1; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token.type === "link_close") break;
+    if (token.content) label.push(token.content);
+  }
+  return label.join("");
+}
+
+export function extractMessageLinks(raw) {
+  const links = [];
+  const seen = new Set();
+  const blocks = markdown.parse(messageSource(raw), {});
+  for (const block of blocks) {
+    if (block.type !== "inline") continue;
+    const tokens = block.children || [];
+    for (const [index, token] of tokens.entries()) {
+      const isImage = token.type === "image";
+      if (token.type !== "link_open" && !isImage) continue;
+      if (isImage && isImageInsideLink(tokens, index)) continue;
+      const url = parseWebSourceUrl(token.attrGet(isImage ? "src" : "href"));
+      if (!url) continue;
+      const key = new URL(url.href);
+      key.hash = "";
+      if (seen.has(key.href)) continue;
+      seen.add(key.href);
+      links.push({
+        url: url.href,
+        label: isImage ? token.content : inlineLinkLabel(tokens, index),
+      });
+      if (links.length === 3) return links;
+    }
+  }
+  return links;
+}

package/dist/src/web-ui/app/lib/message-url-policy.d.ts

@@ -0,0 +1 @@
+export declare function safeLinkHref(value: unknown, baseHref?: string): string;

package/dist/src/web-ui/app/lib/message-url-policy.js

@@ -0,0 +1,13 @@
+export function safeLinkHref(value, baseHref = globalThis.location?.href) {
+  if (typeof value !== "string" || !value.trim()) return "";
+  if (value.length > 4_096 || /[\u0000-\u0020\u007f]/u.test(value)) return "";
+  try {
+    const url = new URL(value, baseHref);
+    if (url.username || url.password) return "";
+    if (url.protocol === "http:" || url.protocol === "https:") return url.href;
+    if (url.protocol === "mailto:") return url.href;
+    return "";
+  } catch {
+    return "";
+  }
+}

package/dist/src/web-ui/app/lib/schedule-errors.js

@@ -0,0 +1,29 @@
+const SCHEDULE_ERRORS = {
+  scheduler_store_in_use:
+    "Schedules are being managed by another ABot process. This window cannot access them right now.",
+  scheduler_unavailable: "The scheduling service is not available right now.",
+  scheduler_stopped:
+    "The scheduling service has stopped. Reconnect after ABot starts again.",
+  scheduler_job_not_found:
+    "This schedule is no longer available. Refresh the list to see current schedules.",
+  scheduler_job_cancelled:
+    "This schedule has been cancelled and cannot run again.",
+  scheduler_session_deleted: "The conversation for this schedule was deleted.",
+  scheduler_session_not_found:
+    "The conversation for this schedule is no longer available.",
+  scheduler_model_required: "Choose a model for this schedule.",
+  scheduler_model_unavailable:
+    "The saved model is unavailable. Choose another configured model.",
+  scheduler_schedule_in_past: "Choose a date and time in the future.",
+};
+
+export function scheduleErrorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error || "");
+  const [code, ...details] = message.split(":");
+  if (SCHEDULE_ERRORS[code]) return SCHEDULE_ERRORS[code];
+  if (details.length && code.startsWith("scheduler_"))
+    return details.join(":").trim();
+  if (/^[a-z][a-z0-9]*_[a-z0-9_]+$/.test(message))
+    return "This schedule request could not be completed. Refresh and try again.";
+  return message || "Schedules could not be loaded. Refresh and try again.";
+}

package/dist/src/web-ui/app/lib/schedule-message.js

@@ -0,0 +1,30 @@
+import { textOf } from "./text-format.js";
+
+export function normalizeScheduleReference(raw) {
+  if (!raw || typeof raw !== "object") return undefined;
+  const jobId = textOf(raw.jobId).trim();
+  const runId = textOf(raw.runId).trim();
+  if (!jobId || !runId) return undefined;
+  return {
+    jobId,
+    runId,
+    title: textOf(raw.title).trim() || "Scheduled task",
+    scheduledAt: textOf(raw.scheduledAt),
+    triggerType: textOf(raw.triggerType),
+  };
+}
+
+export function scheduleTimeLabel(value, timeZone) {
+  if (!value) return "—";
+  const date = new Date(value);
+  if (!Number.isFinite(date.getTime())) return "—";
+  try {
+    return new Intl.DateTimeFormat(undefined, {
+      dateStyle: "medium",
+      timeStyle: "short",
+      ...(timeZone ? { timeZone } : {}),
+    }).format(date);
+  } catch {
+    return date.toISOString();
+  }
+}

package/dist/src/web-ui/app/lib/schedule-presentation.js

@@ -0,0 +1,81 @@
+import { scheduleTimeLabel } from "./schedule-message.js";
+export { scheduleErrorMessage } from "./schedule-errors.js";
+
+export const SCHEDULE_WEEKDAYS = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday",
+];
+
+export function scheduleDurationLabel(milliseconds) {
+  const minutes = milliseconds / 60000;
+  if (minutes % 1440 === 0) return `${minutes / 1440} days`;
+  if (minutes % 60 === 0) return `${minutes / 60} hours`;
+  return `${minutes} minutes`;
+}
+
+export function scheduleDescription(job) {
+  const schedule = job.schedule;
+  if (!schedule) return "Schedule unavailable";
+  if (schedule.kind === "timer")
+    return `After ${scheduleDurationLabel(schedule.delayMs)}`;
+  if (schedule.kind === "once")
+    return scheduleTimeLabel(schedule.at, job.timeZone);
+  if (schedule.kind === "interval")
+    return `Every ${scheduleDurationLabel(schedule.everyMs)}`;
+  if (schedule.kind === "daily") return `Daily at ${schedule.at}`;
+  if (schedule.kind === "weekly")
+    return `${schedule.weekdays.map((day) => SCHEDULE_WEEKDAYS[day]).join(", ")} at ${schedule.at}`;
+  if (schedule.kind === "monthly")
+    return `Day ${schedule.dayOfMonth} each month at ${schedule.at}`;
+  return "Schedule unavailable";
+}
+
+function matchesScheduleState(job, state) {
+  if (!state || state === "all") return true;
+  if (state === "current") return ["active", "paused"].includes(job.state);
+  return job.state === state;
+}
+
+export function matchesScheduleFilter(job, query, state, sessions = []) {
+  if (!matchesScheduleState(job, state)) return false;
+  const needle = String(query || "")
+    .trim()
+    .toLocaleLowerCase();
+  if (!needle) return true;
+  const session = sessions.find((item) => item.id === job.sessionId);
+  return [
+    job.title,
+    job.prompt,
+    job.sessionId,
+    session?.title,
+    job.modelProfileId,
+    scheduleDescription(job),
+  ].some((value) =>
+    String(value || "")
+      .toLocaleLowerCase()
+      .includes(needle),
+  );
+}
+
+export function canManageSchedule(job) {
+  if (!job) return false;
+  return job.state !== "cancelled";
+}
+
+export function canRunScheduleNow(job) {
+  if (!job) return false;
+  return job.state !== "cancelled";
+}
+
+export function emptyScheduleListMessage(snapshot) {
+  if (snapshot.loading) return "Loading…";
+  if (snapshot.error)
+    return "The schedule list is unavailable. Refresh to load it again.";
+  if (snapshot.jobs.length) return "No schedules match your search.";
+  return "No schedules yet. Create one here or ask ABot in a conversation.";
+}

package/dist/src/web-ui/app/lib/session-read-state.d.ts

@@ -0,0 +1,22 @@
+export type SessionReadStateEntry = Record<string, unknown> & {
+  id?: unknown;
+  lastReadAt?: unknown;
+  readState?: Record<string, unknown>;
+};
+
+export declare function isOlderSessionReadState(
+  incoming: SessionReadStateEntry | null | undefined,
+  known: SessionReadStateEntry | null | undefined,
+): boolean;
+
+export declare function isSessionReadStateUnavailable(
+  value: SessionReadStateEntry | null | undefined,
+): boolean;
+
+export declare function mergeSessionReadStateUpdate<
+  T extends SessionReadStateEntry,
+>(incoming: T, known: SessionReadStateEntry | null | undefined): T;
+
+export declare function mergeSessionListReadState<
+  T extends SessionReadStateEntry,
+>(incomingSessions: T[], knownSessions: SessionReadStateEntry[]): T[];

package/dist/src/web-ui/app/lib/session-read-state.js

@@ -0,0 +1,63 @@
+function sessionReadTimestamp(value) {
+  const timestamp = value?.lastReadAt ?? value?.readState?.lastReadAt;
+  if (typeof timestamp !== "number") return null;
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+
+function sessionReadStateStatus(value) {
+  return value?.readStateStatus ?? value?.readState?.readStateStatus;
+}
+
+export function isSessionReadStateUnavailable(value) {
+  return sessionReadStateStatus(value) === "unavailable";
+}
+
+export function isOlderSessionReadState(incoming, known) {
+  if (isSessionReadStateUnavailable(incoming)) return false;
+  const incomingTimestamp = sessionReadTimestamp(incoming);
+  const knownTimestamp = sessionReadTimestamp(known);
+  if (incomingTimestamp === null) return false;
+  if (knownTimestamp === null) return false;
+  return incomingTimestamp < knownTimestamp;
+}
+
+function preserveKnownReadState(incoming, known) {
+  if (!known) return incoming;
+  const preserveUnavailable = isSessionReadStateUnavailable(incoming);
+  if (!preserveUnavailable && !isOlderSessionReadState(incoming, known))
+    return incoming;
+  const preserved = {};
+  for (const field of [
+    "lastReadAt",
+    "lastReadMessageId",
+    "unreadCount",
+    "hasUnread",
+  ]) {
+    preserved[field] = known[field] ?? known.readState?.[field] ?? null;
+  }
+  return {
+    ...incoming,
+    ...preserved,
+    readState: {
+      ...incoming.readState,
+      sessionId: incoming.id ?? incoming.sessionId,
+      readStateStatus: sessionReadStateStatus(incoming),
+      ...preserved,
+    },
+  };
+}
+
+export function mergeSessionReadStateUpdate(incoming, known) {
+  const merged = preserveKnownReadState(incoming, known);
+  if (!isSessionReadStateUnavailable(known)) return merged;
+  return { ...merged, readStateStatus: "unavailable" };
+}
+
+export function mergeSessionListReadState(incomingSessions, knownSessions) {
+  const knownById = new Map(
+    knownSessions.map((session) => [session.id, session]),
+  );
+  return incomingSessions.map((session) =>
+    preserveKnownReadState(session, knownById.get(session.id)),
+  );
+}

package/dist/src/web-ui/app/lib/source-url-policy.d.ts

@@ -0,0 +1,2 @@
+export declare function parseWebSourceUrl(value: unknown): URL | null;
+export declare function webSourceFaviconUrl(value: unknown): string;

package/dist/src/web-ui/app/lib/source-url-policy.js

@@ -0,0 +1,31 @@
+const MAX_SOURCE_URL_LENGTH = 4_096;
+
+export function parseWebSourceUrl(value) {
+  if (typeof value !== "string") return null;
+  const candidate = value.trim();
+  if (!candidate || candidate.length > MAX_SOURCE_URL_LENGTH) return null;
+  if (/[\u0000-\u0020\u007f]/u.test(candidate)) return null;
+  try {
+    const url = new URL(candidate);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+    if (url.username || url.password) return null;
+    return url;
+  } catch {
+    return null;
+  }
+}
+
+function canLoadOriginIcon(hostname) {
+  const host = hostname.toLowerCase().replace(/\.$/u, "");
+  if (!host.includes(".")) return false;
+  if (host.startsWith("[")) return false;
+  if (/^\d+(?:\.\d+){3}$/u.test(host)) return false;
+  const localSuffixes = [".localhost", ".local", ".internal", ".home", ".lan"];
+  return !localSuffixes.some((suffix) => host.endsWith(suffix));
+}
+
+export function webSourceFaviconUrl(value) {
+  const url = parseWebSourceUrl(value);
+  if (!url || !canLoadOriginIcon(url.hostname)) return "";
+  return `${url.origin}/favicon.ico`;
+}

package/dist/src/web-ui/app/lib/task-progress.d.ts

@@ -0,0 +1,53 @@
+import type { EventRecord } from "./event-presentation.js";
+
+export interface TaskProgressItem {
+  id: string;
+  title: string;
+  status: "pending" | "in_progress" | "done" | "blocked";
+  order: number;
+}
+
+interface PlanEventPosition {
+  source: "eventSequence" | "seqNo";
+  value: number;
+}
+
+interface PlanItemUpdate {
+  item: TaskProgressItem;
+  position?: PlanEventPosition;
+  planSummary?: string;
+  planTotal?: number;
+  planCompleted?: number;
+}
+
+interface PlanReplayState {
+  snapshot?: {
+    summary: string;
+    total: number;
+    completed: number;
+    items: TaskProgressItem[];
+    hasSnapshot: boolean;
+  };
+  snapshotPosition?: PlanEventPosition;
+  itemUpdates: PlanItemUpdate[];
+}
+
+export interface TaskProgress {
+  requestId: string;
+  summary: string;
+  total: number;
+  completed: number;
+  items: TaskProgressItem[];
+  activeItem: string;
+  hasSignal: boolean;
+  hasSnapshot: boolean;
+  lastEventSequence?: number;
+  lastSeqNo?: number;
+  replayState?: PlanReplayState;
+}
+
+export declare function taskStatusClass(status: unknown): string;
+export declare function reduceTaskProgress(
+  current: TaskProgress | undefined,
+  message: EventRecord,
+): TaskProgress | undefined;