@abot-ai/runtime 1.0.0

package/dist/src/web-ui/app/lib/text-format.js

@@ -0,0 +1,197 @@
+export function textOf(value, fallback = "") {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return fallback;
+}
+
+export function shortId(id) {
+  const value = textOf(id);
+  return value.length > 12
+    ? `${value.slice(0, 6)}...${value.slice(-4)}`
+    : value;
+}
+
+export function formatTime(value) {
+  if (!value) return "";
+  const date =
+    typeof value === "number"
+      ? new Date(value)
+      : /^\d+$/.test(String(value))
+        ? new Date(Number(value))
+        : new Date(value);
+  if (Number.isNaN(date.getTime())) return "";
+  return date.toLocaleString();
+}
+
+export function hasRtlText(value) {
+  return /[\u0590-\u08ff]/.test(textOf(value));
+}
+
+export function applyTextDirection(element, value) {
+  const isRtl = hasRtlText(value);
+  element.dir = isRtl ? "rtl" : "auto";
+  element.classList.toggle("rtl-text", isRtl);
+}
+
+export function createWebSessionId() {
+  const random = Math.random().toString(36).slice(2, 8);
+  return `abot-web-${Date.now()}-${random}`;
+}
+
+export function escapeHtml(value) {
+  return textOf(value)
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
+}
+
+export function escapeAttribute(value) {
+  return escapeHtml(value).replaceAll("'", "&#39;");
+}
+
+export function safeLinkHref(value, baseHref = globalThis.location?.href) {
+  try {
+    const url = new URL(value, baseHref);
+    if (
+      url.protocol === "http:" ||
+      url.protocol === "https:" ||
+      url.protocol === "mailto:"
+    ) {
+      return url.href;
+    }
+  } catch {
+    return "";
+  }
+  return "";
+}
+
+function renderInlineMarkdown(raw) {
+  let text = escapeHtml(raw);
+  const codeTokens = [];
+  text = text.replace(/`([^`]+)`/g, (_, code) => {
+    const token = `@@CODE${codeTokens.length}@@`;
+    codeTokens.push(`<code>${code}</code>`);
+    return token;
+  });
+  text = text.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_, label, href) => {
+    const safeHref = safeLinkHref(href);
+    if (!safeHref) return label;
+    return `<a href="${escapeAttribute(safeHref)}" target="_blank" rel="noreferrer">${label}</a>`;
+  });
+  text = text.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  text = text.replace(/(^|[^*])\*([^*\n]+)\*/g, "$1<em>$2</em>");
+  text = text.replace(/~~([^~]+)~~/g, "<del>$1</del>");
+  for (let index = 0; index < codeTokens.length; index += 1) {
+    text = text.replaceAll(`@@CODE${index}@@`, codeTokens[index]);
+  }
+  return text;
+}
+
+export function renderMarkdown(raw) {
+  const source = textOf(raw);
+  if (!source.trim()) return "";
+  const lines = source.replace(/\r\n/g, "\n").split("\n");
+  const blocks = [];
+  let paragraph = [];
+  let list = [];
+  let quote = [];
+  let code = [];
+  let inCode = false;
+
+  function flushParagraph() {
+    if (paragraph.length === 0) return;
+    blocks.push(
+      `<p>${paragraph.map((line) => renderInlineMarkdown(line)).join("<br>")}</p>`,
+    );
+    paragraph = [];
+  }
+
+  function flushList() {
+    if (list.length === 0) return;
+    blocks.push(
+      `<ul>${list
+        .map((item) => `<li>${renderInlineMarkdown(item)}</li>`)
+        .join("")}</ul>`,
+    );
+    list = [];
+  }
+
+  function flushQuote() {
+    if (quote.length === 0) return;
+    blocks.push(
+      `<blockquote>${quote
+        .map((line) => renderInlineMarkdown(line))
+        .join("<br>")}</blockquote>`,
+    );
+    quote = [];
+  }
+
+  function flushCode() {
+    if (code.length === 0) return;
+    blocks.push(`<pre><code>${escapeHtml(code.join("\n"))}</code></pre>`);
+    code = [];
+  }
+
+  for (const line of lines) {
+    if (line.trim().startsWith("```")) {
+      if (inCode) {
+        flushCode();
+        inCode = false;
+      } else {
+        flushParagraph();
+        flushList();
+        flushQuote();
+        inCode = true;
+      }
+      continue;
+    }
+    if (inCode) {
+      code.push(line);
+      continue;
+    }
+
+    const heading = line.match(/^(#{1,3})\s+(.+)$/);
+    const bullet = line.match(/^\s*[-*]\s+(.+)$/);
+    const numbered = line.match(/^\s*\d+[.]\s+(.+)$/);
+    const quoted = line.match(/^>\s?(.+)$/);
+
+    if (!line.trim()) {
+      flushParagraph();
+      flushList();
+      flushQuote();
+      continue;
+    }
+    if (heading) {
+      flushParagraph();
+      flushList();
+      flushQuote();
+      const level = heading[1].length + 2;
+      blocks.push(`<h${level}>${renderInlineMarkdown(heading[2])}</h${level}>`);
+      continue;
+    }
+    if (bullet || numbered) {
+      flushParagraph();
+      flushQuote();
+      list.push((bullet || numbered)[1]);
+      continue;
+    }
+    if (quoted) {
+      flushParagraph();
+      flushList();
+      quote.push(quoted[1]);
+      continue;
+    }
+    flushList();
+    flushQuote();
+    paragraph.push(line);
+  }
+
+  flushParagraph();
+  flushList();
+  flushQuote();
+  flushCode();
+  return blocks.join("");
+}

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

@@ -0,0 +1,117 @@
+const storageKeys = {
+  environmentId: "abot-web.environmentId",
+  pinnedSessions: "abot-web.pinnedSessions",
+  currentSessionByEnvironment: "abot-web.currentSessionByEnvironment",
+  sessionModes: "abot-web.sessionModes",
+  sessionModels: "abot-web.sessionModels",
+  lastModelByEnvironment: "abot-web.lastModelByEnvironment",
+};
+
+function parseObject(storage, key) {
+  try {
+    const raw = storage.getItem(key);
+    const value = raw ? JSON.parse(raw) : {};
+    return value && typeof value === "object" && !Array.isArray(value)
+      ? value
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+export function createClientPreferences(storage) {
+  return {
+    loadPinnedSessions() {
+      try {
+        const raw = storage.getItem(storageKeys.pinnedSessions);
+        const value = raw ? JSON.parse(raw) : [];
+        return Array.isArray(value)
+          ? value.map((id) => String(id || "")).filter(Boolean)
+          : [];
+      } catch {
+        return [];
+      }
+    },
+
+    savePinnedSessions(sessionIds) {
+      storage.setItem(storageKeys.pinnedSessions, JSON.stringify(sessionIds));
+    },
+
+    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(),
+                    },
+                  ],
+                ]
+              : [],
+        ),
+      );
+      storage.setItem(storageKeys.sessionModes, JSON.stringify(modes));
+      return modes;
+    },
+
+    saveSessionModes(modes) {
+      storage.setItem(storageKeys.sessionModes, JSON.stringify(modes));
+    },
+
+    loadModelPreferences() {
+      return {
+        sessionModels: parseObject(storage, storageKeys.sessionModels),
+        lastModelByEnvironment: parseObject(
+          storage,
+          storageKeys.lastModelByEnvironment,
+        ),
+      };
+    },
+
+    saveModelPreferences(sessionModels, lastModelByEnvironment) {
+      storage.setItem(storageKeys.sessionModels, JSON.stringify(sessionModels));
+      storage.setItem(
+        storageKeys.lastModelByEnvironment,
+        JSON.stringify(lastModelByEnvironment),
+      );
+    },
+
+    environmentId() {
+      return String(storage.getItem(storageKeys.environmentId) || "").trim();
+    },
+
+    saveEnvironmentId(environmentId) {
+      if (environmentId)
+        storage.setItem(storageKeys.environmentId, environmentId);
+      else storage.removeItem(storageKeys.environmentId);
+    },
+
+    sessionIdForEnvironment(environmentId) {
+      return String(
+        parseObject(storage, storageKeys.currentSessionByEnvironment)[
+          environmentId
+        ] || "",
+      );
+    },
+
+    saveSessionIdForEnvironment(environmentId, sessionId) {
+      const sessions = parseObject(
+        storage,
+        storageKeys.currentSessionByEnvironment,
+      );
+      if (sessionId) sessions[environmentId] = sessionId;
+      else delete sessions[environmentId];
+      storage.setItem(
+        storageKeys.currentSessionByEnvironment,
+        JSON.stringify(sessions),
+      );
+    },
+  };
+}

package/dist/src/web-ui/app/services/realtime-transport.d.ts

@@ -0,0 +1,17 @@
+export declare function decodeRealtimeFrame(data: unknown): Promise<string>;
+
+export declare function createRealtimeTransport(options: {
+  getConfig: () => Record<string, unknown> | null;
+  onMessage: (message: Record<string, unknown>) => void;
+  onOpen: () => void;
+  onClose: () => void;
+  onError: () => void;
+  onParseError: (error: unknown, preview: string) => void;
+  reconnectDelayMs?: number;
+  WebSocketImpl?: typeof WebSocket;
+  location?: Pick<Location, "protocol" | "host">;
+  scheduleReconnect?: typeof setTimeout;
+}): {
+  connect(): void;
+  send(payload: Record<string, unknown>): boolean;
+};

package/dist/src/web-ui/app/services/realtime-transport.js

@@ -0,0 +1,65 @@
+export async function decodeRealtimeFrame(data) {
+  if (typeof data === "string") return data;
+  if (data instanceof Blob) return data.text();
+  if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+  if (ArrayBuffer.isView(data)) return new TextDecoder().decode(data);
+  return String(data);
+}
+
+export function createRealtimeTransport({
+  getConfig,
+  onMessage,
+  onOpen,
+  onClose,
+  onError,
+  onParseError,
+  reconnectDelayMs = 1_800,
+  WebSocketImpl = WebSocket,
+  location = window.location,
+  scheduleReconnect = setTimeout,
+}) {
+  let socket = null;
+
+  async function handleFrame(data) {
+    let raw = "";
+    try {
+      raw = await decodeRealtimeFrame(data);
+      if (!raw.trim()) return;
+      if (raw.trim().startsWith("<")) {
+        throw new Error("received non-JSON HTML from realtime proxy");
+      }
+      onMessage(JSON.parse(raw));
+    } catch (error) {
+      onParseError(error, raw ? raw.slice(0, 80) : "");
+    }
+  }
+
+  function connect() {
+    const config = getConfig();
+    if (!config) return;
+    const protocol = location.protocol === "https:" ? "wss:" : "ws:";
+    socket = new WebSocketImpl(
+      `${protocol}//${location.host}${config.realtimePath}`,
+    );
+    socket.addEventListener("open", () => onOpen());
+    socket.addEventListener("message", (event) => void handleFrame(event.data));
+    socket.addEventListener("close", () => {
+      onClose();
+      scheduleReconnect(connect, reconnectDelayMs);
+    });
+    socket.addEventListener("error", () => onError());
+  }
+
+  return {
+    connect,
+    send(payload) {
+      try {
+        if (socket?.readyState !== WebSocketImpl.OPEN) return false;
+        socket.send(JSON.stringify(payload));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+  };
+}

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

@@ -0,0 +1,96 @@
+export declare function parseJsonResponseText(
+  text: string,
+  context: string,
+): Record<string, unknown>;
+
+export type RuntimeAvailability =
+  | { status: "ready" }
+  | {
+      status: "setup_required";
+      code: "runtime_configuration_required";
+      message: string;
+    };
+
+export type RuntimeModelCatalogResponse = Record<string, unknown> & {
+  defaultProfileId: string;
+  profiles: Record<string, unknown>[];
+  availability: RuntimeAvailability;
+};
+
+export declare function createRuntimeWebClient(options: {
+  getConfig: () => Record<string, unknown> | null;
+  getEnvironmentId: () => string;
+  fetchImpl?: typeof fetch;
+  origin?: string;
+}): {
+  getRuntimeStatus(): Promise<Record<string, unknown>>;
+  getRuntimeLogs(lines?: number): Promise<Record<string, unknown>>;
+  getSystemHealth(): Promise<Record<string, unknown>>;
+  listModels(environmentId?: string): Promise<RuntimeModelCatalogResponse>;
+  getAgentMode(environmentId?: string): Promise<Record<string, unknown>>;
+  setAgentMode(
+    mode: string,
+    environmentId?: string,
+  ): Promise<Record<string, unknown>>;
+  attachmentPreviewUrl(options: {
+    environmentId: string;
+    sessionId: string;
+    storageRef: string;
+    id: string;
+    mimeType: string;
+  }): string;
+  deleteAttachment(options: {
+    environmentId: string;
+    sessionId: string;
+    storageRef: string;
+    id: string;
+    mimeType: string;
+  }): Promise<void>;
+  uploadAttachment(options: {
+    environmentId: string;
+    sessionId: string;
+    name: string;
+    mimeType: string;
+    file: Blob;
+  }): Promise<Record<string, unknown>>;
+  loadWebConfig(): Promise<Record<string, unknown>>;
+  listSessions(environmentId?: string): Promise<Record<string, unknown>>;
+  loadSession(
+    sessionId: string,
+    environmentId?: string,
+  ): Promise<Record<string, unknown>>;
+  markSessionRead(options: {
+    sessionId: string;
+    environmentId?: string;
+    readThroughMessageId?: number | null;
+  }): Promise<Record<string, unknown>>;
+  clearSessionMessages(
+    sessionId: string,
+    environmentId?: string,
+  ): Promise<Record<string, unknown>>;
+  deleteSession(
+    sessionId: string,
+    environmentId?: string,
+  ): Promise<Record<string, unknown>>;
+  fetchRequestEvents(options: {
+    requestId: string;
+    afterSeq?: number;
+    environmentId?: string;
+  }): Promise<unknown[]>;
+  postChatMessage(options: {
+    text: string;
+    attachments: unknown[];
+    environmentId?: string;
+    sessionId: string;
+    agentMode: string;
+    toolPermissionMode: string;
+    modelPreference?: Record<string, unknown> | null;
+  }): Promise<string>;
+  loadConfigDashboard(environmentId?: string): Promise<Record<string, unknown>>;
+  saveConfigFile(options: {
+    environmentId?: string;
+    kind: string;
+    id: string;
+    config: unknown;
+  }): Promise<Record<string, unknown>>;
+};