@abot-ai/runtime 1.3.1 → 1.4.0

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

@@ -1,3 +1,8 @@
+import { createModelSetupWizard } from "./components/model-setup/wizard.js";
+import { createRuntimeConfigActivation } from "./components/runtime-config-activation.js";
+import { createPluginManager } from "./components/plugins/manager.js";
+import { createSystemHostConnectionManager } from "./components/system-host/manager.js";
+import { createSystemHostSetupNotice } from "./components/system-host/setup-notice.js";
 import { createConfigWorkspace } from "./components/config-workspace.js";
 import { createLongTermMemorySetup } from "./components/long-term-memory-setup.js";
 import { createLongTermMemoryManager } from "./components/long-term-memory/manager.js";
@@ -8,8 +13,12 @@ export function createConfigurationFeature({
   runtimeClient,
   selectedEnvironmentId,
   recordControlEvent,
+  onConfigurationApplied = async () => {},
+  onConfigurationSettled = () => true,
 }) {
   let configWorkspace;
+  let activation;
+  let modelSetup;
   const longTermMemorySetup = createLongTermMemorySetup({
     getEnvironmentId: selectedEnvironmentId,
     loadStatus: (environmentId) =>
@@ -45,6 +54,42 @@ export function createConfigurationFeature({
     actions: longTermMemoryController,
   });
 
+  const pluginManager = createPluginManager({
+    getEnvironmentId: selectedEnvironmentId,
+    onConfigurationSaved: () => activation?.markPending(),
+    loadPlugins: () => runtimeClient.getRuntimePlugins(),
+    setPlugin: (input) => runtimeClient.setRuntimePlugin(input),
+    beginRuntimeMutation: (subject) =>
+      configWorkspace?.beginExternalRuntimeMutation(subject) ?? false,
+    refreshRuntimeConfig: (failurePrefix) =>
+      configWorkspace?.refreshAfterExternalRuntimeMutation(failurePrefix) ??
+      Promise.resolve(false),
+    endRuntimeMutation: () => configWorkspace?.endExternalRuntimeMutation(),
+    recordControlEvent,
+  });
+
+  let hostSetupNotice;
+  const hostConnection = createSystemHostConnectionManager({
+    loadConnection: () => runtimeClient.getSystemHostConnection(),
+    downloadSetup: (platform) =>
+      runtimeClient.downloadSystemHostSetup(platform),
+    revokeConnection: () => runtimeClient.revokeSystemHostConnection(),
+    supportsConnection: () => runtimeClient.supportsSystemHostConnection(),
+    onChange: () => hostSetupNotice?.render(),
+  });
+  hostSetupNotice = createSystemHostSetupNotice({
+    container: dom.chatPanel?.querySelector(".composer-dock"),
+    conversationRegion: dom.messagesList,
+    getConnectionState: () => hostConnection.state,
+    supportsConnection: () => runtimeClient.supportsSystemHostConnection(),
+    refreshConnection: () => hostConnection.load(true),
+    onOpen: () => {
+      dom.configWorkspaceButton?.click();
+      if (dom.configWorkspacePanel?.hidden === false)
+        configWorkspace.activateCategory("computer");
+    },
+  });
+
   configWorkspace = createConfigWorkspace({
     dom: {
       refreshConfigButton: dom.refreshConfigButton,
@@ -53,14 +98,31 @@ export function createConfigurationFeature({
     },
     loadDashboard: () =>
       runtimeClient.loadConfigDashboard(selectedEnvironmentId()),
-    saveFile: ({ kind, id, config }) =>
-      runtimeClient.saveConfigFile({
+    saveFile: async ({ kind, id, config, expectedRevision }) => {
+      const result = await runtimeClient.saveConfigFile({
         environmentId: selectedEnvironmentId(),
         kind,
         id,
         config,
-      }),
+        expectedRevision,
+      });
+      activation?.markPending();
+      return result;
+    },
+    onAddModel: async (options) => {
+      if (modelSetup?.isOpen()) return;
+      if (!configWorkspace.beginExternalRuntimeMutation("model setup")) return;
+      configWorkspace.endExternalRuntimeMutation();
+      try {
+        await modelSetup.open(options);
+      } catch {
+        dom.configStatus.textContent =
+          "Model setup could not be opened. Try again.";
+      }
+    },
     memorySetup: longTermMemorySetup,
+    pluginManagement: pluginManager,
+    hostConnection,
     memoryManagement: {
       load: () => longTermMemoryController.load(),
       mount: (root) => longTermMemoryManager.mount(root),
@@ -68,5 +130,64 @@ export function createConfigurationFeature({
     recordControlEvent,
   });
 
-  return configWorkspace;
+  activation = createRuntimeConfigActivation({
+    onAppliedSettled: () => onConfigurationSettled(),
+    root: dom.configDashboard.parentElement,
+    getWorkspace: () => configWorkspace,
+    apply: () =>
+      runtimeClient.applyRuntimeConfiguration(selectedEnvironmentId()),
+    getEnvironmentId: selectedEnvironmentId,
+    refresh: async () => {
+      const refreshed = await configWorkspace.load({ protectUnsaved: false });
+      if (refreshed) pluginManager.markApplied?.();
+      await onConfigurationApplied();
+      return refreshed;
+    },
+  });
+  modelSetup = createModelSetupWizard({
+    root: dom.configDashboard.parentElement,
+    getEnvironmentId: selectedEnvironmentId,
+    loadSetup: () => runtimeClient.loadModelSetup(selectedEnvironmentId()),
+    saveModel: (input) =>
+      runtimeClient.addRuntimeModel(input, selectedEnvironmentId()),
+    applySetup: () =>
+      runtimeClient.applyRuntimeConfiguration(selectedEnvironmentId()),
+    beginRuntimeMutation: () =>
+      configWorkspace.beginExternalRuntimeMutation("model setup"),
+    endRuntimeMutation: () => configWorkspace.endExternalRuntimeMutation(),
+    onSaved: () => activation.markPending(),
+    onComplete: async (model) => {
+      activation.markApplied();
+      try {
+        const refreshed =
+          await configWorkspace.refreshAfterExternalRuntimeMutation(
+            "Model added; refresh required",
+          );
+        if (!refreshed) return false;
+        const memoryRefreshed = await longTermMemorySetup.load();
+        if (!memoryRefreshed) return false;
+        pluginManager.markApplied?.();
+        return configWorkspace.selectModel(model.profileId);
+      } finally {
+        await onConfigurationApplied();
+      }
+    },
+    onClosed: ({ completed }) => {
+      if (completed) configWorkspace.focusSelectedModel();
+      onConfigurationSettled();
+    },
+  });
+
+  const prepareDiscardChanges = configWorkspace.prepareDiscardChanges;
+  return {
+    ...configWorkspace,
+    prepareDiscardChanges: (...args) => {
+      if (modelSetup.isOpen()) {
+        dom.configStatus.textContent =
+          "Finish or cancel model setup before leaving configuration.";
+        return null;
+      }
+      return prepareDiscardChanges(...args);
+    },
+  };
 }

package/dist/src/web-ui/app/controllers/app-event-bindings.js

@@ -12,6 +12,7 @@ export function createAppEventBindings({
   composerActions,
   actions,
   documentRoot = document,
+  onSessionCreated = () => {},
 }) {
   function bind() {
     dom.sessionSearchInput.addEventListener("input", () => {
@@ -31,6 +32,7 @@ export function createAppEventBindings({
       if (!actions.suspendQueueRecovery()) return;
       if (preparedWorkspaceActivation() === false) return;
       state.currentSessionId = createWebSessionId();
+      onSessionCreated(state.currentSessionId);
       actions.saveSessionId(
         actions.selectedEnvironmentId(),
         state.currentSessionId,

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

@@ -49,5 +49,6 @@ export declare function createComposerWorkspaceController<T extends ComposerWork
     homeSetupHost?: HTMLElement;
     selectedEnvironmentId(): string;
     createSessionId?(): string;
+    onSessionCreated?(sessionId: string): void;
   },
 ): ComposerWorkspaceController<T>;

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

@@ -7,6 +7,7 @@ export function createComposerWorkspaceController({
   homeSetupHost,
   selectedEnvironmentId,
   createSessionId = createWebSessionId,
+  onSessionCreated = () => {},
 }) {
   const surfaces = [{
     element: dom.composerForm,
@@ -94,9 +95,9 @@ export function createComposerWorkspaceController({
   }
 
   function ensureHomeSession() {
-    if (!homeState.currentSessionId) {
-      homeState.currentSessionId = createSessionId();
-    }
+    if (homeState.currentSessionId) return homeState.currentSessionId;
+    homeState.currentSessionId = createSessionId();
+    onSessionCreated(homeState.currentSessionId);
     return homeState.currentSessionId;
   }
 

package/dist/src/web-ui/app/controllers/conversation-file-preview-controller.d.ts

@@ -0,0 +1,24 @@
+import type { FilePreviewViewState } from "../components/conversation-file-preview.js";
+export type { FilePreviewViewState } from "../components/conversation-file-preview.js";
+import type { ConversationFileReference } from "../lib/conversation-file-reference.js";
+import type { ConversationFileClient } from "../services/runtime-web-client/conversation-files.js";
+export interface ConversationFileScope {
+  environmentId: string;
+  sessionId: string;
+  activeRequestId?: string;
+}
+export declare function filePreviewErrorMessage(error: unknown): string;
+export declare function createConversationFilePreviewController(options: {
+  client: ConversationFileClient;
+  getScope: () => ConversationFileScope;
+  render: (state: FilePreviewViewState) => void;
+  AbortControllerImpl?: typeof AbortController;
+}): {
+  open(
+    reference: ConversationFileReference,
+    opener?: HTMLElement,
+  ): Promise<void>;
+  openNative(): Promise<void>;
+  close(options?: { restoreFocus?: boolean }): void;
+  syncScope(): void;
+};

package/dist/src/web-ui/app/controllers/conversation-file-preview-controller.js

@@ -0,0 +1,158 @@
+import { parseConversationFileReference } from "../lib/conversation-file-reference.js";
+
+export function filePreviewErrorMessage(error) {
+  if (error?.status === 404) return "This file is no longer available.";
+  if (error?.status === 403)
+    return "This file is outside the currently allowed folders.";
+  if (error?.code === "conversation_file_changed")
+    return "The file changed while it was being read. Open it again to view its latest contents.";
+  if (error?.code === "conversation_file_root_changed")
+    return "The file location has changed. This recorded action can no longer open it.";
+  if (error?.status === 413) return "This file is too large to preview.";
+  if (error?.status === 415) return "A preview is not available for this file.";
+  return "The file could not be loaded. Try opening it again.";
+}
+
+function hasConversationScope(scope) {
+  if (typeof scope?.environmentId !== "string" || !scope.environmentId)
+    return false;
+  return typeof scope.sessionId === "string" && Boolean(scope.sessionId);
+}
+
+function matchesConversationScope(previous, current) {
+  if (previous.environmentId !== current?.environmentId) return false;
+  return previous.sessionId === current?.sessionId;
+}
+
+function hasNewActiveRequest(previous, current) {
+  if (!current?.activeRequestId) return false;
+  return current.activeRequestId !== previous.activeRequestId;
+}
+
+export function createConversationFilePreviewController({
+  client,
+  getScope,
+  render,
+  AbortControllerImpl = globalThis.AbortController,
+}) {
+  let generation = 0;
+  let selection = null;
+  let cancellation = null;
+  let readyFile = null;
+  let nativeOpening = false;
+
+  function close({ restoreFocus = true } = {}) {
+    generation += 1;
+    cancellation?.abort();
+    cancellation = null;
+    selection = null;
+    readyFile = null;
+    nativeOpening = false;
+    render({ open: false, restoreFocus });
+  }
+
+  function ownsPendingPreview(version, scope) {
+    if (generation !== version || !selection) return false;
+    const current = getScope();
+    if (!matchesConversationScope(scope, current)) return false;
+    return !hasNewActiveRequest(scope, current);
+  }
+
+  async function open(rawReference, opener) {
+    const reference = parseConversationFileReference(rawReference);
+    const scope = { ...getScope() };
+    if (!reference || !hasConversationScope(scope)) return;
+    cancellation?.abort();
+    const version = ++generation;
+    cancellation = new AbortControllerImpl();
+    const input = {
+      environmentId: scope.environmentId,
+      sessionId: scope.sessionId,
+      requestId: reference.requestId,
+      executionId: reference.executionId,
+    };
+    selection = { scope, reference, input, version };
+    readyFile = null;
+    nativeOpening = false;
+    render({
+      open: true,
+      status: "loading",
+      opener,
+      name: reference.output.relativePath.split("/").at(-1),
+    });
+    try {
+      const response = await client.loadConversationFile({
+        ...input,
+        signal: cancellation.signal,
+      });
+      if (!ownsPendingPreview(version, scope)) return;
+      readyFile = response.file;
+      render({
+        open: true,
+        status: "ready",
+        file: response.file,
+        imageUrl:
+          response.file.kind === "image"
+            ? client.conversationFileUrl({ ...input, mode: "content" })
+            : "",
+      });
+    } catch (error) {
+      if (!ownsPendingPreview(version, scope)) return;
+      render({
+        open: true,
+        status: "error",
+        error: filePreviewErrorMessage(error),
+      });
+    }
+  }
+
+  function canOpenSelectedFileOnMac() {
+    if (!selection) return false;
+    if (readyFile?.nativeOpenAvailable !== true) return false;
+    if (typeof client.openConversationFile !== "function") return false;
+    if (nativeOpening) return false;
+    return ownsPendingPreview(selection.version, selection.scope);
+  }
+
+  async function openNative() {
+    if (!canOpenSelectedFileOnMac()) return;
+    const { scope, input, version } = selection;
+    nativeOpening = true;
+    render({ open: true, status: "native", nativeStatus: "opening" });
+    try {
+      await client.openConversationFile({
+        ...input,
+        signal: cancellation.signal,
+      });
+      if (!ownsPendingPreview(version, scope)) return;
+      render({ open: true, status: "native", nativeStatus: "opened" });
+    } catch (error) {
+      if (!ownsPendingPreview(version, scope)) return;
+      const message =
+        error?.status === 404
+          ? "This file is no longer available."
+          : "The file could not be opened on your Mac.";
+      render({
+        open: true,
+        status: "native",
+        nativeStatus: "error",
+        nativeError: message,
+      });
+    } finally {
+      if (ownsPendingPreview(version, scope)) nativeOpening = false;
+    }
+  }
+
+  function syncScope() {
+    if (!selection) return;
+    const current = getScope();
+    if (!matchesConversationScope(selection.scope, current)) {
+      close({ restoreFocus: false });
+      return;
+    }
+    if (hasNewActiveRequest(selection.scope, current))
+      close({ restoreFocus: false });
+  }
+
+  return { open, openNative, close, syncScope };
+}

package/dist/src/web-ui/app/controllers/conversation-file-preview-feature.d.ts

@@ -0,0 +1,19 @@
+import type { ConversationFileReference } from "../lib/conversation-file-reference.js";
+import type { ConversationFileClient } from "../services/runtime-web-client/conversation-files.js";
+import type { ConversationFileScope } from "./conversation-file-preview-controller.js";
+export declare function createConversationFilePreviewFeature(options: {
+  client?: ConversationFileClient;
+  getScope: () => ConversationFileScope;
+  scrollRoot: HTMLElement;
+  documentRoot: Document;
+  viewport: Window;
+}): {
+  canOpen(): boolean;
+  open?: (
+    reference: ConversationFileReference,
+    opener?: HTMLElement,
+  ) => Promise<void>;
+  reset(): void;
+  syncScope(): void;
+  setWorkspace(workspace: string): void;
+};

package/dist/src/web-ui/app/controllers/conversation-file-preview-feature.js

@@ -0,0 +1,63 @@
+import { createConversationFilePreview } from "../components/conversation-file-preview.js";
+import { createConversationFilePreviewController } from "./conversation-file-preview-controller.js";
+
+function hasFilePreviewDependencies(options) {
+  if (!options.client?.loadConversationFile) return false;
+  if (typeof options.getScope !== "function") return false;
+  return Boolean(options.scrollRoot?.parentElement);
+}
+
+function preserveConversationScroll(scrollRoot, change) {
+  const top = scrollRoot.scrollTop;
+  const left = scrollRoot.scrollLeft;
+  const bounds = scrollRoot.getBoundingClientRect();
+  const anchor = [...scrollRoot.querySelectorAll(".message-row")].find(
+    (node) => node.getBoundingClientRect().bottom > bounds.top,
+  );
+  const previousOffset = anchor?.getBoundingClientRect().top;
+  change();
+  if (anchor?.isConnected && previousOffset !== undefined) {
+    scrollRoot.scrollTop =
+      top + anchor.getBoundingClientRect().top - previousOffset;
+    scrollRoot.scrollLeft = left;
+    return;
+  }
+  scrollRoot.scrollTop = top;
+  scrollRoot.scrollLeft = left;
+}
+
+export function createConversationFilePreviewFeature(options) {
+  if (!hasFilePreviewDependencies(options)) {
+    return {
+      open: undefined,
+      canOpen: () => false,
+      reset() {},
+      syncScope() {},
+      setWorkspace() {},
+    };
+  }
+  const { client, getScope, scrollRoot, documentRoot, viewport } = options;
+  const host = scrollRoot.parentElement;
+  const view = createConversationFilePreview({
+    host,
+    documentRoot,
+    viewport,
+    onClose: () => controller.close(),
+    onOpenNative: () => controller.openNative(),
+  });
+  const controller = createConversationFilePreviewController({
+    client,
+    getScope,
+    render: (state) =>
+      preserveConversationScroll(scrollRoot, () => view.render(state)),
+  });
+  return {
+    open: controller.open,
+    canOpen: client.supportsConversationFiles,
+    reset: () => controller.close({ restoreFocus: false }),
+    syncScope: controller.syncScope,
+    setWorkspace(workspace) {
+      if (workspace !== "chat") controller.close({ restoreFocus: false });
+    },
+  };
+}

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

@@ -112,6 +112,7 @@ export interface ConversationSessionControllerOptions {
   }): void;
   scheduleTask?(callback: () => void): unknown;
   createSessionId?(): string;
+  onSessionCreated?(sessionId: string): void;
 }
 
 export declare function normalizeConversationMessage(

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

@@ -54,6 +54,7 @@ export function createConversationSessionController({
   onSessionListState = () => {},
   scheduleTask = (callback) => window.setTimeout(callback, 0),
   createSessionId = createWebSessionId,
+  onSessionCreated = () => {},
 }) {
   let environmentLoadRevision = 0;
   let sessionListRevision = 0;
@@ -502,6 +503,7 @@ export function createConversationSessionController({
   function ensureSession() {
     if (state.currentSessionId) return state.currentSessionId;
     state.currentSessionId = createSessionId();
+    onSessionCreated(state.currentSessionId);
     preferences.saveSessionIdForEnvironment(
       selectedEnvironmentId(),
       state.currentSessionId,

package/dist/src/web-ui/app/controllers/conversation-view-feature.js

@@ -0,0 +1,28 @@
+import { createConversationView } from "../components/conversation-view.js";
+import { createConversationFilePreviewFeature } from "./conversation-file-preview-feature.js";
+
+export function createConversationViewFeature({
+  filePreviewClient,
+  getFileEnvironmentId,
+  getFileSessionId,
+  ...viewOptions
+}) {
+  const {
+    dom,
+    getActiveRequestId,
+    documentRoot = document,
+    viewport = window,
+  } = viewOptions;
+  const filePreview = createConversationFilePreviewFeature({
+    client: filePreviewClient,
+    getScope: () => ({
+      environmentId: getFileEnvironmentId?.(),
+      sessionId: getFileSessionId?.(),
+      activeRequestId: getActiveRequestId?.(),
+    }),
+    scrollRoot: dom.messagesList,
+    documentRoot,
+    viewport,
+  });
+  return createConversationView({ ...viewOptions, filePreview });
+}

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

@@ -4,6 +4,7 @@ export function createDashboardController({
   getSessions,
   loadSessions,
   render,
+  isRuntimeReady = () => true,
   isVisible = () => document.visibilityState === "visible",
   setTimer = setTimeout,
   clearTimer = clearTimeout,
@@ -17,6 +18,7 @@ export function createDashboardController({
   };
   let active = false;
   let ready = false;
+  let runtimeReady = isRuntimeReady();
   let environmentId = "";
   let sessionsEnvironmentId = "";
   let revision = 0;
@@ -37,6 +39,7 @@ export function createDashboardController({
     return readEnvironmentId === getEnvironmentId();
   }
   function canRefresh() {
+    if (!isRuntimeReady()) return false;
     if (!ready) return false;
     if (!active) return false;
     return isVisible();
@@ -88,6 +91,20 @@ export function createDashboardController({
     snapshot,
     publish,
     refresh,
+    runtimeAvailabilityChanged() {
+      const available = isRuntimeReady();
+      if (runtimeReady === available) {
+        publish();
+        return;
+      }
+      runtimeReady = available;
+      revision += 1;
+      clearTimer(timer);
+      state.activityError = "";
+      state.sessionsError = "";
+      publish();
+      if (available) void refresh();
+    },
     setReady() {
       ready = true;
       void refresh();

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

@@ -0,0 +1,45 @@
+import type { ProjectRequests } from "../services/runtime-web-client/projects.js";
+import type { ProjectFolderPage, RuntimeProject } from "../../../runtime/projects/contracts.js";
+
+export type ProjectCreationDraft = {
+  name: string;
+  directory: string;
+  pickerOpen: boolean;
+  listing: ProjectFolderPage | null;
+  loading: boolean;
+  saving: boolean;
+  error: string;
+};
+
+export type ProjectsControllerState = {
+  projects: readonly RuntimeProject[];
+  loading: boolean;
+  error: string;
+  draft: ProjectCreationDraft | null;
+  busyProjectId: string;
+};
+
+export declare function createProjectsController(options: {
+  client: ProjectRequests;
+  getEnvironmentId: () => string;
+  getConversationRevision: () => string | number;
+  prepareConversation: () => boolean;
+  openSession: (sessionId: string) => Promise<unknown>;
+  loadSessions: () => Promise<unknown>;
+  onChange: (state: ProjectsControllerState) => void;
+  notify: (message: string, tone: "failed") => void;
+  onSessionCreated?: (sessionId: string) => void;
+}): {
+  snapshot(): ProjectsControllerState;
+  load(): Promise<void>;
+  environmentChanged(): Promise<void>;
+  openCreate(): void;
+  closeCreate(): boolean;
+  updateDraft(field: string, value: string): void;
+  openFolderPicker(): Promise<void>;
+  cancelFolderPicker(): void;
+  selectFolder(): void;
+  browse(directory?: string, cursor?: string): Promise<void>;
+  create(): Promise<void>;
+  newConversation(projectId: string): Promise<void>;
+};