@abot-ai/runtime 1.7.0 → 1.8.1

package/dist/src/web-ui/app/components/system-host/home-widget-summary.js

@@ -0,0 +1,93 @@
+import { connectionDescription, connectionStatus, connectionTitle, hostSetupIsReady } from "./rendering.js";
+import { isNativeWindowsLocalAccess, nativeWindowsAccessPresentation } from "./native-windows-access.js";
+import { computerWidgetPreview } from "./home-widget-permission-preview.js";
+import { macPermissionSummary, permissionSummary } from "./macos-permission-rendering.js";
+import { permissionsMatchConnection, permissionsMatchNativeOwner } from "./macos-permission-scopes.js";
+import { storeConnectionStage, storeConnectionDisplayContent, windowsStorePanelIsAvailable } from "./windows-store-setup.js";
+
+function currentMacPermissionStates(state) {
+  const snapshot = state.snapshot;
+  const states = [];
+  if (permissionsMatchConnection(state.macPermissions, snapshot))
+    states.push(permissionSummary(state.macPermissions));
+  if (permissionsMatchNativeOwner(state.nativeMacPermissions, snapshot, snapshot?.nativePermissions?.environmentId))
+    states.push(permissionSummary(state.nativeMacPermissions));
+  return states;
+}
+
+function hasComputerActionFailure(state) {
+  return Boolean(state.error || state.actionError || state.macPermissionError || state.nativeMacPermissionError);
+}
+
+function computerPermissionTone(state, permissionText) {
+  if (hasComputerActionFailure(state)) return "attention";
+  const status = connectionStatus(state.snapshot, state.statusUnavailable, state.busy);
+  if (["Paired · offline", "Update needed", "Computer access unavailable"].includes(status)) return "attention";
+  const states = currentMacPermissionStates(state);
+  if (states.includes("action needed")) return "attention";
+  // A connected Mac with unmeasured or unavailable permissions is not all-clear.
+  if (permissionText) return "neutral";
+  if (hostSetupIsReady(state.snapshot)) return "success";
+  return "neutral";
+}
+
+function windowsStoreTone(state, stage) {
+  if (hasComputerActionFailure(state)) return "attention";
+  if (state.busy) return "neutral";
+  const tones = { ready: "success", reconnect: "attention", expired: "attention", "confirm-repair": "attention", preparing: "active", repairing: "active", waiting: "active", open: "active" };
+  return tones[stage] || "neutral";
+}
+
+function nativeWindowsTone(state, status) {
+  if (hasComputerActionFailure(state)) return "attention";
+  if (status === "Check needed") return "attention";
+  return "neutral";
+}
+
+function windowsStoreSummary(state) {
+  const snapshot = state.snapshot;
+  const invitation = state.windowsStoreInvitation;
+  const stage = storeConnectionStage(snapshot, invitation, state.windowsStoreAttempt);
+  const content = storeConnectionDisplayContent(stage, snapshot, invitation, state.busy, state.statusUnavailable);
+  return {
+    title: snapshot.identity?.name || content.step,
+    detail: state.error || state.actionError || state.message || content.copy,
+    status: content.status,
+    tone: windowsStoreTone(state, stage),
+  };
+}
+
+/** Connection and process-bound permission receipts stay separate facts. */
+export function computerAccessWidgetSummary(state = {}, supported = true) {
+  const input = { ...state, supported };
+  if (!supported)
+    return { title: "Computer connection unavailable", detail: "Computer access setup requires the local Runtime backend.", status: "Unavailable", tone: "neutral" };
+  if (state.statusUnavailable)
+    return { title: "Check your computer connection", detail: "The current connection status could not be checked.", status: "Status unavailable", tone: "attention" };
+  if (!state.snapshot)
+    return { title: "Checking this computer…", detail: "", status: "Checking", tone: "neutral" };
+  if (isNativeWindowsLocalAccess(state.snapshot)) {
+    const presentation = nativeWindowsAccessPresentation(input);
+    return {
+      title: presentation.title,
+      detail: state.error || state.actionError || state.message || presentation.description,
+      status: presentation.status,
+      tone: nativeWindowsTone(state, presentation.status),
+    };
+  }
+  if (windowsStorePanelIsAvailable(state.snapshot)) return windowsStoreSummary(state);
+  const permissionText = macPermissionSummary(state.snapshot, state.macPermissions, state.nativeMacPermissions);
+  const title = state.snapshot.identity?.name || connectionTitle(input);
+  if (state.busy)
+    return { title, detail: "Waiting for the current connection status…", status: "Checking", tone: "neutral" };
+  const feedback = state.error || state.actionError || state.macPermissionError || state.nativeMacPermissionError || state.message;
+  const status = connectionStatus(state.snapshot, state.statusUnavailable, state.busy);
+  const preview = feedback ? null : computerWidgetPreview(state, title, status);
+  return {
+    title,
+    detail: feedback || permissionText || connectionDescription(input),
+    status,
+    tone: computerPermissionTone(state, permissionText),
+    ...(preview ? { preview } : {}),
+  };
+}

package/dist/src/web-ui/app/components/system-host/macos-permission-rendering.js

@@ -1,12 +1,12 @@
 import { escapeHtml } from "../../lib/text-format.js";
 import { canCheckMacPermissions, canCheckNativePermissions, permissionsMatchConnection, permissionsMatchNativeOwner } from "./macos-permission-scopes.js";
 
-function hasNativePermissionSurface(snapshot) {
+export function hasNativePermissionSurface(snapshot) {
   if (snapshot?.identity?.os === "macos") return true;
   if (!snapshot?.nativePermissions) return false;
   return snapshot.nativePermissions.reason !== "native_macos_unavailable";
 }
-function permissionSummary(receipt) {
+export function permissionSummary(receipt) {
   if (!receipt) return "not checked";
   if (receipt.permissions.screenRecording !== "granted") return "action needed";
   if (receipt.permissions.accessibility !== "granted") return "action needed";

package/dist/src/web-ui/app/components/system-host/macos-permissions.js

@@ -6,6 +6,7 @@ function hasManagedMacPermissionRuntime(version) {
 }
 
 export function macCompanionPermissionPath(snapshot) {
+  if (snapshot?.collectionSource?.mode === "native") return "";
   if (!snapshot?.paired) return "";
   if (snapshot.identity?.os !== "macos") return "";
   if (!hasManagedMacPermissionRuntime(snapshot.companion?.installedVersion))
@@ -20,6 +21,7 @@ export function macCompanionPermissionPath(snapshot) {
 
 /** The managed companion keeps its macOS permission subject at one private path. */
 export function renderMacPermissionGuide(snapshot) {
+  if (snapshot?.collectionSource?.mode === "native") return "";
   if (!snapshot?.paired) return "";
   if (snapshot.identity?.os !== "macos") return "";
   const version = snapshot.companion?.installedVersion;

package/dist/src/web-ui/app/components/system-host/native-windows-access.js

@@ -0,0 +1,50 @@
+import { renderConnectionCard } from "./connection-card.js";
+
+/** The server's native Windows facts identify local access, independently of tool readiness. */
+export function isNativeWindowsLocalAccess(snapshot) {
+  if (snapshot?.collectionSource?.mode !== "native") return false;
+  return snapshot.collectionSource.platform === "windows";
+}
+
+export function shouldRenderNativeWindowsAccess(input) {
+  if (!input.supported) return false;
+  return isNativeWindowsLocalAccess(input.snapshot);
+}
+
+export function nativeWindowsAccessPresentation(input) {
+  if (input.statusUnavailable) return {
+    title: "Check Windows access", status: "Status unavailable",
+    description: "The current local access status could not be checked. Refresh to try again.",
+  };
+  if (input.busy) return {
+    title: "Checking Windows access…", status: "Checking",
+    description: "Waiting for the current local access status…",
+  };
+  if (input.snapshot?.readiness?.directAccessReady === false) return {
+    title: "Check local Windows access", status: "Check needed",
+    description: "ABot runs directly on Windows, but direct commands could not be verified. Refresh to check again. Companion pairing is not required for local tools.",
+  };
+  return {
+    title: "Windows access is local", status: "Local",
+    description: "ABot runs directly on this Windows computer. Local tools do not need Companion pairing. Compatible plugins and your permission settings determine which actions are available.",
+  };
+}
+
+function canCompactNativeWindowsAccess(input) {
+  if (!input.compact) return false;
+  if (input.statusUnavailable || input.busy) return false;
+  if (input.error || input.message) return false;
+  return input.snapshot?.readiness?.directAccessReady !== false;
+}
+
+export function renderNativeWindowsAccess(input) {
+  const presentation = nativeWindowsAccessPresentation(input);
+  const compact = canCompactNativeWindowsAccess(input);
+  return renderConnectionCard({
+    ...presentation, ready: false, compact, disabled: input.busy,
+    actions: '<button type="button" class="system-host-card-secondary" data-system-host-refresh' +
+      (input.busy ? " disabled" : "") + '>Refresh status</button>',
+    error: input.error, message: input.message,
+    attributes: "data-system-host-native-windows",
+  });
+}

package/dist/src/web-ui/app/components/system-host/rendering.js

@@ -1,6 +1,7 @@
 import { escapeHtml } from "../../lib/text-format.js";
 import { renderWindowsStoreSetup, windowsStorePanelIsAvailable } from "./windows-store-setup.js";
 import { renderConnectionCard, renderComputerMetadata } from "./connection-card.js";
+import { shouldRenderNativeWindowsAccess, renderNativeWindowsAccess } from "./native-windows-access.js";
 import { macPermissionSummary, renderMacPermissionPreparation } from "./macos-permission-rendering.js";
 import {
   renderMacSetupAction,
@@ -22,7 +23,7 @@ function pairedCompanionIsOffline(snapshot) {
 function hasDirectAccess(snapshot) {
   return ["native", "wsl_interop"].includes(snapshot?.readiness?.route);
 }
-function connectionStatus(snapshot, statusUnavailable, busy) {
+export function connectionStatus(snapshot, statusUnavailable, busy) {
   if (statusUnavailable) return "Status unavailable";
   if (busy || !snapshot) return "Checking";
   if (hostSetupIsReady(snapshot)) return snapshot.identity?.os === "macos" ? "Connected" : "Ready";
@@ -41,7 +42,7 @@ function readyDescription(snapshot) {
     return "Direct commands are available. No extra installation is needed for direct commands.";
   return "You can use computer tools from your ABot chat. Permissions and Spark collection are managed separately.";
 }
-function connectionTitle({ snapshot, supported, statusUnavailable, busy }) {
+export function connectionTitle({ snapshot, supported, statusUnavailable, busy }) {
   if (!supported) return "Computer connection unavailable";
   if (statusUnavailable) return "Check your computer connection";
   if (busy || !snapshot) return "Checking this computer…";
@@ -54,7 +55,7 @@ function connectionTitle({ snapshot, supported, statusUnavailable, busy }) {
   if (platforms.length === 1 && platforms[0] === "linux") return "Connect your Linux computer";
   return "Connect your computer";
 }
-function connectionDescription({ snapshot, supported, statusUnavailable, busy }) {
+export function connectionDescription({ snapshot, supported, statusUnavailable, busy }) {
   if (!supported) return "Computer access setup requires the local Runtime backend.";
   if (statusUnavailable) return "The current connection status could not be checked. Refresh to try again.";
   if (busy || !snapshot) return "Waiting for the current connection status…";
@@ -123,6 +124,8 @@ function canRenderCompactConnection(input) {
   return true;
 }
 export function renderSystemHostConnection(input) {
+  if (shouldRenderNativeWindowsAccess(input))
+    return renderNativeWindowsAccess(input);
   if (input.supported && windowsStorePanelIsAvailable(input.snapshot)) {
     return renderWindowsStoreSetup({
       snapshot: input.snapshot, invitation: input.windowsStoreInvitation,

package/dist/src/web-ui/app/components/system-host/windows-store-setup.js

@@ -41,7 +41,7 @@ function storeRepairConfirmationIsCurrent(snapshot, attempt) {
   return attempt?.phase === "confirm-repair";
 }
 
-function storeConnectionStage(snapshot, invitation, attempt) {
+export function storeConnectionStage(snapshot, invitation, attempt) {
   if (snapshot?.readiness?.ready === true) return "ready";
   if (attempt?.phase === "repairing") return "repairing";
   if (storeRepairConfirmationIsCurrent(snapshot, attempt)) return "confirm-repair";
@@ -111,7 +111,7 @@ function connectionStageContent(stage, snapshot, invitation, disabled) {
   };
 }
 
-function storeConnectionDisplayContent(stage, snapshot, invitation, disabled, statusUnavailable) {
+export function storeConnectionDisplayContent(stage, snapshot, invitation, disabled, statusUnavailable) {
   if (statusUnavailable) return {
     status: "Status unavailable", step: "Check your computer connection",
     copy: "The current connection status could not be checked. Refresh to try again.",

package/dist/src/web-ui/app/components/workspace-storage-notice.js

@@ -0,0 +1,37 @@
+export async function acknowledgeWorkspaceStorage(storage, documentRoot = document) {
+  if (storage.snapshot().introductionSeen) return;
+  const dialog = documentRoot.createElement("dialog");
+  dialog.className = "workspace-storage-notice";
+  dialog.innerHTML = `<h2>Your workspace settings stay with ABot</h2>
+    <p>Settings and queued messages are now saved with this ABot installation, across browsers and app restarts.</p>
+    <p>This is a one-time fresh start. Previous browser-only pins, archives, model choices, memory review markers and queued messages are not imported.</p>
+    <p>Your conversations, memories, configuration and read status are kept. Tool permissions start in <strong>Ask</strong>; you can change them in the composer.</p>
+    <p role="alert" hidden></p><button type="button" class="primary">Continue</button>`;
+  documentRoot.body.append(dialog);
+  dialog.addEventListener("cancel", (event) => event.preventDefault());
+  dialog.showModal();
+  await new Promise((resolve) => {
+    const button = dialog.querySelector("button");
+    button.addEventListener("click", async () => {
+      button.disabled = true;
+      try { await storage.execute({ kind: "introduction" }); dialog.close(); dialog.remove(); resolve(); }
+      catch (error) {
+        const notice = dialog.querySelector('[role="alert"]');
+        notice.textContent = `${error.message} Reload to try again.`;
+        notice.hidden = false;
+      }
+    });
+  });
+}
+
+export function showWorkspaceStorageFailure(error, documentRoot = document) {
+  let notice = documentRoot.querySelector("[data-workspace-storage-error]");
+  if (!notice) {
+    notice = documentRoot.createElement("div");
+    notice.dataset.workspaceStorageError = "";
+    notice.setAttribute("role", "alert");
+    notice.className = "workspace-storage-failure";
+    documentRoot.body.append(notice);
+  }
+  notice.textContent = `${error.message} Changes are not confirmed. Reload before sending more messages.`;
+}

package/dist/src/web-ui/app/computer-access-feature.js

@@ -1,5 +1,6 @@
 import { createSystemHostConnectionManager } from "./components/system-host/manager.js";
 import { createSystemHostSetupNotice } from "./components/system-host/setup-notice.js";
+import { computerAccessWidgetSummary } from "./components/system-host/home-widget-summary.js";
 
 /** One connection owner for configured Home and its shared chat notice. */
 export function createComputerAccessFeature({
@@ -7,11 +8,13 @@ export function createComputerAccessFeature({
   runtimeClient,
   getEnvironmentId = () => "",
   isComputerAccessAvailable = () => true,
+  compactHomeWidgets,
   onChange = () => {},
 }) {
   const documentRoot = dom.homeDashboardRoot?.ownerDocument;
   const root = documentRoot?.createElement("section");
   let notice;
+  let unregisterWidget = () => {};
   const connection = createSystemHostConnectionManager({
     documentRoot,
     compact: true,
@@ -27,6 +30,7 @@ export function createComputerAccessFeature({
     supportsConnection: () => runtimeClient.supportsSystemHostConnection(),
     onChange: () => {
       notice?.render();
+      compactHomeWidgets?.refresh();
       onChange();
     },
   });
@@ -35,7 +39,7 @@ export function createComputerAccessFeature({
     if (!isComputerAccessAvailable()) return false;
     dom.homeWorkspaceButton?.click();
     if (dom.homeWorkspacePanel?.hidden !== false || !root) return false;
-    connection.openManagement();
+    if (!compactHomeWidgets?.open("computer")) connection.openManagement();
     root.scrollIntoView?.({ block: "start", behavior: "smooth" });
     root.focus({ preventScroll: true });
     return true;
@@ -45,6 +49,7 @@ export function createComputerAccessFeature({
     const ready = isComputerAccessAvailable();
     if (root) root.hidden = !ready;
     connection.setActive(ready);
+    compactHomeWidgets?.refresh();
     notice?.render();
   }
 
@@ -71,6 +76,12 @@ export function createComputerAccessFeature({
       dom.homeDashboardRoot,
     );
     connection.mount(root);
+    unregisterWidget = compactHomeWidgets?.register({
+      id: "computer", label: "Computer access", icon: "computer", element: root,
+      isAvailable: isComputerAccessAvailable,
+      getSummary: () => computerAccessWidgetSummary(connection.state, runtimeClient.supportsSystemHostConnection()),
+      onOpen: connection.openManagement,
+    }) || unregisterWidget;
     runtimeAvailabilityChanged();
   }
   dom.environmentSelect?.addEventListener("change", connection.environmentChanged);
@@ -80,6 +91,7 @@ export function createComputerAccessFeature({
     open,
     runtimeAvailabilityChanged,
     dispose() {
+      unregisterWidget();
       dom.environmentSelect?.removeEventListener("change", connection.environmentChanged);
       notice.dispose();
       connection.dispose();

package/dist/src/web-ui/app/configuration-environment-refresh.js

@@ -6,6 +6,7 @@ export function createAppliedEnvironmentProjection({
   dom,
   selection,
   loadWebConfig,
+  changeEnvironment,
 }) {
   let generation = 0;
   let pending = null;
@@ -23,11 +24,10 @@ export function createAppliedEnvironmentProjection({
     );
   }
 
-  function restoreProjection(config, selected) {
+  function applyProjection(config, selected) {
     state.config = config;
     selection.renderEnvironmentOptions();
     dom.environmentSelect.value = selected;
-    selection.renderAgentPicker();
   }
 
   function preferredEnvironmentId(options, selected, defaultId) {
@@ -36,45 +36,36 @@ export function createAppliedEnvironmentProjection({
     return options[0]?.value || "";
   }
 
-  function changeProjectedEnvironment(
-    next,
-    previousConfig,
-    previousEnvironment,
-  ) {
-    const ChangeEvent = dom.environmentSelect.ownerDocument.defaultView.Event;
-    dom.environmentSelect.dispatchEvent(new ChangeEvent("change"));
-    if (dom.environmentSelect.value === next) return true;
-    restoreProjection(previousConfig, previousEnvironment);
-    // Existing listeners also own composer/environment presentation after a refusal.
-    dom.environmentSelect.dispatchEvent(new ChangeEvent("change"));
-    return false;
-  }
-
-  function flush() {
+  async function flush() {
     if (!pending) return "unchanged";
-    const previousConfig = state.config;
     const previousEnvironment = selection.selectedEnvironmentId();
-    state.config = pending;
-    selection.renderEnvironmentOptions();
+    const projected = pending;
+    const revision = generation;
     const next = preferredEnvironmentId(
-      selection.environmentOptions(),
+      selection.configuredEnvironmentOptions(projected),
       previousEnvironment,
-      textOf(pending.defaultEnvironmentId).trim(),
+      textOf(projected.defaultEnvironmentId).trim(),
     );
-    if (!next) {
-      restoreProjection(previousConfig, previousEnvironment);
-      return "blocked";
-    }
-    dom.environmentSelect.value = next;
-    const unchanged = next === previousEnvironment;
-    if (unchanged) {
+    if (!next) return "blocked";
+    if (next === previousEnvironment) {
+      applyProjection(projected, next);
       pending = null;
       selection.renderAgentPicker();
       return "unchanged";
     }
-    if (!changeProjectedEnvironment(next, previousConfig, previousEnvironment))
-      return "blocked";
-    pending = null;
+    // Keep the old catalog and selected option until draft preparation commits.
+    const commitEnvironmentOptions = () => {
+      applyProjection(projected, next);
+      pending = null;
+    };
+    commitEnvironmentOptions.canCommit = () => {
+      if (revision !== generation) return false;
+      return pending === projected;
+    };
+    let accepted = false;
+    try { accepted = await changeEnvironment(next, { commitEnvironmentOptions }); }
+    catch { /* The old catalog remains active when draft persistence fails. */ }
+    if (!accepted) return "blocked";
     selection.renderAgentPicker();
     return "changed";
   }
@@ -87,6 +78,7 @@ export function createConfigurationFeature({
   state,
   selection,
   onConfigurationApplied,
+  changeEnvironment,
   ...options
 }) {
   const projection = createAppliedEnvironmentProjection({
@@ -94,6 +86,7 @@ export function createConfigurationFeature({
     dom: options.dom,
     selection,
     loadWebConfig: () => options.runtimeClient.loadWebConfig(),
+    changeEnvironment,
   });
   const workspace = createWorkspaceFeature({
     ...options,
@@ -101,13 +94,13 @@ export function createConfigurationFeature({
       const currentStillConfigured = await projection.prepare();
       if (currentStillConfigured) await onConfigurationApplied();
     },
-    onConfigurationSettled: () => projection.flush() !== "blocked",
+    onConfigurationSettled: async () => await projection.flush() !== "blocked",
   });
   return {
     ...workspace,
     async reloadAppliedEnvironmentModels() {
       await projection.prepare();
-      const result = projection.flush();
+      const result = await projection.flush();
       if (result === "blocked") return false;
       if (result === "changed") return true;
       const refreshed = await workspace.load();

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

@@ -22,6 +22,7 @@ export function createConfigurationFeature({
   getLearningSnapshot = () => null,
   isRuntimeReady = () => true,
   isComputerAccessAvailable = () => true,
+  compactHomeWidgets,
 }) {
   let configWorkspace;
   let activation;
@@ -107,6 +108,7 @@ export function createConfigurationFeature({
   let homeSetupSuggestion;
   const computerAccess = createComputerAccessFeature({
     dom,
+    compactHomeWidgets,
     runtimeClient,
     getEnvironmentId: selectedEnvironmentId,
     isComputerAccessAvailable,
@@ -278,7 +280,15 @@ export function createConfigurationFeature({
           "Finish or cancel model setup before leaving configuration.";
         return null;
       }
-      return prepareDiscardChanges(...args);
+      const prepared = prepareDiscardChanges(...args);
+      if (typeof prepared !== "function") return prepared;
+      const commit = () => prepared();
+      commit.canCommit = () => {
+        if (pluginManager.hasConfigurationDraft()) return false;
+        if (modelSetup.isOpen()) return false;
+        return prepared.canCommit?.() !== false;
+      };
+      return commit;
     },
   };
 }