@abot-ai/runtime 1.3.1 → 1.4.0

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

@@ -0,0 +1,38 @@
+/** Save a setup file without retaining its authorization material. */
+export function downloadHostSetup(
+  receipt,
+  {
+    documentRoot = globalThis.document,
+    urlApi = globalThis.URL,
+    decode = globalThis.atob,
+    createBlob = (parts, options) => new Blob(parts, options),
+    defer = (callback) => setTimeout(callback, 1000),
+  } = {},
+) {
+  if (!isSetupDownloadReceipt(receipt))
+    throw new Error("Invalid setup download.");
+  const bytes = Uint8Array.from(decode(receipt.contentBase64), (value) =>
+    value.charCodeAt(0),
+  );
+  const url = urlApi.createObjectURL(
+    createBlob([bytes], { type: receipt.mimeType }),
+  );
+  const link = documentRoot.createElement("a");
+  try {
+    link.href = url;
+    link.download = receipt.filename;
+    link.hidden = true;
+    documentRoot.body.append(link);
+    link.click();
+  } finally {
+    link.remove();
+    defer(() => urlApi.revokeObjectURL(url));
+  }
+}
+function isSetupDownloadReceipt(receipt) {
+  if (typeof receipt?.filename !== "string") return false;
+  if (!/^[a-z0-9][a-z0-9._-]{0,119}$/iu.test(receipt.filename)) return false;
+  if (typeof receipt.mimeType !== "string") return false;
+  if (typeof receipt.contentBase64 !== "string") return false;
+  return receipt.contentBase64.length <= 8 * 1024 * 1024;
+}

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

@@ -0,0 +1,249 @@
+import { downloadHostSetup } from "./download.js";
+import { hostSetupIsReady, renderSystemHostConnection } from "./rendering.js";
+import { createSystemHostVisibility } from "./visibility.js";
+
+export function createSystemHostConnectionManager({
+  loadConnection,
+  downloadSetup,
+  revokeConnection,
+  supportsConnection = () => true,
+  saveDownload = downloadHostSetup,
+  documentRoot = globalThis.document,
+  onChange = () => {},
+  schedulePoll = (callback, delay) => setTimeout(callback, delay),
+  cancelPoll = (timer) => clearTimeout(timer),
+}) {
+  const state = {
+    root: null,
+    snapshot: null,
+    active: false,
+    busy: false,
+    error: "",
+    actionError: "",
+    message: "",
+    statusUnavailable: false,
+    downloaded: null,
+  };
+  let revision = 0;
+  let pollTimer;
+  let wasVisible = false;
+  let surfaceRevision = 0;
+  let backgroundPending = false;
+  let lastNotification = "";
+  const visibility = createSystemHostVisibility({
+    documentRoot,
+    getRoot: () => state.root,
+    isActive: () => state.active,
+    onChange: visibilityChanged,
+  });
+  function markup() {
+    return renderSystemHostConnection({
+      ...state,
+      error: state.error || state.actionError,
+      supported: supportsConnection(),
+    });
+  }
+  function afterPaint(root = state.root) {
+    root
+      ?.querySelector("[data-system-host-refresh]")
+      ?.addEventListener("click", () => void load());
+    root
+      ?.querySelector("[data-system-host-revoke]")
+      ?.addEventListener("click", () => void revoke());
+    for (const button of root?.querySelectorAll?.(
+      "[data-system-host-install]",
+    ) || []) {
+      button.addEventListener(
+        "click",
+        () => void install(button.dataset.systemHostInstall),
+      );
+    }
+  }
+  function render() {
+    if (!state.root) return;
+    state.root.innerHTML = markup();
+    afterPaint();
+  }
+  function notify() {
+    const content = markup();
+    if (content === lastNotification) return;
+    lastNotification = content;
+    render();
+    onChange();
+  }
+  function stopPolling() {
+    if (pollTimer !== undefined) cancelPoll(pollTimer);
+    pollTimer = undefined;
+  }
+  function scheduleNextPoll() {
+    stopPolling();
+    if (!visibility.isVisible()) return;
+    if (!supportsConnection()) return;
+    pollTimer = schedulePoll(() => {
+      pollTimer = undefined;
+      void load(true);
+    }, 3000);
+  }
+  function visibilityChanged() {
+    const visible = visibility.isVisible();
+    const becameVisible = visible && !wasVisible;
+    if (!visible && wasVisible) surfaceRevision += 1;
+    wasVisible = visible;
+    if (!visible) {
+      stopPolling();
+      return;
+    }
+    if (becameVisible) void load();
+  }
+  function isCurrentResponse(operation) {
+    return operation === revision;
+  }
+  function beginRequest(background = false) {
+    stopPolling();
+    state.busy = !background;
+    backgroundPending = background;
+    if (!background) state.error = "";
+    if (!background) state.actionError = "";
+    notify();
+    return ++revision;
+  }
+  function finishRequest(operation) {
+    if (!isCurrentResponse(operation)) return;
+    state.busy = false;
+    backgroundPending = false;
+    notify();
+    scheduleNextPoll();
+  }
+  async function load(background = false) {
+    if (state.busy) return false;
+    const backgroundAlreadyLoading = background && backgroundPending;
+    if (backgroundAlreadyLoading) return false;
+    if (!supportsConnection()) {
+      state.snapshot = null;
+      notify();
+      return false;
+    }
+    const operation = beginRequest(background);
+    try {
+      const snapshot = await loadConnection();
+      if (!isCurrentResponse(operation)) return false;
+      state.snapshot = snapshot;
+      state.statusUnavailable = false;
+      state.error = "";
+      if (hostSetupIsReady(snapshot)) {
+        state.downloaded = null;
+        state.message = "";
+        state.actionError = "";
+      }
+      return true;
+    } catch {
+      if (!isCurrentResponse(operation)) return false;
+      state.statusUnavailable = true;
+      state.error = state.downloaded?.restartRequired
+        ? "Waiting for WSL and ABot to return after setup."
+        : "Could not check this computer. Refresh to try again.";
+      return false;
+    } finally {
+      finishRequest(operation);
+    }
+  }
+  function canInstallOnPlatform(platform) {
+    if (state.busy) return false;
+    if (!visibility.isVisible()) return false;
+    if (!supportsConnection()) return false;
+    if (hostSetupIsReady(state.snapshot)) return false;
+    return state.snapshot?.readiness?.platforms?.includes(platform) === true;
+  }
+  function setupDownloadErrorMessage(error) {
+    if (typeof error?.message !== "string")
+      return "Setup could not be downloaded. Try again.";
+    const message = error.message.trim().slice(0, 500);
+    return message || "Setup could not be downloaded. Try again.";
+  }
+  async function install(platform) {
+    if (!canInstallOnPlatform(platform)) return false;
+    const operation = beginRequest();
+    const surface = surfaceRevision;
+    try {
+      const receipt = await downloadSetup(platform);
+      if (!isCurrentResponse(operation)) return false;
+      if (surface !== surfaceRevision) return false;
+      if (!visibility.isVisible()) return false;
+      await saveDownload(receipt);
+      state.downloaded = {
+        filename: receipt.filename,
+        expiresAt: receipt.expiresAt,
+        restartRequired: receipt.restartRequired === true,
+      };
+      state.message =
+        "Setup downloaded. Open the downloaded file and follow its instructions. Waiting for verification…";
+      return true;
+    } catch (error) {
+      if (isCurrentResponse(operation))
+        state.actionError = setupDownloadErrorMessage(error);
+      return false;
+    } finally {
+      finishRequest(operation);
+    }
+  }
+  async function revoke() {
+    if (state.busy) return false;
+    if (!supportsConnection()) return false;
+    const operation = beginRequest();
+    try {
+      const snapshot = await revokeConnection();
+      if (!isCurrentResponse(operation)) return false;
+      state.snapshot = snapshot;
+      state.downloaded = null;
+      state.statusUnavailable = false;
+      state.message = "Computer access revoked.";
+      return true;
+    } catch {
+      if (isCurrentResponse(operation))
+        state.error = "Computer access could not be revoked. Try again.";
+      return false;
+    } finally {
+      finishRequest(operation);
+    }
+  }
+  function setActive(active) {
+    state.active = active;
+    visibilityChanged();
+  }
+  function reset() {
+    revision += 1;
+    state.busy = false;
+    backgroundPending = false;
+    lastNotification = "";
+    state.active = false;
+    state.snapshot = null;
+    state.statusUnavailable = false;
+    state.downloaded = null;
+    state.error = "";
+    state.actionError = "";
+    state.message = "";
+    stopPolling();
+    wasVisible = false;
+  }
+  return {
+    state,
+    load,
+    install,
+    revoke,
+    markup,
+    afterPaint,
+    setActive,
+    reset,
+    mount(root) {
+      state.root = root;
+      visibility.watch();
+      render();
+      visibilityChanged();
+    },
+    dispose() {
+      reset();
+      visibility.dispose();
+      state.root = null;
+    },
+  };
+}

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

@@ -0,0 +1,88 @@
+import { escapeHtml } from "../../lib/text-format.js";
+
+export function hostSetupIsReady(snapshot) {
+  if (snapshot?.readiness) return snapshot.readiness.ready === true;
+  return snapshot?.connected === true;
+}
+function connectionStatus(snapshot, statusUnavailable, busy) {
+  if (statusUnavailable) return "Status unavailable";
+  if (busy || !snapshot) return "Checking this computer…";
+  if (hostSetupIsReady(snapshot)) return "Ready";
+  if (snapshot.paired) return "Paired · offline";
+  return "Setup needed";
+}
+function readyDescription(snapshot) {
+  if (snapshot?.readiness?.route === "native")
+    return "ABot can already use this computer. No extra installation is needed.";
+  if (snapshot?.readiness?.route === "wsl_interop")
+    return "Windows access through WSL is ready. No extra installation is needed.";
+  return "Your computer is connected and ready.";
+}
+function renderIdentity(snapshot) {
+  const identity = snapshot?.identity || {};
+  const fields = [
+    ["Computer", identity.name],
+    ["Operating system", identity.os],
+    ["User", identity.user],
+    ["Computer ID", snapshot?.hostId],
+  ];
+  return `<dl class="system-host-identity">${fields
+    .filter(([, value]) => typeof value === "string" && value.length > 0)
+    .map(
+      ([label, value]) =>
+        `<div><dt>${escapeHtml(label)}</dt><dd>${escapeHtml(value)}</dd></div>`,
+    )
+    .join("")}</dl>`;
+}
+function renderSetupActions(snapshot, disabled) {
+  if (hostSetupIsReady(snapshot)) return "";
+  const platforms = snapshot?.readiness?.platforms || [];
+  const labels = {
+    windows: "Set up Windows access",
+    macos: "Set up Mac access",
+  };
+  return platforms
+    .filter((platform) => Object.hasOwn(labels, platform))
+    .map(
+      (platform) =>
+        `<button type="button" data-system-host-install="${platform}" ${disabled ? "disabled" : ""}>${labels[platform]}</button>`,
+    )
+    .join("");
+}
+function hasInstallablePlatform(snapshot) {
+  if (hostSetupIsReady(snapshot)) return false;
+  return (
+    snapshot?.readiness?.platforms?.some((platform) =>
+      ["windows", "macos"].includes(platform),
+    ) === true
+  );
+}
+function setupDownloadHasExpired(downloaded) {
+  if (!downloaded?.expiresAt) return false;
+  return Date.parse(downloaded.expiresAt) <= Date.now();
+}
+export function renderSystemHostConnection({
+  snapshot,
+  supported,
+  busy,
+  error,
+  message,
+  statusUnavailable,
+  downloaded,
+}) {
+  const ready = hostSetupIsReady(snapshot);
+  const restart = snapshot?.readiness?.restartRequired === true;
+  return `<section class="system-host-panel" aria-label="Connected computer" aria-busy="${busy ? "true" : "false"}">
+    <div class="system-host-heading"><div><h2>Computer access</h2><p>Use applications and system commands on your computer.</p></div><button type="button" data-system-host-refresh ${busy || !supported ? "disabled" : ""}>Refresh status</button></div>
+    <p class="system-host-note">Shared by all environments in this ABot installation. Your selected tools and ASK, Full or Full+ mode still apply.</p>
+    <p class="system-host-status" role="status">${supported ? connectionStatus(snapshot, statusUnavailable, busy) : "Computer access setup requires the local Runtime backend."}</p>
+    ${ready && !statusUnavailable && !busy ? `<p>${readyDescription(snapshot)}</p>` : ""}
+    ${renderIdentity(snapshot)}
+    ${!ready && snapshot?.readiness?.message ? `<p class="system-host-note">${escapeHtml(snapshot.readiness.message)}</p>` : ""}
+    ${hasInstallablePlatform(snapshot) && supported ? "<p>Download setup for the computer hosting ABot, then open the downloaded file. It installs what is needed and connects automatically. Follow any permission prompts shown by your operating system.</p>" : ""}
+    ${restart ? '<p class="system-host-restart" role="note">Opening the setup file enables Windows access and automatically restarts the selected WSL distribution. This interrupts its services and conversations. Finish active work before opening the setup file.</p>' : ""}
+    ${downloaded ? `<div class="system-host-download"><p><strong>Downloaded:</strong> ${escapeHtml(downloaded.filename)}</p><p>${setupDownloadHasExpired(downloaded) ? "Setup download expired. Download setup again." : "Open this file to continue. A download alone does not mean access is ready."}</p>${downloaded.expiresAt && !setupDownloadHasExpired(downloaded) ? `<p class="system-host-note">Open before ${escapeHtml(new Date(downloaded.expiresAt).toLocaleTimeString())}.</p>` : ""}</div>` : ""}
+    <div class="${error ? "error-text" : "system-host-note"}" role="${error ? "alert" : "status"}" aria-live="polite">${escapeHtml(error || message || "")}</div>
+    <div class="system-host-actions">${supported ? renderSetupActions(snapshot, busy) : ""}${snapshot?.paired ? `<button type="button" data-system-host-revoke ${busy ? "disabled" : ""}>Disconnect computer</button>` : ""}</div>
+  </section>`;
+}

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

@@ -0,0 +1,87 @@
+import { createSystemHostVisibility } from "./visibility.js";
+
+function needsComputerSetup(state) {
+  if (!state || state.busy || state.statusUnavailable) return false;
+  const snapshot = state.snapshot;
+  const readiness = snapshot?.readiness;
+  if (snapshot?.paired || readiness?.ready !== false) return false;
+  if (readiness.route !== "setup_required") return false;
+  if (!["container", "wsl"].includes(readiness.environment)) return false;
+  if (!Array.isArray(readiness.platforms)) return false;
+  return readiness.platforms.some((platform) =>
+    ["windows", "macos"].includes(platform),
+  );
+}
+
+export function createSystemHostSetupNotice({
+  container,
+  conversationRegion,
+  getConnectionState,
+  supportsConnection = () => true,
+  refreshConnection = () => {},
+  onOpen = () => {},
+}) {
+  const root = container?.ownerDocument?.createElement("aside");
+  if (!root) return { render() {}, dispose() {} };
+  let dismissed = false;
+  let disposed = false;
+  const visibility = createSystemHostVisibility({
+    documentRoot: container.ownerDocument,
+    getRoot: () => conversationRegion,
+    isActive: () => Boolean(conversationRegion),
+    onChange: visibilityChanged,
+  });
+  let wasVisible = visibility.isVisible();
+  visibility.watch();
+
+  function visibilityChanged() {
+    if (disposed) return;
+    const visible = visibility.isVisible();
+    const becameVisible = visible && !wasVisible;
+    wasVisible = visible;
+    if (becameVisible && supportsConnection()) void refreshConnection();
+  }
+  root.className = "system-host-setup-notice";
+  root.setAttribute("aria-label", "Computer setup");
+  root.hidden = true;
+  root.innerHTML = `
+    <span data-host-setup-description></span>
+    <button type="button" class="system-host-setup-link" data-host-setup-open>Set up computer</button>
+    <button type="button" class="system-host-setup-dismiss" data-host-setup-dismiss aria-label="Dismiss computer setup suggestion">×</button>`;
+  const description = root.querySelector("[data-host-setup-description]");
+  root.querySelector("[data-host-setup-open]").addEventListener("click", () => {
+    if (!root.hidden) onOpen();
+  });
+  root
+    .querySelector("[data-host-setup-dismiss]")
+    .addEventListener("click", () => {
+      dismissed = true;
+      root.hidden = true;
+    });
+  container.prepend(root);
+
+  function render() {
+    if (disposed) return;
+    const state = getConnectionState();
+    const visible =
+      !dismissed && supportsConnection() && needsComputerSetup(state);
+    const hidden = !visible;
+    if (root.hidden !== hidden) root.hidden = hidden;
+    if (!visible) return;
+    const text =
+      state.snapshot.readiness.environment === "wsl"
+        ? "Set up Windows access to use its apps and system tools."
+        : "Connect your computer to use its apps and system tools.";
+    if (description.textContent !== text) description.textContent = text;
+  }
+
+  render();
+  return {
+    render,
+    dispose() {
+      disposed = true;
+      visibility.dispose();
+      root.remove();
+    },
+  };
+}

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

@@ -0,0 +1,35 @@
+/** Observe panel ancestors as well as browser visibility. */
+export function createSystemHostVisibility({
+  documentRoot,
+  getRoot,
+  isActive,
+  onChange,
+}) {
+  const Observer = documentRoot?.defaultView?.MutationObserver;
+  const observer = Observer ? new Observer(onChange) : null;
+  function isVisible() {
+    if (!isActive()) return false;
+    if (documentRoot?.hidden) return false;
+    return !getRoot()?.closest?.("[hidden]");
+  }
+  function watch() {
+    observer?.disconnect();
+    let element = getRoot();
+    while (element) {
+      observer?.observe(element, {
+        attributes: true,
+        attributeFilter: ["hidden"],
+      });
+      element = element.parentElement;
+    }
+  }
+  documentRoot?.addEventListener("visibilitychange", onChange);
+  return {
+    isVisible,
+    watch,
+    dispose() {
+      observer?.disconnect();
+      documentRoot?.removeEventListener("visibilitychange", onChange);
+    },
+  };
+}

package/dist/src/web-ui/app/components/tool-approval-card.d.ts

@@ -1,9 +1,13 @@
+import type { ToolActivityEvent } from "../lib/tool-activity-event.js";
+
 export type ToolApprovalEvent = Record<string, unknown> & {
   approvalId?: string;
   eventName?: string;
   name?: string;
   tool?: string;
   summary?: string;
+  toolActivity?: ToolActivityEvent;
+  recommendedToolPermissionMode?: string;
 };
 
 export interface ToolApprovalCardOptions {

package/dist/src/web-ui/app/components/tool-approval-card.js

@@ -1,5 +1,6 @@
 import { formatToolName } from "../lib/event-presentation.js";
 import { textOf } from "../lib/text-format.js";
+import { createConversationToolEvidence } from "./conversation-tool-evidence.js";
 
 export function createToolApprovalCard({
   event,
@@ -35,6 +36,20 @@ export function createToolApprovalCard({
     textOf(event?.summary) || "The runtime is waiting for your decision.";
   bubble.append(header, detail);
 
+  const evidence = createConversationToolEvidence(
+    { ...event?.toolActivity, executed: false },
+    { documentRoot },
+  );
+  if (evidence) bubble.appendChild(evidence);
+
+  if (event?.recommendedToolPermissionMode === "full_plus") {
+    const recommendation = documentRoot.createElement("p");
+    recommendation.className = "approval-message-detail";
+    recommendation.textContent =
+      "For future actions without these approval requests, select FULL+. Approving this action keeps your current mode.";
+    bubble.appendChild(recommendation);
+  }
+
   const actions = documentRoot.createElement("div");
   actions.className = "tool-approval-actions";
   actions.setAttribute("aria-label", "Permission request actions");

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

@@ -0,0 +1,118 @@
+import { createConfigurationFeature as createWorkspaceFeature } from "./configuration-feature.js";
+import { textOf } from "./lib/text-format.js";
+
+export function createAppliedEnvironmentProjection({
+  state,
+  dom,
+  selection,
+  loadWebConfig,
+}) {
+  let generation = 0;
+  let pending = null;
+
+  async function prepare() {
+    const revision = ++generation;
+    pending = null;
+    const config = await loadWebConfig();
+    if (revision !== generation) return null;
+    pending = config;
+    const selected = selection.selectedEnvironmentId();
+    return (
+      Array.isArray(config.environments) &&
+      config.environments.some(({ id }) => textOf(id).trim() === selected)
+    );
+  }
+
+  function restoreProjection(config, selected) {
+    state.config = config;
+    selection.renderEnvironmentOptions();
+    dom.environmentSelect.value = selected;
+    selection.renderAgentPicker();
+  }
+
+  function preferredEnvironmentId(options, selected, defaultId) {
+    if (options.some(({ value }) => value === selected)) return selected;
+    if (options.some(({ value }) => value === defaultId)) return defaultId;
+    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() {
+    if (!pending) return "unchanged";
+    const previousConfig = state.config;
+    const previousEnvironment = selection.selectedEnvironmentId();
+    state.config = pending;
+    selection.renderEnvironmentOptions();
+    const next = preferredEnvironmentId(
+      selection.environmentOptions(),
+      previousEnvironment,
+      textOf(pending.defaultEnvironmentId).trim(),
+    );
+    if (!next) {
+      restoreProjection(previousConfig, previousEnvironment);
+      return "blocked";
+    }
+    dom.environmentSelect.value = next;
+    const unchanged = next === previousEnvironment;
+    if (unchanged) {
+      pending = null;
+      selection.renderAgentPicker();
+      return "unchanged";
+    }
+    if (!changeProjectedEnvironment(next, previousConfig, previousEnvironment))
+      return "blocked";
+    pending = null;
+    selection.renderAgentPicker();
+    return "changed";
+  }
+
+  return { prepare, flush };
+}
+
+/** Stage applied metadata under the mutation lock, then use normal navigation after release. */
+export function createConfigurationFeature({
+  state,
+  selection,
+  onConfigurationApplied,
+  ...options
+}) {
+  const projection = createAppliedEnvironmentProjection({
+    state,
+    dom: options.dom,
+    selection,
+    loadWebConfig: () => options.runtimeClient.loadWebConfig(),
+  });
+  const workspace = createWorkspaceFeature({
+    ...options,
+    onConfigurationApplied: async () => {
+      const currentStillConfigured = await projection.prepare();
+      if (currentStillConfigured) await onConfigurationApplied();
+    },
+    onConfigurationSettled: () => projection.flush() !== "blocked",
+  });
+  return {
+    ...workspace,
+    async reloadAppliedEnvironmentModels() {
+      await projection.prepare();
+      const result = projection.flush();
+      if (result === "blocked") return false;
+      if (result === "changed") return true;
+      const refreshed = await workspace.load();
+      const modelsLoaded = await onConfigurationApplied();
+      return refreshed !== false && modelsLoaded !== false;
+    },
+  };
+}