@abot-ai/runtime 1.3.1 → 1.4.0

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

@@ -0,0 +1,134 @@
+import { createProjectsController } from "./controllers/projects-controller.js";
+import { createProjectCreation } from "./components/project-creation.js";
+import { renderProjectSessionGroups } from "./components/project-session-groups.js";
+
+export function createProjectsFeature({
+  dom,
+  state,
+  client,
+  shell,
+  selectedEnvironmentId,
+  conversationSession,
+  renderSessions,
+  prepareConversation,
+  closeFilePreview = () => {},
+  onSessionCreated = () => {},
+}) {
+  let view;
+  let wasOpen = false;
+  const controller = createProjectsController({
+    client,
+    getEnvironmentId: selectedEnvironmentId,
+    getConversationRevision: () =>
+      `${state.currentSessionId}:${state.sessionViewVersion}`,
+    prepareConversation,
+    openSession: activateProjectConversation,
+    loadSessions: conversationSession.loadSessions,
+    notify: shell.showToast,
+    onSessionCreated,
+    onChange: (snapshot) => {
+      const open = Boolean(snapshot.draft);
+      dom.chatPanel.classList.toggle("project-creation-open", open);
+      dom.messagesList.inert = open;
+      dom.composerForm.inert = open;
+      view?.render(snapshot.draft);
+      renderSessions();
+      if (open && !wasOpen)
+        dom.projectCreationRoot.querySelector("input")?.focus();
+      wasOpen = open;
+    },
+  });
+  view = createProjectCreation({
+    root: dom.projectCreationRoot,
+    actions: { ...controller, closeCreate },
+  });
+
+  function canCloseDraftAfterProjectActivation(sessionId, draft) {
+    if (!draft) return false;
+    if (state.currentSessionId !== sessionId) return false;
+    return controller.snapshot().draft === draft;
+  }
+
+  async function activateProjectConversation(sessionId) {
+    const draft = controller.snapshot().draft;
+    await conversationSession.openSession(sessionId);
+    if (!canCloseDraftAfterProjectActivation(sessionId, draft)) return;
+    controller.closeCreate();
+  }
+
+  function closeCreate() {
+    const hadOpenDraft = Boolean(controller.snapshot().draft);
+    const closed = controller.closeCreate();
+    if (!hadOpenDraft) return closed;
+    if (closed) dom.newProjectButton.focus();
+    return closed;
+  }
+
+  function refreshAvailability() {
+    const available = client.supportsProjects();
+    dom.newProjectButton.disabled = !available;
+    dom.newProjectButton.title = available
+      ? "Create a project"
+      : "Projects are unavailable on this server";
+  }
+
+  return {
+    load: controller.load,
+    refreshAvailability,
+    renderSessionGroups({ root, sessions, createSessionItem }) {
+      const project = state.sessions.find(
+        (session) => session.id === state.currentSessionId,
+      )?.project;
+      dom.currentProjectContext.hidden = !project;
+      dom.currentProjectContext.textContent = project
+        ? `${project.name} · ${project.directory}`
+        : "";
+      dom.currentProjectContext.title = project?.directory || "";
+      if (!client.supportsProjects()) return false;
+      renderProjectSessionGroups({
+        root,
+        sessions,
+        createSessionItem,
+        ...controller.snapshot(),
+        query: state.sessionQuery,
+        onNewConversation: controller.newConversation,
+        onRetry: () => void controller.load(),
+      });
+      return true;
+    },
+    bind() {
+      dom.newProjectButton.addEventListener("click", () => {
+        if (!client.supportsProjects()) return;
+        if (!shell.activateWorkspace("chat", { focus: false })) return;
+        shell.setSessionsDrawerOpen(false);
+        closeFilePreview();
+        controller.openCreate();
+      });
+      dom.projectCreationRoot.addEventListener("keydown", (event) => {
+        if (event.key !== "Escape") return;
+        event.stopPropagation();
+        closeCreate();
+      });
+      dom.newSessionButton.addEventListener("click", () =>
+        controller.closeCreate(),
+      );
+      dom.sessionsList.addEventListener("click", (event) => {
+        if (event.target.closest(".session-open-button"))
+          controller.closeCreate();
+      });
+      dom.environmentSelect.addEventListener("change", () => {
+        queueMicrotask(() => {
+          refreshAvailability();
+          void controller.environmentChanged();
+        });
+      });
+      dom.refreshSessionsButton.addEventListener(
+        "click",
+        () => void controller.load(),
+      );
+    },
+    workspaceChanged(workspace) {
+      if (workspace !== "chat") controller.closeCreate();
+    },
+  };
+}

package/dist/src/web-ui/app/runtime-onboarding-feature.d.ts

@@ -0,0 +1,34 @@
+import type { createRuntimeSetupGuide } from "./components/runtime-setup-guide.js";
+import type {
+  createRuntimeOnboardingController,
+  RuntimeAvailability,
+} from "./controllers/runtime-onboarding-controller.js";
+import type { createRuntimeWebClient } from "./services/runtime-web-client.js";
+
+export declare function createRuntimeOnboardingFeature(options: {
+  dom: { runtimeSetupGuide: HTMLElement; messagesList: HTMLElement };
+  runtimeClient: Pick<
+    ReturnType<typeof createRuntimeWebClient>,
+    | "getRuntimeSetup"
+    | "saveRuntimeSetup"
+    | "applyRuntimeConfiguration"
+    | "loadLongTermMemoryStatus"
+    | "loadModelSetup"
+    | "discoverLongTermMemoryModels"
+    | "saveRuntimeSetupEmbedding"
+    | "getRuntimePlugins"
+    | "setRuntimePlugin"
+  >;
+  selectedEnvironmentId(): string;
+  state: {
+    config: Record<string, unknown> | null;
+    runtimeAvailability: RuntimeAvailability;
+  };
+  reloadModels(): unknown | Promise<unknown>;
+  reloadCatalog(): unknown | Promise<unknown>;
+  setMessageStatus(message: string): void;
+  onStateChange?(): void;
+}): {
+  guide: ReturnType<typeof createRuntimeSetupGuide>;
+  controller: ReturnType<typeof createRuntimeOnboardingController>;
+};

package/dist/src/web-ui/app/runtime-onboarding-feature.js

@@ -0,0 +1,92 @@
+import { createEmbeddingCredentialStatus } from "./components/runtime-setup/embedding-credential-status.js";
+import { createRuntimeSetupGuide } from "./components/runtime-setup-guide.js";
+import { createBridgeSetupGuide } from "./components/runtime-setup/bridge-guide.js";
+import { createRuntimeOnboardingController } from "./controllers/runtime-onboarding-controller.js";
+
+export function createRuntimeOnboardingFeature({
+  dom,
+  runtimeClient,
+  selectedEnvironmentId,
+  state,
+  reloadModels,
+  reloadCatalog,
+  setMessageStatus,
+  onStateChange,
+}) {
+  const usesBridgeBackend = () => state.config?.backend === "bridge";
+  let selectedGuide = null;
+  let bindings = {};
+
+  function createConfiguredGuide() {
+    const common = {
+      container: dom.runtimeSetupGuide,
+      conversationRegion: dom.messagesList,
+      getEnvironmentId: selectedEnvironmentId,
+    };
+    if (usesBridgeBackend())
+      return createBridgeSetupGuide({
+        ...common,
+        getSetupCommandMode: () => state.config.setupCommandMode,
+      });
+    const embedding = createEmbeddingCredentialStatus({
+      runtimeClient,
+      getEnvironmentId: selectedEnvironmentId,
+    });
+    return createRuntimeSetupGuide({
+      ...common,
+      loadSetup: () => runtimeClient.getRuntimeSetup(),
+      openConfiguration: () => dom.configWorkspaceButton?.click(),
+      saveSetup: (input) => runtimeClient.saveRuntimeSetup(input),
+      applySetup: () =>
+        runtimeClient.applyRuntimeConfiguration(selectedEnvironmentId()),
+      loadEmbeddingStatus: embedding.loadStatus,
+      discoverEmbeddingModels: (providerId) =>
+        runtimeClient.discoverLongTermMemoryModels({
+          environmentId: selectedEnvironmentId(),
+          providerId,
+        }),
+      saveEmbedding: embedding.saveEmbedding,
+      loadPlugins: () => runtimeClient.getRuntimePlugins(),
+      setPlugin: (input) => runtimeClient.setRuntimePlugin(input),
+      loadHostConnection: () => runtimeClient.getSystemHostConnection(),
+      downloadHostSetup: (platform) =>
+        runtimeClient.downloadSystemHostSetup(platform),
+      revokeHostConnection: () => runtimeClient.revokeSystemHostConnection(),
+    });
+  }
+
+  // Bootstrap binds controls before /web-config supplies the backend identity.
+  const guide = {
+    bind(options = {}) {
+      bindings = options;
+      selectedGuide?.bind(options);
+    },
+    render(availability) {
+      const hasConfiguredBackend = ["runtime", "bridge"].includes(
+        state.config?.backend,
+      );
+      if (!hasConfiguredBackend) {
+        dom.runtimeSetupGuide.hidden = true;
+        dom.messagesList.hidden = false;
+        return;
+      }
+      if (!selectedGuide) {
+        selectedGuide = createConfiguredGuide();
+        selectedGuide.bind(bindings);
+      }
+      selectedGuide.render(availability);
+    },
+    clearSecret: () => selectedGuide?.clearSecret(),
+    dispose: () => selectedGuide?.dispose(),
+    focusAction: () => selectedGuide?.focusAction(),
+  };
+  const controller = createRuntimeOnboardingController({
+    state,
+    guide,
+    reloadModels: () =>
+      usesBridgeBackend() ? reloadCatalog() : reloadModels(),
+    setMessageStatus,
+    onStateChange,
+  });
+  return { guide, controller };
+}

package/dist/src/web-ui/app/runtime-setup-page-lifecycle.d.ts

@@ -0,0 +1,5 @@
+export declare function bindRuntimeSetupPageLifecycle(options: {
+  readonly page: Pick<Window, "addEventListener">;
+  readonly dispose: () => void;
+  readonly reloadModels: () => void | Promise<void>;
+}): void;

package/dist/src/web-ui/app/runtime-setup-page-lifecycle.js

@@ -0,0 +1,13 @@
+function isPersistedPageRestore(event) {
+  return event.persisted === true;
+}
+
+export function bindRuntimeSetupPageLifecycle({ page, dispose, reloadModels }) {
+  function restoreSetupAfterPageShow(event) {
+    if (!isPersistedPageRestore(event)) return;
+    void reloadModels();
+  }
+
+  page.addEventListener("pagehide", dispose);
+  page.addEventListener("pageshow", restoreSetupAfterPageShow);
+}

package/dist/src/web-ui/app/services/client-preferences.d.ts

@@ -0,0 +1,24 @@
+import type { ToolPermissionMode } from "../lib/tool-permission-mode.js";
+
+type PreferenceMap = Record<string, unknown>;
+type SessionModeMap = Record<string, Record<string, unknown>>;
+
+export declare function createClientPreferences(storage: Pick<
+  Storage, "getItem" | "setItem" | "removeItem"
+>): {
+  loadPinnedSessions(): string[];
+  savePinnedSessions(sessionIds: readonly string[]): void;
+  loadSessionModes(normalize: (value: unknown) => ToolPermissionMode): SessionModeMap;
+  saveSessionModes(modes: SessionModeMap): void;
+  loadLastToolPermissionMode(normalize: (value: unknown) => ToolPermissionMode): ToolPermissionMode;
+  saveLastToolPermissionMode(mode: ToolPermissionMode): void;
+  loadModelPreferences(): {
+    sessionModels: PreferenceMap;
+    lastModelByEnvironment: PreferenceMap;
+  };
+  saveModelPreferences(sessionModels: PreferenceMap, lastModelByEnvironment: PreferenceMap): void;
+  environmentId(): string;
+  saveEnvironmentId(environmentId: string): void;
+  sessionIdForEnvironment(environmentId: string): string;
+  saveSessionIdForEnvironment(environmentId: string, sessionId: string): void;
+};

package/dist/src/web-ui/app/services/client-preferences.js

@@ -3,6 +3,7 @@ const storageKeys = {
   pinnedSessions: "abot-web.pinnedSessions",
   currentSessionByEnvironment: "abot-web.currentSessionByEnvironment",
   sessionModes: "abot-web.sessionModes",
+  lastToolPermissionMode: "abot-web.lastToolPermissionMode",
   sessionModels: "abot-web.sessionModels",
   lastModelByEnvironment: "abot-web.lastModelByEnvironment",
 };
@@ -19,6 +20,18 @@ function parseObject(storage, key) {
   }
 }
 
+function restoreSessionMode(value, normalizeToolPermissionMode) {
+  if (!value || typeof value !== "object") return null;
+  if (Array.isArray(value)) return null;
+  const mode = normalizeToolPermissionMode(value.toolPermissionMode);
+  if (mode === "ask") {
+    return { toolPermissionMode: mode, savedAt: value.savedAt || Date.now() };
+  }
+  const hasExplicitFullMode = ["full_access", "full_plus"].includes(value.toolPermissionMode);
+  if (!hasExplicitFullMode) return null;
+  return { toolPermissionMode: mode, savedAt: value.savedAt || Date.now() };
+}
+
 export function createClientPreferences(storage) {
   return {
     loadPinnedSessions() {
@@ -38,25 +51,13 @@ export function createClientPreferences(storage) {
     },
 
     loadSessionModes(normalizeToolPermissionMode) {
-      const modes = Object.fromEntries(
-        Object.entries(parseObject(storage, storageKeys.sessionModes)).flatMap(
-          ([sessionId, value]) =>
-            value &&
-            typeof value === "object" &&
-            !Array.isArray(value) &&
-            normalizeToolPermissionMode(value.toolPermissionMode) === "ask"
-              ? [
-                  [
-                    sessionId,
-                    {
-                      toolPermissionMode: "ask",
-                      savedAt: value.savedAt || Date.now(),
-                    },
-                  ],
-                ]
-              : [],
-        ),
-      );
+      const stored = parseObject(storage, storageKeys.sessionModes);
+      const modes = Object.fromEntries(Object.entries(stored).flatMap(
+        ([sessionId, value]) => {
+          const restored = restoreSessionMode(value, normalizeToolPermissionMode);
+          return restored ? [[sessionId, restored]] : [];
+        },
+      ));
       storage.setItem(storageKeys.sessionModes, JSON.stringify(modes));
       return modes;
     },
@@ -65,6 +66,18 @@ export function createClientPreferences(storage) {
       storage.setItem(storageKeys.sessionModes, JSON.stringify(modes));
     },
 
+    loadLastToolPermissionMode(normalizeToolPermissionMode) {
+      try {
+        return normalizeToolPermissionMode(storage.getItem(storageKeys.lastToolPermissionMode));
+      } catch {
+        return "full_access";
+      }
+    },
+
+    saveLastToolPermissionMode(mode) {
+      storage.setItem(storageKeys.lastToolPermissionMode, mode);
+    },
+
     loadModelPreferences() {
       return {
         sessionModels: parseObject(storage, storageKeys.sessionModels),

package/dist/src/web-ui/app/services/runtime-web-client/configuration.js

@@ -0,0 +1,46 @@
+/** Configuration transport; credentials are sent once and never retained here. */
+export function createConfigurationRequests({ requestApi, environmentQuery }) {
+  const scoped = (path, environmentId) =>
+    path + "?environment=" + environmentQuery(environmentId);
+  return {
+    getRuntimeSetup(environmentId) {
+      return requestApi(scoped("/runtime/setup", environmentId));
+    },
+    saveRuntimeSetup(input, environmentId) {
+      return requestApi(scoped("/runtime/setup", environmentId), {
+        method: "POST",
+        body: JSON.stringify(input),
+      });
+    },
+    saveRuntimeSetupEmbedding(input, environmentId) {
+      return requestApi(scoped("/runtime/setup/embedding", environmentId), {
+        method: "POST",
+        body: JSON.stringify(input),
+      });
+    },
+    loadModelSetup(environmentId) {
+      return requestApi(scoped("/runtime/config/models/setup", environmentId));
+    },
+    addRuntimeModel(input, environmentId) {
+      return requestApi(scoped("/runtime/config/models", environmentId), {
+        method: "POST",
+        body: JSON.stringify(input),
+      });
+    },
+    getRuntimePlugins(environmentId) {
+      return requestApi(scoped("/runtime/plugins", environmentId));
+    },
+    setRuntimePlugin(input, environmentId) {
+      return requestApi(scoped("/runtime/plugins", environmentId), {
+        method: "PUT",
+        body: JSON.stringify(input),
+      });
+    },
+    applyRuntimeConfiguration(environmentId) {
+      return requestApi(scoped("/runtime/config/apply", environmentId), {
+        method: "POST",
+        body: JSON.stringify({}),
+      });
+    },
+  };
+}

package/dist/src/web-ui/app/services/runtime-web-client/conversation-files.d.ts

@@ -0,0 +1,28 @@
+import type { ConversationFilePreview } from "../../lib/conversation-file-preview.js";
+export type { ConversationFilePreview } from "../../lib/conversation-file-preview.js";
+export interface ConversationFileRequest {
+  environmentId: string;
+  sessionId: string;
+  requestId: string;
+  executionId: string;
+  signal?: AbortSignal;
+}
+export interface ConversationFileClient {
+  supportsConversationFiles(): boolean;
+  loadConversationFile(
+    input: ConversationFileRequest,
+  ): Promise<{ ok: true; file: ConversationFilePreview }>;
+  openConversationFile?(input: ConversationFileRequest): Promise<{ ok: true }>;
+  conversationFileUrl(
+    input: ConversationFileRequest & { mode?: "download" | "content" },
+  ): string;
+}
+export declare function createConversationFileRequests(options: {
+  requestApi: (
+    path: string,
+    options?: { signal?: AbortSignal; method?: string; body?: string },
+  ) => Promise<unknown>;
+  resolveApiPath: (path: string) => string;
+  origin: string;
+  getConfig: () => Record<string, unknown>;
+}): ConversationFileClient;

package/dist/src/web-ui/app/services/runtime-web-client/conversation-files.js

@@ -0,0 +1,75 @@
+const PREVIEW_KINDS = new Set(["text", "image", "unsupported"]);
+const IMAGE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/webp"]);
+
+function hasSupportedPreviewResponse(payload) {
+  const file = payload?.file;
+  if (payload?.ok !== true || !file) return false;
+  if (!PREVIEW_KINDS.has(file.kind)) return false;
+  if (typeof file.name !== "string" || file.name.length > 4096) return false;
+  if (typeof file.mimeType !== "string") return false;
+  if (!Number.isSafeInteger(file.size) || file.size < 0) return false;
+  if (file.kind === "text" && typeof file.content !== "string") return false;
+  if (file.kind === "image" && !IMAGE_MIME_TYPES.has(file.mimeType))
+    return false;
+  return true;
+}
+
+export function createConversationFileRequests({
+  requestApi,
+  resolveApiPath,
+  origin,
+  getConfig,
+}) {
+  const supportsConversationFiles = () => getConfig()?.backend === "runtime";
+  function path(
+    { environmentId, sessionId, requestId, executionId, mode },
+    action = "",
+  ) {
+    const query = new URLSearchParams({
+      environment: environmentId,
+      sessionId,
+      requestId,
+      executionId,
+    });
+    if (mode === "download") query.set("download", "1");
+    if (mode === "content") query.set("content", "1");
+    return "/chat/files" + action + "?" + query;
+  }
+
+  function conversationFileUrl(input) {
+    if (!supportsConversationFiles()) return "";
+    const url = new URL(resolveApiPath(path(input)), origin);
+    if (url.origin !== new URL(origin).origin) return "";
+    if (!["http:", "https:"].includes(url.protocol)) return "";
+    return url.pathname + url.search;
+  }
+
+  async function loadConversationFile(input) {
+    if (!conversationFileUrl(input))
+      throw new Error("File preview is unavailable.");
+    const payload = await requestApi(path(input), { signal: input.signal });
+    if (!hasSupportedPreviewResponse(payload))
+      throw new Error("Invalid file preview.");
+    return payload;
+  }
+
+  async function openConversationFile(input) {
+    if (!conversationFileUrl(input))
+      throw new Error("Opening this file on Mac is unavailable.");
+    const result = await requestApi(path(input, "/open"), {
+      method: "POST",
+      body: "{}",
+      signal: input.signal,
+    });
+    if (result?.ok !== true)
+      throw new Error("The file could not be opened on your Mac.");
+    return result;
+  }
+
+  return {
+    supportsConversationFiles,
+    openConversationFile,
+    loadConversationFile,
+    conversationFileUrl,
+  };
+}

package/dist/src/web-ui/app/services/runtime-web-client/projects.d.ts

@@ -0,0 +1,19 @@
+import type { ProjectFolderPage, RuntimeProject } from "../../../../runtime/projects/contracts.js";
+import type { SessionProject } from "../../../../sessions/project-binding.js";
+
+export interface ProjectRequests {
+  supportsProjects(): boolean;
+  listProjects(environmentId?: string): Promise<{ projects: readonly RuntimeProject[] }>;
+  browseProjectFolders(directory?: string, cursor?: string, environmentId?: string): Promise<ProjectFolderPage>;
+  createProject(input: { name: string; directory: string }, environmentId?: string): Promise<{ project: RuntimeProject }>;
+  createProjectSession(projectId: string, environmentId?: string): Promise<{
+    sessionId: string;
+    project: SessionProject;
+  }>;
+}
+
+export declare function createProjectRequests(options: {
+  requestApi: (url: string, options?: RequestInit) => Promise<unknown>;
+  getEnvironmentId: () => string;
+  getConfig: () => Record<string, unknown> | null;
+}): ProjectRequests;

package/dist/src/web-ui/app/services/runtime-web-client/projects.js

@@ -0,0 +1,34 @@
+export function createProjectRequests({
+  requestApi,
+  getEnvironmentId,
+  getConfig,
+}) {
+  const supportsProjects = () => getConfig()?.supportsProjects === true;
+  const path = (suffix = "", environmentId = getEnvironmentId()) =>
+    `/projects${suffix}?environment=${encodeURIComponent(environmentId)}`;
+  async function requestProjects(url, options) {
+    if (!supportsProjects())
+      throw new Error("Projects are unavailable on this server.");
+    return requestApi(url, options);
+  }
+  return {
+    supportsProjects,
+    listProjects: (environmentId) => requestProjects(path("", environmentId)),
+    browseProjectFolders(directory = "", cursor = "", environmentId) {
+      const query = new URLSearchParams();
+      if (directory) query.set("path", directory);
+      if (cursor) query.set("cursor", cursor);
+      return requestProjects(`${path("/folders", environmentId)}&${query}`);
+    },
+    createProject: (input, environmentId) =>
+      requestProjects(path("", environmentId), {
+        method: "POST",
+        body: JSON.stringify(input),
+      }),
+    createProjectSession: (projectId, environmentId) =>
+      requestProjects(
+        path(`/${encodeURIComponent(projectId)}/sessions`, environmentId),
+        { method: "POST", body: "{}" },
+      ),
+  };
+}

package/dist/src/web-ui/app/services/runtime-web-client/system-host.js

@@ -0,0 +1,27 @@
+/** Pairing is shared by this ABot installation, independent of environments. */
+export function createSystemHostRequests({ requestApi, getConfig }) {
+  const supportsSystemHostConnection = () => getConfig()?.backend === "runtime";
+
+  async function requestSystemHost(path = "", options) {
+    if (!supportsSystemHostConnection()) {
+      throw new Error(
+        "Connected computers require the local Runtime backend. Open the Web UI served by your ABot installation.",
+      );
+    }
+    return requestApi(`/runtime/system-host${path}`, options);
+  }
+
+  return {
+    supportsSystemHostConnection,
+    getSystemHostConnection: () => requestSystemHost(),
+    downloadSystemHostSetup: (platform) =>
+      requestSystemHost("/setup", {
+        method: "POST",
+        body: JSON.stringify({ platform }),
+      }),
+    createSystemHostPairing: () =>
+      requestSystemHost("/pairing", { method: "POST", body: "{}" }),
+    revokeSystemHostConnection: () =>
+      requestSystemHost("", { method: "DELETE", body: "{}" }),
+  };
+}