@abot-ai/runtime 1.1.0 → 1.3.0

package/dist/src/web-ui/app/controllers/schedule-realtime.js

@@ -0,0 +1,118 @@
+import { normalizeScheduleReference } from "../lib/schedule-message.js";
+import { textOf } from "../lib/text-format.js";
+
+export function isScheduleTriggerForConversation(
+  message,
+  sessionId,
+  environmentId,
+) {
+  if (!sessionId || message.sessionId !== sessionId) return false;
+  return isScheduleTriggerInEnvironment(message, environmentId);
+}
+
+function isScheduleTriggerInEnvironment(message, environmentId) {
+  if (!textOf(message.sessionId)) return false;
+  if (textOf(message.environment || message.environmentId) !== environmentId)
+    return false;
+  if (!textOf(message.requestId) || !textOf(message.messageId)) return false;
+  return Boolean(normalizeScheduleReference(message.schedule));
+}
+
+export function createScheduleRealtimeController({
+  state,
+  selectedEnvironmentId,
+  addOrMergeMessage,
+  normalizeChatMessage,
+  activeAssistantForRequest,
+  renderMessages,
+  updateComposerSendState,
+  setMessageActivityStatus,
+  trackSeq,
+  loadSessions,
+}) {
+  const scheduledRequests = new Map();
+
+  function hasRecordedTrigger(message) {
+    return (state.messages || []).some(
+      (item) => item.schedule?.runId === message.schedule.runId,
+    );
+  }
+
+  function hasDifferentActiveRequest(requestId) {
+    if (!state.activeRequestId) return false;
+    return state.activeRequestId !== requestId;
+  }
+
+  function isForegroundScheduledRequest(message) {
+    if (message.sessionId !== state.currentSessionId) return false;
+    return message.requestId === state.activeRequestId;
+  }
+
+  function scheduledTerminalScope(message) {
+    const tracked = scheduledRequests.get(message.requestId);
+    if (tracked) return tracked;
+    if (message.requestOrigin !== "schedule") return undefined;
+    const environmentId = textOf(message.environment || message.environmentId);
+    if (!environmentId.trim()) return undefined;
+    if (!textOf(message.requestId).trim()) return undefined;
+    if (!textOf(message.sessionId).trim()) return undefined;
+    return { sessionId: message.sessionId, environmentId };
+  }
+
+  function handleScheduledTerminal(message) {
+    if (message.type !== "completed" && message.type !== "failed") return false;
+    const scope = scheduledTerminalScope(message);
+    if (!scope) return message.requestOrigin === "schedule";
+    if (message.sessionId !== scope.sessionId) return true;
+    const environmentId =
+      textOf(message.environment || message.environmentId) ||
+      scope.environmentId;
+    if (environmentId !== scope.environmentId) return true;
+    scheduledRequests.delete(message.requestId);
+    if (environmentId !== selectedEnvironmentId()) return true;
+    if (message.sessionDeleted === true) return true;
+    if (isForegroundScheduledRequest(message)) return false;
+    void loadSessions();
+    return true;
+  }
+
+  function handle(message) {
+    if (handleScheduledTerminal(message)) return true;
+    if (message.type !== "event" || message.name !== "schedule.triggered")
+      return false;
+    if (!isScheduleTriggerInEnvironment(message, selectedEnvironmentId()))
+      return true;
+    if (message.sessionDeleted === true) return true;
+    scheduledRequests.set(message.requestId, {
+      sessionId: message.sessionId,
+      environmentId: selectedEnvironmentId(),
+    });
+    if (hasRecordedTrigger(message)) return true;
+    if (
+      !isScheduleTriggerForConversation(
+        message,
+        state.currentSessionId,
+        selectedEnvironmentId(),
+      )
+    )
+      return true;
+    if (hasDifferentActiveRequest(message.requestId)) return true;
+    const userMessage = normalizeChatMessage({
+      id: message.messageId,
+      role: "user",
+      requestId: message.requestId,
+      text: message.text,
+      createdAt: message.createdAt,
+      schedule: message.schedule,
+    });
+    addOrMergeMessage(userMessage);
+    state.activeRequestId = message.requestId;
+    activeAssistantForRequest(message.requestId);
+    trackSeq(message);
+    renderMessages();
+    updateComposerSendState();
+    setMessageActivityStatus("Scheduled task is running.", true);
+    return true;
+  }
+  return { handle };
+}

package/dist/src/web-ui/app/controllers/schedules-controller.js

@@ -0,0 +1,421 @@
+import {
+  canManageSchedule,
+  matchesScheduleFilter,
+  scheduleErrorMessage,
+} from "../lib/schedule-presentation.js";
+
+export function createSchedulesController({
+  client,
+  getEnvironmentId,
+  render,
+  openConversation,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+}) {
+  const state = {
+    environmentId: "",
+    jobs: [],
+    sessions: [],
+    models: [],
+    defaultModelProfileId: "",
+    selectedId: "",
+    runs: [],
+    runsCursor: null,
+    runsNextCursor: null,
+    runsPreviousCursors: [],
+    query: "",
+    filter: "current",
+    loading: false,
+    loadingRuns: false,
+    mutation: "",
+    error: "",
+    detailError: "",
+    editor: null,
+  };
+  let active = false;
+  let loadRevision = 0;
+  let detailRevision = 0;
+  let selectionRevision = 0;
+  let pendingDetailRead = null;
+  let pollTimer;
+  const publish = () => render({ ...state });
+  const isCurrentEnvironment = (environmentId) =>
+    environmentId === getEnvironmentId();
+  const hasCurrentListRead = (revision, environmentId) =>
+    revision === loadRevision && isCurrentEnvironment(environmentId);
+  const hasCurrentDetailRead = (revision, environmentId, jobId) =>
+    revision === detailRevision &&
+    isCurrentEnvironment(environmentId) &&
+    state.selectedId === jobId;
+
+  function resetRunPages() {
+    Object.assign(state, {
+      runs: [],
+      runsCursor: null,
+      runsNextCursor: null,
+      runsPreviousCursors: [],
+    });
+  }
+
+  function selectJobIdentity(jobId) {
+    if (state.selectedId !== jobId) resetRunPages();
+    state.selectedId = jobId;
+  }
+
+  function isVisibleJob(job) {
+    return matchesScheduleFilter(
+      job,
+      state.query,
+      state.filter,
+      state.sessions,
+    );
+  }
+
+  function firstVisibleJob() {
+    return state.jobs.find(isVisibleJob);
+  }
+
+  function hasLoadedJob(jobId) {
+    return state.jobs.some((job) => job.id === jobId);
+  }
+
+  function hasVisibleSelection(selected) {
+    if (!selected) return false;
+    return isVisibleJob(selected);
+  }
+
+  function hasPendingDetailRead(jobId, environmentId) {
+    if (!pendingDetailRead) return false;
+    if (pendingDetailRead.revision !== detailRevision) return false;
+    if (pendingDetailRead.environmentId !== environmentId) return false;
+    if (pendingDetailRead.jobId !== jobId) return false;
+    return pendingDetailRead.cursor === state.runsCursor;
+  }
+
+  function shouldShowHistoryLoading(background) {
+    if (!background) return true;
+    return state.runs.length === 0;
+  }
+
+  function shouldOpenEntryEditor(
+    openFirstEditor,
+    environmentChanged,
+    targetJobId,
+    readSelectionRevision,
+  ) {
+    if (readSelectionRevision !== selectionRevision) return false;
+    if (targetJobId) return false;
+    if (state.editor) return false;
+    if (state.mutation) return false;
+    if (!active) return false;
+    if (openFirstEditor) return true;
+    return environmentChanged;
+  }
+
+  function canRestoreRequestedJob(targetJobId, readSelectionRevision) {
+    if (!targetJobId) return false;
+    return readSelectionRevision === selectionRevision;
+  }
+
+  function shouldPreserveMissingSelection(selected, readSelectionRevision) {
+    if (selected) return false;
+    return readSelectionRevision === selectionRevision;
+  }
+
+  function openEntryScheduleEditor() {
+    const job = firstVisibleJob();
+    selectJobIdentity(job?.id || "");
+    if (!canManageSchedule(job)) return;
+    state.editor = { job, environmentId: getEnvironmentId() };
+  }
+
+  function reconcileLoadedSelection(
+    openEditor,
+    targetJobId,
+    readSelectionRevision,
+  ) {
+    if (canRestoreRequestedJob(targetJobId, readSelectionRevision)) {
+      selectJobIdentity(targetJobId);
+      return;
+    }
+    if (state.editor) return;
+    if (openEditor) {
+      openEntryScheduleEditor();
+      return;
+    }
+    const selected = state.jobs.find((job) => job.id === state.selectedId);
+    if (shouldPreserveMissingSelection(selected, readSelectionRevision)) return;
+    if (hasVisibleSelection(selected)) return;
+    selectJobIdentity(firstVisibleJob()?.id || "");
+  }
+
+  function scheduleRefresh() {
+    clearTimer(pollTimer);
+    if (!active) return;
+    pollTimer = setTimer(() => {
+      if (state.mutation) {
+        scheduleRefresh();
+        return;
+      }
+      void load({ background: true });
+    }, 5000);
+  }
+
+  async function load({
+    background = false,
+    openFirstEditor = false,
+    targetJobId = "",
+  } = {}) {
+    const environmentId = getEnvironmentId();
+    const revision = ++loadRevision;
+    const readSelectionRevision = selectionRevision;
+    const environmentChanged = state.environmentId !== environmentId;
+    if (environmentChanged) {
+      Object.assign(state, {
+        environmentId,
+        jobs: [],
+        sessions: [],
+        models: [],
+        selectedId: "",
+        query: "",
+        filter: targetJobId ? "all" : "current",
+        runs: [],
+        editor: null,
+        error: "",
+        detailError: "",
+      });
+      resetRunPages();
+      detailRevision += 1;
+    }
+    state.loading = !background;
+    if (!background) publish();
+    try {
+      const [jobs, sessions, models] = await Promise.all([
+        client.listSchedules(environmentId),
+        client.listSessions(environmentId),
+        client.listModels(environmentId),
+      ]);
+      if (!hasCurrentListRead(revision, environmentId)) return;
+      state.jobs = jobs.jobs || [];
+      state.sessions = sessions.sessions || [];
+      state.models = models.profiles || [];
+      state.defaultModelProfileId = models.defaultProfileId || "";
+      state.error = "";
+      reconcileLoadedSelection(
+        shouldOpenEntryEditor(
+          openFirstEditor,
+          environmentChanged,
+          targetJobId,
+          readSelectionRevision,
+        ),
+        targetJobId,
+        readSelectionRevision,
+      );
+      if (state.selectedId)
+        void select(state.selectedId, {
+          background: true,
+          reusePendingRead: background,
+        });
+    } catch (error) {
+      if (!hasCurrentListRead(revision, environmentId)) return;
+      state.error = scheduleErrorMessage(error);
+    } finally {
+      if (hasCurrentListRead(revision, environmentId)) {
+        state.loading = false;
+        publish();
+        scheduleRefresh();
+      }
+    }
+  }
+
+  async function select(
+    jobId,
+    { background = false, reusePendingRead = background } = {},
+  ) {
+    const environmentId = getEnvironmentId();
+    if (reusePendingRead && hasPendingDetailRead(jobId, environmentId)) return;
+    if (!background) selectionRevision += 1;
+    const revision = ++detailRevision;
+    selectJobIdentity(jobId);
+    state.loadingRuns = shouldShowHistoryLoading(background);
+    state.detailError = "";
+    if (!hasLoadedJob(jobId)) {
+      resetRunPages();
+      state.loadingRuns = false;
+      publish();
+      return;
+    }
+    const read = { revision, environmentId, jobId, cursor: state.runsCursor };
+    pendingDetailRead = read;
+    if (!background) publish();
+    try {
+      const result = await client.listScheduleRuns(jobId, environmentId, {
+        cursor: read.cursor ?? undefined,
+      });
+      if (!hasCurrentDetailRead(revision, environmentId, jobId)) return;
+      state.runs = result.runs || [];
+      state.runsNextCursor = result.nextCursor ?? null;
+    } catch (error) {
+      if (!hasCurrentDetailRead(revision, environmentId, jobId)) return;
+      state.detailError = scheduleErrorMessage(error);
+    } finally {
+      if (pendingDetailRead === read) pendingDetailRead = null;
+      if (hasCurrentDetailRead(revision, environmentId, jobId)) {
+        state.loadingRuns = false;
+        publish();
+      }
+    }
+  }
+
+  async function moveRunPage(cursor, previousCursors) {
+    state.runsCursor = cursor;
+    state.runsPreviousCursors = previousCursors;
+    state.runsNextCursor = null;
+    state.runs = [];
+    await select(state.selectedId);
+  }
+
+  async function olderRuns() {
+    if (state.loadingRuns || !state.runsNextCursor) return;
+    await moveRunPage(state.runsNextCursor, [
+      ...state.runsPreviousCursors,
+      state.runsCursor,
+    ]);
+  }
+
+  async function newerRuns() {
+    if (state.loadingRuns || !state.runsPreviousCursors.length) return;
+    const previous = [...state.runsPreviousCursors];
+    await moveRunPage(previous.pop(), previous);
+  }
+
+  async function latestRuns() {
+    if (state.loadingRuns || state.runsCursor === null) return;
+    await moveRunPage(null, []);
+  }
+
+  function beginEdit(jobId = "", initialValues = null) {
+    selectionRevision += 1;
+    state.editor = {
+      job: state.jobs.find((job) => job.id === jobId) || null,
+      environmentId: getEnvironmentId(),
+      initialValues,
+    };
+    publish();
+  }
+
+  function cancelEdit() {
+    selectionRevision += 1;
+    state.editor = null;
+    publish();
+    scheduleRefresh();
+  }
+
+  async function save(input) {
+    const editor = state.editor;
+    if (!editor || !isCurrentEnvironment(editor.environmentId))
+      throw new Error("The environment changed. Reopen the schedule editor.");
+    state.mutation = "save";
+    try {
+      const result = editor.job
+        ? await client.updateSchedule(
+            editor.job.id,
+            input,
+            editor.environmentId,
+          )
+        : await client.createSchedule(input, editor.environmentId);
+      if (!isCurrentEnvironment(editor.environmentId)) return;
+      state.editor = null;
+      selectJobIdentity(result.job.id);
+      await load();
+    } finally {
+      state.mutation = "";
+      publish();
+    }
+  }
+
+  async function action(jobId, actionName) {
+    if (state.mutation) return;
+    const environmentId = getEnvironmentId();
+    state.mutation = actionName;
+    state.error = "";
+    publish();
+    try {
+      await client.scheduleAction(jobId, actionName, environmentId);
+      if (isCurrentEnvironment(environmentId)) await load();
+    } catch (error) {
+      if (isCurrentEnvironment(environmentId))
+        state.error = scheduleErrorMessage(error);
+    } finally {
+      state.mutation = "";
+      publish();
+    }
+  }
+
+  async function openJob(jobId) {
+    selectionRevision += 1;
+    Object.assign(state, { query: "", filter: "all", editor: null });
+    selectJobIdentity(jobId);
+    await load({ targetJobId: jobId });
+  }
+
+  async function openCreate(initialValues = {}) {
+    const environmentId = getEnvironmentId();
+    const revision = ++selectionRevision;
+    await load();
+    if (!isCurrentEnvironment(environmentId)) return;
+    if (revision !== selectionRevision) return;
+    if (state.error) return;
+    beginEdit("", {
+      ...initialValues,
+      modelProfileId: initialValues.modelProfileId || state.defaultModelProfileId,
+    });
+  }
+
+  async function filter(query, filter) {
+    selectionRevision += 1;
+    Object.assign(state, { query, filter });
+    if (state.editor) {
+      publish();
+      return;
+    }
+    const selected = state.jobs.find((job) => job.id === state.selectedId);
+    if (hasVisibleSelection(selected)) {
+      publish();
+      return;
+    }
+    const job = firstVisibleJob();
+    await select(job?.id || "");
+  }
+
+  return {
+    load,
+    select,
+    olderRuns,
+    newerRuns,
+    latestRuns,
+    beginEdit,
+    cancelEdit,
+    save,
+    action,
+    openJob,
+    openCreate,
+    snapshot: () => ({ ...state }),
+    filter,
+    setActive(value) {
+      const entering = value && !active;
+      active = value;
+      if (active) {
+        void load({ openFirstEditor: entering });
+        return;
+      }
+      loadRevision += 1;
+      detailRevision += 1;
+      state.loading = false;
+      state.loadingRuns = false;
+      clearTimer(pollTimer);
+    },
+    openConversation: (sessionId, requestId) =>
+      openConversation(sessionId, requestId),
+  };
+}

package/dist/src/web-ui/app/controllers/session-controller.js

@@ -1,10 +1,10 @@
-import { matchesSessionQuery } from "../ui-behavior.js";
 import {
-  escapeAttribute,
-  escapeHtml,
-  formatTime,
-  textOf,
-} from "../lib/text-format.js";
+  isOlderSessionReadState,
+  isSessionReadStateUnavailable,
+  mergeSessionReadStateUpdate,
+} from "../lib/session-read-state.js";
+import { matchesSessionQuery } from "../ui-behavior.js";
+import { escapeAttribute, escapeHtml, textOf } from "../lib/text-format.js";
 import { getNumber } from "../lib/event-presentation.js";
 
 export function createSessionController({
@@ -22,6 +22,7 @@ export function createSessionController({
   onReload,
   onControlEvent,
   confirmAction = window.confirm.bind(window),
+  copyText = (value) => navigator.clipboard.writeText(value),
 }) {
   const titleOf = (session) =>
     textOf(session?.displayName || session?.title || session?.id);
@@ -85,7 +86,10 @@ export function createSessionController({
       const pinned = isPinned(sessionId);
       const busy = state.busySessionIds.has(sessionId);
       const unreadCount = getNumber(session.unreadCount, 0);
-      const hasUnread = session.hasUnread === true || unreadCount > 0;
+      const unreadUnavailable = isSessionReadStateUnavailable(session);
+      const hasUnread = unreadUnavailable
+        ? false
+        : session.hasUnread === true || unreadCount > 0;
       const item = document.createElement("div");
       item.className = `session-item ${
         session.id === state.currentSessionId ? "active" : ""
@@ -93,9 +97,10 @@ export function createSessionController({
         hasUnread ? "unread" : ""
       }`;
       item.innerHTML = `
-        <button class="session-open-button" type="button">
+        <button class="session-open-button" type="button" title="${escapeAttribute(titleOf(session))}">
           <div class="session-title-row">
             <div class="session-title" dir="auto">${escapeHtml(titleOf(session))}</div>
+            ${unreadUnavailable ? '<span class="session-unread-badge" title="Unread status unavailable" aria-label="Unread status unavailable">?</span>' : ""}
             ${
               hasUnread
                 ? `<span class="session-unread-badge" title="${escapeAttribute(
@@ -104,16 +109,12 @@ export function createSessionController({
                 : ""
             }
           </div>
-          <div class="session-preview" dir="auto">${escapeHtml(
-            session.lastMessagePreview ||
-              formatTime(session.updatedAt) ||
-              session.id,
-          )}</div>
         </button>
         <div class="session-actions" aria-label="Session actions">
           <button class="session-menu-button" type="button" title="Session actions" aria-label="Session actions" aria-haspopup="menu" aria-expanded="false" aria-controls="session-menu-${sessionIndex}">•••</button>
           <div id="session-menu-${sessionIndex}" class="session-menu" role="menu" hidden>
             <button class="session-action pin-action" type="button" role="menuitem" tabindex="-1" title="${pinned ? "Unpin session" : "Pin session"}">${pinned ? "Unpin" : "Pin"}</button>
+            <button class="session-action copy-filename-action" type="button" role="menuitem" tabindex="-1" title="Copy session filename">Copy filename</button>
             <button class="session-action clear-action" type="button" role="menuitem" tabindex="-1" title="Reset messages">Reset</button>
             <button class="session-action delete-action" type="button" role="menuitem" tabindex="-1" title="Delete session">Delete</button>
           </div>
@@ -128,6 +129,9 @@ export function createSessionController({
       item
         .querySelector(".pin-action")
         ?.addEventListener("click", () => togglePinned(sessionId));
+      item
+        .querySelector(".copy-filename-action")
+        ?.addEventListener("click", () => void copyFilename(sessionId));
       item
         .querySelector(".clear-action")
         ?.addEventListener("click", () => void clearMessages(sessionId));
@@ -180,12 +184,20 @@ export function createSessionController({
   }
 
   function applyReadState(sessionId, readState) {
-    const value = readState && typeof readState === "object" ? readState : {};
-    const normalizedSessionId = textOf(value.sessionId || sessionId);
+    const incoming =
+      readState && typeof readState === "object" ? readState : {};
+    const normalizedSessionId = textOf(incoming.sessionId || sessionId);
     if (!normalizedSessionId) return false;
+    const known = byId(normalizedSessionId);
+    if (isOlderSessionReadState(incoming, known)) return false;
+    const value = mergeSessionReadStateUpdate(incoming, known);
+    const unreadUnavailable = isSessionReadStateUnavailable(value);
     const unreadCount = getNumber(value.unreadCount, 0);
     const normalized = {
       sessionId: normalizedSessionId,
+      readStateStatus: unreadUnavailable
+        ? "unavailable"
+        : value.readStateStatus,
       lastReadMessageId: textOf(value.lastReadMessageId),
       lastReadAt: value.lastReadAt || null,
       unreadCount,
@@ -193,6 +205,15 @@ export function createSessionController({
       latestMessageId: textOf(value.latestMessageId),
       latestAssistantMessageId: textOf(value.latestAssistantMessageId),
     };
+    if (unreadUnavailable) {
+      for (const field of [
+        "lastReadMessageId",
+        "lastReadAt",
+        "unreadCount",
+        "hasUnread",
+      ])
+        normalized[field] = value[field] ?? null;
+    }
     let changed = false;
     state.sessions = state.sessions.map((session) => {
       if (textOf(session.id) !== normalized.sessionId) return session;
@@ -200,6 +221,7 @@ export function createSessionController({
       return {
         ...session,
         readState: normalized,
+        readStateStatus: normalized.readStateStatus,
         unreadCount: normalized.unreadCount,
         hasUnread: normalized.hasUnread,
         lastReadMessageId: normalized.lastReadMessageId,
@@ -229,6 +251,16 @@ export function createSessionController({
     render();
   }
 
+  async function copyFilename(sessionId) {
+    sessionActionsMenu.close({ restoreFocus: true });
+    try {
+      await copyText(`${sessionId}.json`);
+      shell.showToast("Session filename copied");
+    } catch {
+      shell.showToast("Could not copy session filename", "failed");
+    }
+  }
+
   async function clearMessages(sessionId) {
     if (!sessionId || state.busySessionIds.has(sessionId)) return;
     if (