@abot-ai/runtime 1.3.1 → 1.5.0

package/dist/src/web-ui/app/lib/tool-approval-activity.js

@@ -0,0 +1,33 @@
+import { projectToolActivityEvent } from "./tool-activity-event.js";
+
+/** Older saved decisions carry approvalId but omit the execution identity. */
+export function correlateToolApprovalActivity(events, requestId) {
+  const approvals = new Map();
+  for (const event of events) {
+    if (event?.requestId !== requestId || !event.approvalId) continue;
+    const evidence = event.toolActivity || projectToolActivityEvent(event);
+    if (evidence?.name !== "tool.approval.required") continue;
+    if (evidence.executionId) approvals.set(event.approvalId, evidence);
+  }
+  return events.map((event) => {
+    if (event?.requestId !== requestId) return event;
+    const required = approvals.get(event.approvalId);
+    if (!required) return event;
+    const evidence =
+      event.toolActivity ||
+      projectToolActivityEvent({
+        ...event,
+        tool: event.tool || required.tool,
+      });
+    if (!evidence?.name.startsWith("tool.approval.")) return event;
+    return {
+      ...event,
+      toolActivity: {
+        ...evidence,
+        executionId: evidence.executionId || required.executionId,
+        executorRole: evidence.executorRole || required.executorRole,
+        roleCallId: evidence.roleCallId || required.roleCallId,
+      },
+    };
+  });
+}

package/dist/src/web-ui/app/lib/tool-computer-activity-fields.js

@@ -0,0 +1,74 @@
+const COMPUTER_ACTIONS = new Set([
+  "click",
+  "move",
+  "drag",
+  "scroll",
+  "type_text",
+  "press_keys",
+  "focus_window",
+]);
+
+function hasRecordedComputerAction(meta) {
+  return COMPUTER_ACTIONS.has(meta.computerAction);
+}
+
+function isTypedTextAction(meta) {
+  return meta.computerAction === "type_text";
+}
+
+function textField(fields, label, value, limit = 128) {
+  if (typeof value !== "string" || value.length === 0) return;
+  fields.push({ label, value: value.slice(0, limit) });
+}
+
+function numberField(fields, label, value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return;
+  fields.push({ label, value: String(value) });
+}
+
+function hasCompleteTypedText(meta, text) {
+  if (meta.computerTextLength === 0) return text === "";
+  if (meta.computerTextTruncated !== false) return false;
+  if (text.length > 4_096) return false;
+  return text.length === meta.computerTextLength;
+}
+
+function hasCompleteKeyChord(meta) {
+  if (!Array.isArray(meta.computerKeys)) return false;
+  if (meta.computerKeys.length > 8) return false;
+  if (meta.computerKeysTruncated !== false) return false;
+  return meta.computerKeys.every(
+    (key) => typeof key === "string" && key.length <= 32,
+  );
+}
+
+/** Inert plugin-declared display evidence; never infer controls from intent. */
+export function computerInputFields(meta) {
+  if (!hasRecordedComputerAction(meta)) return [];
+  const fields = [{ label: "Action", value: meta.computerAction }];
+  textField(fields, "Observation reference", meta.computerObservation);
+  textField(fields, "Window reference", meta.computerWindow);
+  numberField(fields, "Image X", meta.computerX);
+  numberField(fields, "Image Y", meta.computerY);
+  numberField(fields, "From image X", meta.computerFromX);
+  numberField(fields, "From image Y", meta.computerFromY);
+  numberField(fields, "To image X", meta.computerToX);
+  numberField(fields, "To image Y", meta.computerToY);
+  textField(fields, "Button", meta.computerButton);
+  numberField(fields, "Click count", meta.computerClickCount);
+  numberField(fields, "Duration (ms)", meta.computerDurationMs);
+  numberField(fields, "Horizontal scroll", meta.computerDeltaX);
+  numberField(fields, "Vertical scroll", meta.computerDeltaY);
+  if (isTypedTextAction(meta)) {
+    const text = typeof meta.computerText === "string" ? meta.computerText : "";
+    const label = hasCompleteTypedText(meta, text)
+      ? "Typed text"
+      : "Typed text excerpt";
+    fields.push({ label, value: text.slice(0, 4_096) });
+    numberField(fields, "Text characters", meta.computerTextLength);
+  }
+  if (hasCompleteKeyChord(meta)) {
+    fields.push({ label: "Keys", value: JSON.stringify(meta.computerKeys) });
+  }
+  return fields;
+}

package/dist/src/web-ui/app/lib/tool-permission-mode.d.ts

@@ -0,0 +1,16 @@
+import type { ToolPermissionMode } from "../../../runtime/ports.js";
+export type { ToolPermissionMode } from "../../../runtime/ports.js";
+
+export declare const TOOL_PERMISSION_MODES: readonly ToolPermissionMode[];
+export declare function normalizeToolPermissionMode(value: unknown): ToolPermissionMode;
+export declare function toolPermissionModeMeta(mode: unknown): Readonly<{
+  label: string;
+  description: string;
+  title: string;
+}>;
+export declare function supportsFullPlus(config: unknown): boolean;
+export declare function isKnownToolPermissionMode(mode: unknown): boolean;
+export declare function toolPermissionRequestError(
+  mode: unknown,
+  config: unknown,
+): { code: string; message: string } | null;

package/dist/src/web-ui/app/lib/tool-permission-mode.js

@@ -0,0 +1,60 @@
+import { textOf } from "./text-format.js";
+
+export const TOOL_PERMISSION_MODES = Object.freeze([
+  "full_access", "full_plus", "ask",
+]);
+
+const permissionMetadata = Object.freeze({
+  ask: {
+    label: "Ask",
+    description: "Require approval",
+    title: "Ask before running tools",
+  },
+  full_access: {
+    label: "Full",
+    description: "Run tools directly",
+    title: "Run tools without approval prompts",
+  },
+  full_plus: {
+    label: "FULL+",
+    description: "Full trust, including system actions",
+    title: "Full trust, including system actions; OS permissions still apply",
+  },
+});
+
+export function normalizeToolPermissionMode(value) {
+  if (value === "full_plus") return "full_plus";
+  const mode = textOf(value).trim().toLowerCase();
+  if (mode === "ask" || mode === "approval_required") return "ask";
+  return "full_access";
+}
+
+export function toolPermissionModeMeta(mode) {
+  return permissionMetadata[normalizeToolPermissionMode(mode)];
+}
+
+export function supportsFullPlus(config) {
+  if (config?.backend !== "runtime") return false;
+  if (!Array.isArray(config.supportedToolPermissionModes)) return false;
+  return config.supportedToolPermissionModes.includes("full_plus");
+}
+
+export function isKnownToolPermissionMode(mode) {
+  if (mode === "approval_required") return true;
+  return TOOL_PERMISSION_MODES.includes(mode);
+}
+
+export function toolPermissionRequestError(mode, config) {
+  if (!isKnownToolPermissionMode(mode)) {
+    return {
+      code: "unsupported_tool_permission_mode",
+      message: "The selected tool permission mode is not recognized. Select a supported mode before sending.",
+    };
+  }
+  if (mode !== "full_plus") return null;
+  if (supportsFullPlus(config)) return null;
+  return {
+    code: "full_plus_not_supported",
+    message: "This server does not advertise FULL+ support. Update the server or explicitly select Ask or Full before sending.",
+  };
+}

package/dist/src/web-ui/app/lib/tool-process-activity-fields.js

@@ -0,0 +1,102 @@
+import { titleCaseEventValue } from "./event-presentation.js";
+
+const INPUT_TEXT_LIMIT = 4_096;
+
+function textField(fields, label, value, limit = 500) {
+  if (typeof value !== "string" || value.length === 0) return;
+  const text = value.length > limit ? `${value.slice(0, limit - 1)}…` : value;
+  fields.push({ label, value: text });
+}
+
+function numberField(fields, label, value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return;
+  fields.push({ label, value: String(value) });
+}
+
+function booleanField(fields, label, value) {
+  if (typeof value !== "boolean") return;
+  fields.push({ label, value: value ? "Yes" : "No" });
+}
+
+function hasCompleteCommandText(meta) {
+  if (meta.commandTruncated !== false) return false;
+  return (
+    typeof meta.command === "string" && meta.command.length <= INPUT_TEXT_LIMIT
+  );
+}
+
+function hasUnrecordedCommandInput(meta) {
+  if (typeof meta.command === "string") return false;
+  if (!meta.params || typeof meta.params !== "object") return false;
+  return Object.hasOwn(meta.params, "command");
+}
+
+/** These are declared event fields, independent of any concrete tool identity. */
+export function processInputFields(meta) {
+  const fields = [];
+  textField(fields, "Computer", meta.computerName);
+  textField(fields, "Computer ID", meta.hostId);
+  textField(
+    fields,
+    hasCompleteCommandText(meta) ? "Command" : "Command excerpt",
+    meta.command,
+    INPUT_TEXT_LIMIT,
+  );
+  if (hasUnrecordedCommandInput(meta)) {
+    fields.push({
+      label: "Command details",
+      value: "Not recorded in this event",
+    });
+  }
+  textField(fields, "Working directory", meta.cwd, INPUT_TEXT_LIMIT);
+  textField(fields, "Process ID", meta.processId);
+  numberField(fields, "Cursor", meta.cursor);
+  textField(fields, "Application ID", meta.applicationId, INPUT_TEXT_LIMIT);
+  if (Array.isArray(meta.arguments)) {
+    const argumentsText = meta.arguments
+      .slice(0, 32)
+      .filter((value) => typeof value === "string");
+    const encodedArguments = JSON.stringify(argumentsText);
+    textField(
+      fields,
+      hasCompleteArguments(meta, encodedArguments)
+        ? "Arguments"
+        : "Arguments excerpt",
+      encodedArguments,
+      INPUT_TEXT_LIMIT,
+    );
+    numberField(fields, "Omitted arguments", meta.argumentsOmittedCount);
+  }
+  numberField(fields, "Timeout (ms)", meta.timeoutMs);
+  booleanField(fields, "Elevated", meta.elevated);
+  return fields;
+}
+
+export function processResultFields(meta) {
+  const fields = [];
+  numberField(fields, "Exit code", meta.exitCode);
+  textField(fields, "Transport", titleCaseEventValue(meta.transport));
+  textField(fields, "Process status", titleCaseEventValue(meta.processStatus));
+  textField(fields, "Evidence scope", titleCaseEventValue(meta.evidenceScope));
+  textField(
+    fields,
+    "Independent outcome check",
+    titleCaseEventValue(meta.independentOutcomeCheck),
+  );
+  textField(
+    fields,
+    "Availability scope",
+    titleCaseEventValue(meta.availabilityScope),
+  );
+  numberField(fields, "Catalog matches", meta.observedMatches);
+  numberField(fields, "Omitted matches", meta.omittedMatches);
+  booleanField(fields, "Declared catalog complete", meta.catalogComplete);
+  booleanField(fields, "Absence established", meta.absenceConclusionSupported);
+  return fields;
+}
+
+function hasCompleteArguments(meta, encodedArguments) {
+  if (meta.argumentsTruncated !== false) return false;
+  if (meta.arguments.length > 32) return false;
+  return encodedArguments.length <= INPUT_TEXT_LIMIT;
+}

package/dist/src/web-ui/app/lib/workspace-change.js

@@ -0,0 +1,34 @@
+import { normalizeRealtimeMessage } from "./realtime-message.js";
+
+export function isWorkspaceChange(message) {
+  if (message.type === "workspace_changed") return true;
+  if (message.type === "learning.changed") return true;
+  return (
+    message.type === "event" &&
+    ["scheduler.changed", "session.messages.updated"].includes(message.name)
+  );
+}
+
+export function dashboardRefreshResources(rawMessage, environmentId) {
+  const message = normalizeRealtimeMessage(rawMessage);
+  if ((message.environment || message.environmentId) !== environmentId)
+    return [];
+  if (message.type === "workspace_changed") {
+    const resources = Array.isArray(message.resources) ? message.resources : [];
+    return resources.filter(
+      (resource) => resource === "sessions" || resource === "approvals",
+    );
+  }
+  if (message.type === "event" && message.name === "scheduler.changed")
+    return ["activity", "sessions"];
+  if (message.type === "completed" || message.type === "failed")
+    return ["sessions", "approvals"];
+  if (message.type === "chat_message" || message.type === "chat_read_state")
+    return ["sessions"];
+  if (
+    message.type === "event" &&
+    ["session.title.updated", "session.messages.updated"].includes(message.name)
+  )
+    return ["sessions"];
+  return [];
+}

package/dist/src/web-ui/app/lib/workspace-route.d.ts

@@ -0,0 +1,21 @@
+export interface WorkspaceRoute {
+  workspace: string;
+  environment: string;
+  session: string;
+  category: string;
+  tab: string;
+  job: string;
+}
+
+export function readWorkspaceRoute(
+  location: Pick<Location, "pathname" | "search">,
+): WorkspaceRoute;
+
+export function workspaceRouteUrl(
+  route: Partial<WorkspaceRoute> & Record<string, unknown>,
+): string;
+
+export function configuredRouteEnvironment(
+  environmentId: string,
+  options: Array<{ value: string }>,
+): boolean;

package/dist/src/web-ui/app/lib/workspace-route.js

@@ -0,0 +1,60 @@
+import { configurationCategoryForWorkspace, legacyConfigurationWorkspace } from "./configuration-pages.js";
+
+const WORKSPACE_PATHS = Object.freeze({
+  home: "/home",
+  notifications: "/notifications",
+  chat: "/chat",
+  schedules: "/schedules",
+  learning: "/learning",
+  memory: "/memory",
+  models: "/models",
+  plugins: "/plugins",
+  config: "/system",
+});
+
+function routeParameter(parameters, name) {
+  const value = parameters.get(name) || "";
+  return value.length <= 512 ? value : "";
+}
+
+export function readWorkspaceRoute(location) {
+  const path = location.pathname.replace(/\/$/, "") || "/";
+  const requestedWorkspace = Object.keys(WORKSPACE_PATHS).find(
+    (name) => WORKSPACE_PATHS[name] === path,
+  );
+  const parameters = new URLSearchParams(location.search);
+  const requestedCategory = routeParameter(parameters, "category");
+  const workspace = path === "/config"
+    ? legacyConfigurationWorkspace(requestedCategory)
+    : requestedWorkspace || "home";
+  return {
+    workspace,
+    environment: routeParameter(parameters, "environment"),
+    session: routeParameter(parameters, "session"),
+    category: configurationCategoryForWorkspace(workspace) || "",
+    tab: routeParameter(parameters, "tab"),
+    job: routeParameter(parameters, "job"),
+  };
+}
+
+export function workspaceRouteUrl(route) {
+  const workspace = route.workspace === "config" && route.category
+    ? legacyConfigurationWorkspace(route.category)
+    : route.workspace;
+  const path = WORKSPACE_PATHS[workspace] || WORKSPACE_PATHS.home;
+  const parameters = new URLSearchParams();
+  if (route.environment) parameters.set("environment", route.environment);
+  if (workspace === "chat" && route.session)
+    parameters.set("session", route.session);
+  if (workspace === "config") {
+    if (route.tab) parameters.set("tab", route.tab);
+  }
+  if (workspace === "schedules" && route.job)
+    parameters.set("job", route.job);
+  const query = parameters.toString();
+  return query ? `${path}?${query}` : path;
+}
+
+export function configuredRouteEnvironment(environmentId, options) {
+  return options.some((option) => option.value === environmentId);
+}

package/dist/src/web-ui/app/notifications-feature.js

@@ -0,0 +1,95 @@
+import { mountNotificationsDom } from "./components/notifications/dom.js";
+import { createNotificationsWorkspace } from "./components/notifications/workspace.js";
+import { createNotificationsController } from "./controllers/notifications-controller.js";
+import { createNotificationPresence } from "./controllers/notification-presence.js";
+import { createHomeNotificationsEntry } from "./components/notifications/home-entry.js";
+import { notificationSourceUrl } from "./components/notifications/presentation.js";
+
+function isNotificationSummaryWorkspace(workspace) {
+  return ["notifications", "home"].includes(workspace);
+}
+
+export function createNotificationsFeature({ dom, state, client, shell, getEnvironmentId, send }) {
+  mountNotificationsDom(dom);
+  let view;
+  let environmentRevision = 0;
+  const homeEntry = createHomeNotificationsEntry({
+    homePanel: dom.homeWorkspacePanel,
+    onOpen: () => {
+      if (!shell.activateWorkspace("notifications")) return;
+      controller.setFilter("unread");
+    },
+  });
+  const controller = createNotificationsController({
+    client, getEnvironmentId, render: (snapshot) => {
+      view?.render(snapshot);
+      homeEntry.render(snapshot);
+      refreshAvailability();
+    },
+  });
+  const presence = createNotificationPresence({
+    getEnvironmentId,
+    getSessionId: () => state.currentSessionId,
+    getWorkspace: shell.activeWorkspace,
+    isConnected: () => state.connected && client.supportsNotifications(),
+    send,
+  });
+  function canOpenNotificationSource(item) {
+    if (!client.supportsNotifications()) return false;
+    if (item.environmentId !== getEnvironmentId()) return false;
+    return shell.activeWorkspace() === "notifications";
+  }
+  async function openNotificationSource(item) {
+    if (!canOpenNotificationSource(item)) return;
+    const source = notificationSourceUrl(item);
+    if (!source) return;
+    const environmentVersion = environmentRevision;
+    const navigationVersion = shell.navigationRevision();
+    await controller.markRead(item.id, true);
+    if (!canOpenNotificationSource(item)) return;
+    if (environmentVersion !== environmentRevision) return;
+    if (navigationVersion !== shell.navigationRevision()) return;
+    window.location.assign(source);
+  }
+  function refreshAvailability() {
+    const available = client.supportsNotifications();
+    dom.notificationsWorkspaceButton.hidden = !available;
+    dom.notificationsWorkspaceButton.disabled = !available || dom.notificationsWorkspaceButton.dataset.onboardingBlocked === "true";
+    if (available) return;
+    if (shell.activeWorkspace() !== "notifications") return;
+    shell.activateWorkspace("chat", { focus: false });
+  }
+  view = createNotificationsWorkspace({
+    root: dom.notificationsRoot,
+    button: dom.notificationsWorkspaceButton,
+    badge: dom.notificationsBadge,
+    actions: { ...controller, openSource: openNotificationSource },
+  });
+  controller.publish();
+  return {
+    ...controller,
+    refreshAvailability,
+    isWorkspaceAvailable(destination) {
+      if (destination !== "notifications") return true;
+      return client.supportsNotifications();
+    },
+    bind() {
+      presence.bind();
+      document.addEventListener("visibilitychange", controller.visibilityChanged);
+    },
+    presenceChanged: presence.changed,
+    workspaceChanged(workspace) {
+      presence.changed();
+      controller.setActive(isNotificationSummaryWorkspace(workspace));
+    },
+    environmentChanged() {
+      environmentRevision += 1;
+      presence.changed();
+      controller.environmentChanged();
+    },
+    reconnect() {
+      presence.reconnect();
+      void controller.refresh();
+    },
+  };
+}

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

@@ -0,0 +1,98 @@
+import { createMacCollectionConsent } from "./components/passive-learning/macos-collection-consent.js";
+import { createPassiveLearningController } from "./controllers/passive-learning-controller.js";
+import { createPassiveLearningHome } from "./components/passive-learning/home.js";
+import { createPassiveLearningMemory } from "./components/passive-learning/memory.js";
+import { selectLearningView } from "./components/passive-learning/workspace-view.js";
+import { createProposalNotifications } from "./components/passive-learning/proposal-notifications.js";
+import { visibleProposalSnapshot } from "./components/passive-learning/proposal-read-state.js";
+
+export function createPassiveLearningFeature({
+  client,
+  getEnvironmentId,
+  learningRoot,
+  openLearning,
+  showActivityMemories,
+  openComputerAccess,
+  openSession = () => {},
+  activateChat = () => true,
+  onChange = () => {},
+}) {
+  let home;
+  let memory;
+  let sessionSnapshot;
+  let collectionConsent;
+  function renderViews(snapshot) {
+    collectionConsent?.update(snapshot);
+    const visibleSnapshot = visibleProposalSnapshot(snapshot, sessionSnapshot);
+    home?.render(visibleSnapshot);
+    memory?.render(visibleSnapshot);
+  }
+  async function openConversation(sessionId, environmentId) {
+    if (environmentId !== getEnvironmentId()) return false;
+    if (activateChat() === false) return false;
+    await openSession(sessionId);
+    return true;
+  }
+  const controller = createPassiveLearningController({
+    client,
+    getEnvironmentId,
+    openSession: openConversation,
+    render: (snapshot) => {
+      renderViews(snapshot);
+      onChange();
+    },
+  });
+  collectionConsent = createMacCollectionConsent({
+    actions: controller,
+    container: learningRoot,
+  });
+  const actions = { ...controller, configure: collectionConsent.configure };
+  home = createPassiveLearningHome({
+    actions,
+    openLearning,
+    openComputerAccess,
+    openSetup: () => {
+      if (openLearning() === false) return;
+      if (learningRoot) selectLearningView(learningRoot, "settings");
+    },
+  });
+  memory = createPassiveLearningMemory({
+    actions,
+    showActivityMemories,
+    openComputerAccess,
+  });
+  memory.mount(learningRoot);
+  const notifications = createProposalNotifications({
+    getEnvironmentId,
+    openSession: openConversation,
+  });
+  return Object.freeze({
+    ...actions,
+    setWorkspace(workspace) {
+      collectionConsent.cancel();
+      controller.setWorkspace(workspace);
+    },
+    handleRealtime(message) {
+      if (message?.type === "system-host.changed") collectionConsent.cancel();
+      notifications.handleRealtime(message);
+      controller.handleRealtime(message);
+    },
+    environmentChanged() {
+      collectionConsent.cancel();
+      sessionSnapshot = undefined;
+      notifications.environmentChanged();
+      controller.environmentChanged();
+    },
+    updateSessions(snapshot) {
+      if (snapshot.environmentId !== getEnvironmentId()) return;
+      sessionSnapshot = snapshot;
+      renderViews(controller.snapshot());
+    },
+    mountHome: (root) => {
+      home.mount(root);
+      home.render(
+        visibleProposalSnapshot(controller.snapshot(), sessionSnapshot),
+      );
+    },
+  });
+}