@abot-ai/runtime 1.3.1 → 1.5.0

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

@@ -0,0 +1,153 @@
+import { createEventRefresh } from "../lib/event-refresh.js";
+import { normalizeRealtimeMessage } from "../lib/realtime-message.js";
+
+export function createNotificationsController({
+  client,
+  getEnvironmentId,
+  render,
+  isVisible = () => document.visibilityState === "visible",
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+}) {
+  const state = {
+    items: [], unreadCount: 0, nextCursor: null, preferences: null,
+    desktop: null, loading: false, busy: false, error: "", filter: "all",
+  };
+  let ready = false;
+  let environmentRevision = 0;
+  let readRevision = 0;
+  const refreshEvents = createEventRefresh({
+    canRefresh: () => ready && isVisible(),
+    refresh: () => refresh(),
+    setTimer, clearTimer,
+  });
+  const snapshot = () => ({ ...state, supported: client.supportsNotifications() });
+  const publish = () => render(snapshot());
+  function isCurrentEnvironment(environment, revision) {
+    if (revision !== environmentRevision) return false;
+    return environment === getEnvironmentId();
+  }
+  function isCurrentRead(environment, environmentVersion, readVersion) {
+    if (!isCurrentEnvironment(environment, environmentVersion)) return false;
+    return readVersion === readRevision;
+  }
+  function hasScopedNotifications(result, environment) {
+    if (!Array.isArray(result?.items)) return false;
+    return result.items.every((item) => item.environmentId === environment);
+  }
+  async function refresh({ append = false } = {}) {
+    if (!ready) return;
+    if (!client.supportsNotifications()) {
+      publish();
+      return;
+    }
+    const environment = getEnvironmentId();
+    const environmentVersion = environmentRevision;
+    const readVersion = ++readRevision;
+    const before = append ? state.nextCursor : undefined;
+    if (append && !before) return;
+    state.loading = true;
+    state.error = "";
+    publish();
+    try {
+      const result = await client.listNotifications(environment, { before });
+      if (!isCurrentRead(environment, environmentVersion, readVersion)) return;
+      if (!hasScopedNotifications(result, environment))
+        throw new Error("The notification history could not be verified. Refresh to try again.");
+      const existing = append ? state.items : [];
+      const seen = new Set(existing.map((item) => item.id));
+      state.items = [...existing, ...result.items.filter((item) => !seen.has(item.id))];
+      state.unreadCount = Math.max(0, Number(result.unreadCount) || 0);
+      state.nextCursor = result.nextCursor || null;
+      state.preferences = result.preferences;
+      state.desktop = result.desktop;
+    } catch (error) {
+      if (!isCurrentRead(environment, environmentVersion, readVersion)) return;
+      state.error = error instanceof Error ? error.message : String(error);
+    } finally {
+      if (isCurrentRead(environment, environmentVersion, readVersion)) {
+        state.loading = false;
+        publish();
+      }
+    }
+  }
+  async function mutate(operation) {
+    if (state.busy) return false;
+    if (!ready || !client.supportsNotifications()) return false;
+    const environment = getEnvironmentId();
+    const version = environmentRevision;
+    readRevision += 1;
+    state.busy = true;
+    state.loading = false;
+    state.error = "";
+    publish();
+    try {
+      await operation(environment);
+      if (!isCurrentEnvironment(environment, version)) return false;
+      await refresh();
+      return isCurrentEnvironment(environment, version);
+    } catch (error) {
+      if (!isCurrentEnvironment(environment, version)) return false;
+      state.error = error instanceof Error ? error.message : String(error);
+      return false;
+    } finally {
+      if (isCurrentEnvironment(environment, version)) {
+        state.busy = false;
+        publish();
+      }
+    }
+  }
+  async function markRead(id, read = true) {
+    const item = state.items.find((candidate) => candidate.id === id);
+    if (!item) return false;
+    if (item.environmentId !== getEnvironmentId()) return false;
+    return mutate((environment) => client.markNotificationsRead({ ids: [id], read }, environment));
+  }
+  return {
+    snapshot, publish, refresh, markRead,
+    loadMore: () => refresh({ append: true }),
+    markAllRead: () => mutate((environment) =>
+      client.markNotificationsRead({ all: true, read: true }, environment)),
+    savePreferences: (preferences) => mutate((environment) =>
+      client.saveNotificationPreferences(preferences, environment)),
+    setFilter(filter) {
+      state.filter = filter === "unread" ? "unread" : "all";
+      publish();
+    },
+    setReady() {
+      ready = true;
+      return refresh();
+    },
+    setActive(active) {
+      if (active) void refresh();
+    },
+    environmentChanged() {
+      environmentRevision += 1;
+      readRevision += 1;
+      refreshEvents.cancel();
+      Object.assign(state, {
+        items: [], unreadCount: 0, nextCursor: null, preferences: null,
+        desktop: null, loading: false, busy: false, error: "",
+      });
+      publish();
+      void refresh();
+    },
+    handleRealtime(rawMessage) {
+      const message = normalizeRealtimeMessage(rawMessage);
+      if (canRefreshNotificationEvent(message, getEnvironmentId()))
+        refreshEvents.schedule();
+    },
+    visibilityChanged() {
+      refreshEvents.cancel();
+      if (isVisible()) void refresh();
+    },
+    dispose: refreshEvents.cancel,
+  };
+}
+
+function canRefreshNotificationEvent(message, environmentId) {
+  if (message.type === "system-host.changed") return true;
+  if (message.type !== "workspace_changed") return false;
+  if ((message.environment || message.environmentId) !== environmentId) return false;
+  return message.resources?.includes("notifications") === true;
+}

package/dist/src/web-ui/app/controllers/operations-controller.d.ts

@@ -4,14 +4,15 @@ export declare function latestHealthEvent(
 ): Record<string, unknown> | undefined;
 
 export interface OperationsControllerDependencies {
+  readonly getEnvironmentId?: () => string | undefined;
   readonly dom: Readonly<{
     runtimeStatus: Pick<HTMLElement, "innerHTML" | "textContent">;
     runtimeLogs: Pick<HTMLElement, "textContent">;
     healthStatus: Pick<HTMLElement, "innerHTML" | "textContent">;
   }>;
   readonly client: Readonly<{
-    getRuntimeStatus(): Promise<Record<string, unknown>>;
-    getRuntimeLogs(lines: number): Promise<Record<string, unknown>>;
+    getRuntimeStatus(environmentId?: string): Promise<Record<string, unknown>>;
+    getRuntimeLogs(lines: number, environmentId?: string): Promise<Record<string, unknown>>;
     getSystemHealth(): Promise<Record<string, unknown>>;
   }>;
 }
@@ -19,6 +20,7 @@ export interface OperationsControllerDependencies {
 export declare function createOperationsController(
   options: OperationsControllerDependencies,
 ): {
+  environmentChanged(): void;
   loadRuntimeStatus(): Promise<void>;
   loadRuntimeLogs(): Promise<void>;
   loadSystemHealth(): Promise<void>;

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

@@ -37,12 +37,29 @@ export function latestHealthEvent(details) {
   )[0];
 }
 
-export function createOperationsController({ dom, client }) {
-  return {
+export function createOperationsController({ dom, client, getEnvironmentId = () => undefined }) {
+  let statusRevision = 0;
+  let logsRevision = 0;
+  let displayedEnvironment = getEnvironmentId();
+  function isCurrentOperationsRead(environmentId, revision, currentRevision) {
+    if (environmentId !== getEnvironmentId()) return false;
+    return revision === currentRevision;
+  }
+  const controller = {
+    environmentChanged() {
+      const environmentId = getEnvironmentId();
+      if (displayedEnvironment === environmentId) return;
+      displayedEnvironment = environmentId;
+      void controller.loadRuntimeStatus();
+      void controller.loadRuntimeLogs();
+    },
     async loadRuntimeStatus() {
+      const environmentId = getEnvironmentId();
+      const revision = ++statusRevision;
       dom.runtimeStatus.textContent = "Loading...";
       try {
-        const payload = await client.getRuntimeStatus();
+        const payload = await client.getRuntimeStatus(environmentId);
+        if (!isCurrentOperationsRead(environmentId, revision, statusRevision)) return;
         const status = payload.status || {};
         dom.runtimeStatus.innerHTML = `
           <div class="runtime-grid">
@@ -54,6 +71,7 @@ export function createOperationsController({ dom, client }) {
           </div>
         `;
       } catch (error) {
+        if (!isCurrentOperationsRead(environmentId, revision, statusRevision)) return;
         dom.runtimeStatus.innerHTML = `<span class="error-text">${escapeHtml(
           error instanceof Error ? error.message : String(error),
         )}</span>`;
@@ -61,9 +79,12 @@ export function createOperationsController({ dom, client }) {
     },
 
     async loadRuntimeLogs() {
+      const environmentId = getEnvironmentId();
+      const revision = ++logsRevision;
       dom.runtimeLogs.textContent = "Loading...";
       try {
-        const payload = await client.getRuntimeLogs(100);
+        const payload = await client.getRuntimeLogs(100, environmentId);
+        if (!isCurrentOperationsRead(environmentId, revision, logsRevision)) return;
         const lines = Array.isArray(payload.log?.lines)
           ? payload.log.lines
           : [];
@@ -71,6 +92,7 @@ export function createOperationsController({ dom, client }) {
           ? lines.join("\n")
           : "No runtime log lines returned.";
       } catch (error) {
+        if (!isCurrentOperationsRead(environmentId, revision, logsRevision)) return;
         dom.runtimeLogs.textContent =
           error instanceof Error ? error.message : String(error);
       }
@@ -134,4 +156,5 @@ export function createOperationsController({ dom, client }) {
       }
     },
   };
+  return controller;
 }

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

@@ -0,0 +1,458 @@
+import { createEventRefresh } from "../lib/event-refresh.js";
+import { learningFailureCopy } from "../components/passive-learning/failure-copy.js";
+
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function learningActionErrorMessage(error) {
+  const message = errorMessage(error);
+  const explanation = learningFailureCopy(message);
+  return explanation.code ? explanation.message : message;
+}
+
+function hasLearningStatus(result) {
+  return (
+    result?.status?.preferences?.enabled === true ||
+    result?.status?.preferences?.enabled === false
+  );
+}
+
+export function createPassiveLearningController({
+  client,
+  getEnvironmentId,
+  render,
+  openSession = () => {},
+  isVisible = () => document.visibilityState === "visible",
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+}) {
+  const state = {
+    status: null,
+    hostConnection: null,
+    hostConnectionKey: "",
+    batches: [],
+    candidates: [],
+    candidateError: "",
+    loadingCandidates: false,
+    proposalError: "",
+    dismissingProposalId: "",
+    selectedBatch: null,
+    selectedBatchId: "",
+    models: [],
+    statusError: "",
+    batchError: "",
+    detailError: "",
+    modelsError: "",
+    loadingStatus: false,
+    loadingBatches: false,
+    loadingDetail: false,
+    saving: false,
+    restartingCollection: false,
+  };
+  let environmentId = getEnvironmentId();
+  let workspace = "";
+  let revision = 0;
+  let detailRevision = 0;
+  let stale = true;
+  let modelsStale = true;
+  let environmentEpoch = 0;
+
+  const learningActive = () => workspace === "learning";
+  const homeActive = () => workspace === "home";
+  const canRefresh = () => (learningActive() || homeActive()) && isVisible();
+  const snapshot = () => ({
+    ...state,
+    environmentId,
+    learningActive: learningActive(),
+    homeActive: homeActive(),
+  });
+  const publish = () => render(snapshot());
+  const currentRead = (readEnvironmentId, readRevision) =>
+    readRevision === revision && readEnvironmentId === getEnvironmentId();
+
+  async function readCurrentState() {
+    stale = false;
+    const readEnvironmentId = getEnvironmentId();
+    const readRevision = ++revision;
+    const includeBatches = learningActive();
+    const includeModels = includeBatches && modelsStale;
+    const includeCandidates =
+      includeBatches &&
+      typeof client.listPassiveLearningCandidates === "function";
+    state.loadingStatus = state.status === null;
+    state.loadingBatches = includeBatches && state.batches.length === 0;
+    state.loadingCandidates =
+      includeCandidates && state.candidates.length === 0;
+    publish();
+    const [statusRead, batchRead, modelRead, candidateRead] =
+      await Promise.allSettled([
+        client.loadPassiveLearning(readEnvironmentId),
+        includeBatches
+          ? client.listPassiveLearningBatches(readEnvironmentId)
+          : Promise.resolve(null),
+        includeModels
+          ? client.listModels(readEnvironmentId)
+          : Promise.resolve(null),
+        includeCandidates
+          ? client.listPassiveLearningCandidates(readEnvironmentId)
+          : Promise.resolve(null),
+      ]);
+    if (!currentRead(readEnvironmentId, readRevision)) return;
+    if (includeCandidates) {
+      if (
+        candidateRead.status === "fulfilled" &&
+        Array.isArray(candidateRead.value?.items)
+      ) {
+        state.candidates = candidateRead.value.items;
+        state.candidateError = "";
+      } else {
+        state.candidateError =
+          candidateRead.status === "rejected"
+            ? errorMessage(candidateRead.reason)
+            : "Candidates are unavailable.";
+      }
+    }
+    let changedSelectedBatch = false;
+    if (
+      statusRead.status === "fulfilled" &&
+      hasLearningStatus(statusRead.value)
+    ) {
+      state.status = statusRead.value.status;
+      state.statusError = "";
+    } else {
+      state.statusError =
+        statusRead.status === "rejected"
+          ? errorMessage(statusRead.reason)
+          : "Learning status is unavailable.";
+    }
+    if (includeBatches) {
+      if (
+        batchRead.status === "fulfilled" &&
+        Array.isArray(batchRead.value?.items)
+      ) {
+        const selectedId = state.selectedBatchId;
+        const previous = state.batches.find((batch) => batch.id === selectedId);
+        const next = batchRead.value.items.find(
+          (batch) => batch.id === selectedId,
+        );
+        const summaryKey = (batch) =>
+          JSON.stringify([
+            batch?.status,
+            batch?.reason,
+            batch?.completedAt,
+            batch?.observationCount,
+            batch?.recordIds,
+            batch?.candidateIds,
+          ]);
+        changedSelectedBatch = Boolean(
+          selectedId && next && summaryKey(previous) !== summaryKey(next),
+        );
+        if (selectedId && !next) void selectBatch("");
+        state.batches = batchRead.value.items;
+        state.batchError = "";
+      } else {
+        state.batchError =
+          batchRead.status === "rejected"
+            ? errorMessage(batchRead.reason)
+            : "Recent batches are unavailable.";
+      }
+    }
+    if (includeModels) {
+      if (
+        modelRead.status === "fulfilled" &&
+        Array.isArray(modelRead.value?.profiles)
+      ) {
+        state.models = modelRead.value.profiles;
+        state.modelsError = "";
+        modelsStale = false;
+      } else {
+        state.modelsError =
+          modelRead.status === "rejected"
+            ? errorMessage(modelRead.reason)
+            : "Model choices are unavailable.";
+      }
+    }
+    const hostState = JSON.stringify([
+      state.status?.deviceId,
+      state.status?.state,
+    ]);
+    if (includeModels || state.hostConnectionKey !== hostState) {
+      try {
+        const host = await client.getSystemHostConnection?.();
+        if (!currentRead(readEnvironmentId, readRevision)) return;
+        state.hostConnection = host ?? null;
+        state.hostConnectionKey = hostState;
+      } catch {
+        if (!currentRead(readEnvironmentId, readRevision)) return;
+        state.hostConnection = null;
+      }
+    }
+    state.loadingStatus = false;
+    state.loadingBatches = false;
+    state.loadingCandidates = false;
+    publish();
+    if (changedSelectedBatch) void selectBatch(state.selectedBatchId);
+  }
+
+  const eventRefresh = createEventRefresh({
+    canRefresh,
+    refresh: readCurrentState,
+    setTimer,
+    clearTimer,
+  });
+
+  function maybeRefresh() {
+    if (!canRefresh() || !stale) return;
+    void eventRefresh.run();
+  }
+
+  function markStale() {
+    stale = true;
+    maybeRefresh();
+  }
+
+  function resetEnvironment() {
+    eventRefresh.cancel();
+    revision += 1;
+    detailRevision += 1;
+    environmentEpoch += 1;
+    environmentId = getEnvironmentId();
+    Object.assign(state, {
+      status: null,
+      hostConnection: null,
+      hostConnectionKey: "",
+      batches: [],
+      candidates: [],
+      candidateError: "",
+      loadingCandidates: false,
+      proposalError: "",
+      dismissingProposalId: "",
+      selectedBatch: null,
+      selectedBatchId: "",
+      models: [],
+      statusError: "",
+      batchError: "",
+      detailError: "",
+      modelsError: "",
+      loadingStatus: false,
+      loadingBatches: false,
+      loadingDetail: false,
+      saving: false,
+      restartingCollection: false,
+    });
+    stale = true;
+    modelsStale = true;
+    publish();
+    maybeRefresh();
+  }
+
+  async function selectBatch(id) {
+    const readEnvironmentId = getEnvironmentId();
+    const readRevision = ++detailRevision;
+    state.selectedBatchId = id;
+    state.selectedBatch = null;
+    state.detailError = "";
+    state.loadingDetail = Boolean(id);
+    publish();
+    if (!id) return;
+    try {
+      const result = await client.loadPassiveLearningBatch(
+        id,
+        readEnvironmentId,
+      );
+      if (
+        readRevision !== detailRevision ||
+        readEnvironmentId !== getEnvironmentId()
+      )
+        return;
+      if (!result?.batch || result.batch.id !== id)
+        throw new Error("Batch details are unavailable.");
+      state.selectedBatch = result.batch;
+    } catch (error) {
+      if (
+        readRevision !== detailRevision ||
+        readEnvironmentId !== getEnvironmentId()
+      )
+        return;
+      state.detailError = errorMessage(error);
+    } finally {
+      if (
+        readRevision === detailRevision &&
+        readEnvironmentId === getEnvironmentId()
+      ) {
+        state.loadingDetail = false;
+        publish();
+      }
+    }
+  }
+
+  async function mutateLearningState(mutate, failureMessage) {
+    if (state.saving) return;
+    const mutationEnvironmentId = getEnvironmentId();
+    const epoch = environmentEpoch;
+    const mutationCurrent = () =>
+      epoch === environmentEpoch &&
+      mutationEnvironmentId === getEnvironmentId();
+    state.saving = true;
+    state.statusError = "";
+    publish();
+    try {
+      const result = await mutate(mutationEnvironmentId);
+      if (!mutationCurrent()) return;
+      if (!hasLearningStatus(result)) throw new Error(failureMessage);
+      state.status = result.status;
+      markStale();
+      return result.status;
+    } catch (error) {
+      if (mutationCurrent()) state.statusError = learningActionErrorMessage(error);
+    } finally {
+      if (mutationCurrent()) {
+        state.saving = false;
+        publish();
+      }
+    }
+  }
+
+  function canRestartCollection() {
+    if (state.saving || state.loadingStatus) return false;
+    if (state.restartingCollection) return false;
+    if (environmentId !== getEnvironmentId()) return false;
+    return typeof client.restartPassiveLearningCollection === "function";
+  }
+
+  async function restartCollection() {
+    if (!canRestartCollection()) return;
+    const epoch = environmentEpoch;
+    const targetEnvironment = environmentId;
+    state.restartingCollection = true;
+    try {
+      return await mutateLearningState(
+        (id) => client.restartPassiveLearningCollection(id),
+        "Collection restart was not confirmed.",
+      );
+    } finally {
+      const hasCurrentRestart = epoch === environmentEpoch && targetEnvironment === getEnvironmentId();
+      if (hasCurrentRestart) {
+        state.restartingCollection = false;
+        publish();
+      }
+    }
+  }
+
+  function findDeliveredProposal(id) {
+    return state.status?.proactive?.proposals?.find(
+      (proposal) =>
+        proposal.id === id &&
+        ["delivered", "dismissed"].includes(proposal.status),
+    );
+  }
+
+  async function openProposal(id) {
+    const proposal = findDeliveredProposal(id);
+    if (!proposal || environmentId !== getEnvironmentId()) return;
+    const epoch = environmentEpoch;
+    state.proposalError = "";
+    try {
+      await openSession(proposal.sessionId, environmentId);
+    } catch (error) {
+      if (epoch !== environmentEpoch) return;
+      state.proposalError = errorMessage(error);
+      publish();
+    }
+  }
+
+  async function dismissProposal(id) {
+    if (state.dismissingProposalId || !findDeliveredProposal(id)) return;
+    const targetEnvironment = getEnvironmentId();
+    if (environmentId !== targetEnvironment) return;
+    const epoch = environmentEpoch;
+    state.dismissingProposalId = id;
+    state.proposalError = "";
+    publish();
+    try {
+      const result = await client.dismissPassiveLearningProposal(
+        id,
+        targetEnvironment,
+      );
+      if (
+        epoch !== environmentEpoch ||
+        targetEnvironment !== getEnvironmentId()
+      )
+        return;
+      if (result?.ok !== true)
+        throw new Error("Suggestion dismissal was not confirmed.");
+      markStale();
+    } catch (error) {
+      if (
+        epoch === environmentEpoch &&
+        targetEnvironment === getEnvironmentId()
+      )
+        state.proposalError = errorMessage(error);
+    } finally {
+      if (
+        epoch === environmentEpoch &&
+        targetEnvironment === getEnvironmentId()
+      ) {
+        state.dismissingProposalId = "";
+        publish();
+      }
+    }
+  }
+
+  return Object.freeze({
+    snapshot,
+    publish,
+    restartCollection,
+    configure: (preferences) =>
+      mutateLearningState(
+        (id) => client.configurePassiveLearning(preferences, id),
+        "Learning configuration was not confirmed.",
+      ),
+    clearPending: () =>
+      mutateLearningState(
+        (id) => client.clearPassiveLearningPending(id),
+        "Pending activity deletion was not confirmed.",
+      ),
+    selectBatch,
+    openProposal,
+    dismissProposal,
+    refresh: () => {
+      stale = true;
+      modelsStale = true;
+      return eventRefresh.run();
+    },
+    reconnect: () => {
+      state.hostConnectionKey = "";
+      markStale();
+    },
+    visibilityChanged: maybeRefresh,
+    handleRealtime(message) {
+      if (message?.type === "system-host.changed") {
+        revision += 1;
+        state.hostConnectionKey = "";
+        stale = true;
+        eventRefresh.schedule();
+        return;
+      }
+      if (message?.type !== "learning.changed") return;
+      if (message.environmentId !== getEnvironmentId()) return;
+      stale = true;
+      eventRefresh.schedule();
+    },
+    setWorkspace(nextWorkspace) {
+      const wasLearningActive = learningActive();
+      const wasHomeActive = homeActive();
+      workspace = nextWorkspace;
+      if (!wasLearningActive && learningActive()) modelsStale = true;
+      if (
+        (!wasLearningActive && learningActive()) ||
+        (!wasHomeActive && homeActive())
+      )
+        stale = true;
+      publish();
+      maybeRefresh();
+    },
+    environmentChanged: resetEnvironment,
+  });
+}