Spaces:
Running
Running
| import { requireAcceptedTask } from "./ingestContract.mjs"; | |
| import { clearSession, loadSession, saveSession, normalizeBaseUrl, type AuthSession } from "./auth"; | |
| export class ApiError extends Error { | |
| status: number; | |
| constructor(status: number, message: string) { | |
| super(message); | |
| this.status = status; | |
| } | |
| } | |
| export interface BrainRecord { | |
| id?: string; | |
| name_key: string; | |
| } | |
| export interface ApiFetchOptions { | |
| logoutOn401?: boolean; | |
| } | |
| export interface Workspace { | |
| id?: string; | |
| brain_id: string; | |
| slug: string; | |
| display_name: string; | |
| description?: string | null; | |
| archived: boolean; | |
| api_base_url: string; | |
| console_url: string; | |
| } | |
| export interface CreateWorkspaceInput { | |
| slug: string; | |
| display_name: string; | |
| description?: string | null; | |
| } | |
| export interface UpdateWorkspaceInput { | |
| display_name?: string; | |
| description?: string | null; | |
| archived?: boolean; | |
| } | |
| let session: AuthSession | null = null; | |
| export function getSession(): AuthSession | null { | |
| return session; | |
| } | |
| export function setSession(next: AuthSession | null): void { | |
| session = next; | |
| } | |
| function authHeaders(brainId?: string | null, path?: string): Headers { | |
| const headers = new Headers(); | |
| if (session?.csrfToken) headers.set("X-CSRF-Token", session.csrfToken); | |
| if (brainId && path && !path.startsWith("/system")) headers.set("X-Brain-ID", brainId); | |
| return headers; | |
| } | |
| export async function apiFetch<T>( | |
| path: string, | |
| options: RequestInit = {}, | |
| overrideBrainId?: string, | |
| fetchOptions: ApiFetchOptions = {}, | |
| ): Promise<T> { | |
| if (!session) { | |
| throw new ApiError(401, "Not authenticated"); | |
| } | |
| const headers = authHeaders(overrideBrainId ?? session.brainId, path); | |
| for (const [key, value] of new Headers(options.headers).entries()) { | |
| headers.set(key, value); | |
| } | |
| if (options.body && !headers.has("Content-Type")) { | |
| headers.set("Content-Type", "application/json"); | |
| } | |
| const url = `${normalizeBaseUrl(session.apiBaseUrl)}${path}`; | |
| const response = await fetch(url, { ...options, headers, credentials: "include" }); | |
| if (response.status === 401 && fetchOptions.logoutOn401 !== false) { | |
| clearSession(); | |
| setSession(null); | |
| if (!window.location.pathname.endsWith("/login")) { | |
| window.location.href = "/console/login"; | |
| } | |
| throw new ApiError(401, "Unauthorized"); | |
| } | |
| const text = await response.text(); | |
| let data: unknown = null; | |
| if (text) { | |
| try { | |
| data = JSON.parse(text); | |
| } catch { | |
| data = text; | |
| } | |
| } | |
| if (!response.ok) { | |
| const envelope = typeof data === "object" && data !== null ? data as {detail?: unknown; error?: {message?: string}} : null; | |
| const reason = envelope?.detail; | |
| const detail = typeof reason === "string" ? reason | |
| : reason ? `${envelope?.error?.message ?? "Request failed"}: ${JSON.stringify(reason)}` | |
| : envelope?.error?.message ?? `Request failed (${response.status})`; | |
| throw new ApiError(response.status, detail); | |
| } | |
| if ((path.startsWith("/ingest/") || path.includes("/agent/memory")) && options.method === "POST") { | |
| requireAcceptedTask(response.status, data); | |
| } | |
| return data as T; | |
| } | |
| export function workspaceApiFetch<T>( | |
| workspace: Pick<Workspace, "brain_id">, | |
| path: string, | |
| options: RequestInit = {}, | |
| fetchOptions: ApiFetchOptions = {}, | |
| ): Promise<T> { | |
| return apiFetch<T>(path, options, workspace.brain_id, fetchOptions); | |
| } | |
| export async function fetchWorkspaces(): Promise<Workspace[]> { | |
| const result = await apiFetch<{ workspaces: Workspace[] }>( | |
| "/system/workspaces", | |
| ); | |
| return result.workspaces; | |
| } | |
| export function fetchWorkspace(slug: string): Promise<Workspace> { | |
| return apiFetch<Workspace>(`/system/workspaces/${encodeURIComponent(slug)}`); | |
| } | |
| export function createWorkspace( | |
| input: CreateWorkspaceInput, | |
| ): Promise<Workspace> { | |
| return apiFetch<Workspace>("/system/workspaces", { | |
| method: "POST", | |
| body: JSON.stringify(input), | |
| }); | |
| } | |
| export function updateWorkspace( | |
| slug: string, | |
| input: UpdateWorkspaceInput, | |
| ): Promise<Workspace> { | |
| return apiFetch<Workspace>( | |
| `/system/workspaces/${encodeURIComponent(slug)}`, | |
| { method: "PATCH", body: JSON.stringify(input) }, | |
| ); | |
| } | |
| interface SessionIdentity { | |
| is_system: boolean; | |
| brain_id: string | null; | |
| csrf_token?: string; | |
| } | |
| export async function connectSession(apiBaseUrl: string, token: string): Promise<AuthSession> { | |
| const base = normalizeBaseUrl(apiBaseUrl); | |
| const response = await fetch(`${base}/auth/session`, { | |
| method: "POST", credentials: "include", headers: { "Content-Type": "application/json" }, | |
| body: JSON.stringify({ token }), | |
| }); | |
| if (!response.ok) throw new ApiError(response.status, "Access token rejected"); | |
| const identity: SessionIdentity = await response.json(); | |
| session = { apiBaseUrl: base, brainId: identity.brain_id, isSystemPat: identity.is_system, csrfToken: identity.csrf_token }; | |
| // The credential has served its purpose; all subsequent calls use the cookie. | |
| return session; | |
| } | |
| export async function restoreSession(): Promise<AuthSession | null> { | |
| const base = loadSession()?.apiBaseUrl ?? window.location.origin; | |
| const response = await fetch(`${normalizeBaseUrl(base)}/auth/me`, { credentials: "include" }); | |
| if (!response.ok) { session = null; return null; } | |
| const identity: SessionIdentity = await response.json(); | |
| session = { apiBaseUrl: base, brainId: identity.brain_id, isSystemPat: identity.is_system, csrfToken: identity.csrf_token }; | |
| saveSession(session); | |
| return session; | |
| } | |
| export async function logoutSession(): Promise<void> { | |
| try { await apiFetch("/auth/logout", { method: "POST" }); } | |
| finally { clearSession(); session = null; } | |
| } | |
| export function mergeBrainOptions( | |
| brains: BrainRecord[], | |
| activeBrainId: string, | |
| ): BrainRecord[] { | |
| const byKey = new Map<string, BrainRecord>(); | |
| for (const brain of brains) { | |
| byKey.set(brain.name_key, brain); | |
| } | |
| if (activeBrainId && !byKey.has(activeBrainId)) { | |
| byKey.set(activeBrainId, { name_key: activeBrainId }); | |
| } | |
| return [...byKey.values()].sort((a, b) => | |
| a.name_key.localeCompare(b.name_key), | |
| ); | |
| } | |