349 lines
15 KiB
TypeScript
349 lines
15 KiB
TypeScript
import type { ChatMessage, Conversation, DriverModel, SharedChat, User } from "./types.ts";
|
|
|
|
export type AccessStatus = "pending" | "reviewing" | "accepted" | "refused";
|
|
|
|
export interface AccessRequest {
|
|
id: string;
|
|
username: string;
|
|
email: string;
|
|
message: string;
|
|
status: AccessStatus;
|
|
reason: string;
|
|
created_at: number;
|
|
updated_at: number;
|
|
}
|
|
|
|
export interface AccessMessage {
|
|
id: number;
|
|
request_id: string;
|
|
author: "user" | "admin";
|
|
body: string;
|
|
created_at: number;
|
|
}
|
|
|
|
export type ReportReason = "copyright" | "gore" | "falseinfo" | "bug";
|
|
export type ReportStatus = "open" | "reviewing" | "resolved" | "dismissed";
|
|
|
|
export interface Report {
|
|
id: string;
|
|
reporter_id: string;
|
|
reporter_name: string;
|
|
conversation_id: string;
|
|
message_index: number;
|
|
content: string;
|
|
prompt: string;
|
|
model: string;
|
|
reason: ReportReason;
|
|
details: string;
|
|
status: ReportStatus;
|
|
admin_note: string;
|
|
reporter_shadowbanned: number;
|
|
created_at: number;
|
|
updated_at: number;
|
|
}
|
|
|
|
const TOKEN_KEY = "kisassistant_token";
|
|
|
|
export function getToken(): string | null {
|
|
return localStorage.getItem(TOKEN_KEY);
|
|
}
|
|
export function setToken(t: string): void {
|
|
localStorage.setItem(TOKEN_KEY, t);
|
|
}
|
|
export function clearToken(): void {
|
|
localStorage.removeItem(TOKEN_KEY);
|
|
}
|
|
|
|
export class ApiError extends Error {
|
|
status: number;
|
|
constructor(status: number, message: string) {
|
|
super(message);
|
|
this.status = status;
|
|
}
|
|
}
|
|
|
|
async function req<T>(path: string, opts: RequestInit = {}, auth = true): Promise<T> {
|
|
const headers: Record<string, string> = { "Content-Type": "application/json" };
|
|
if (auth) {
|
|
const t = getToken();
|
|
if (t) headers["Authorization"] = `Bearer ${t}`;
|
|
}
|
|
const res = await fetch(path, { ...opts, headers: { ...headers, ...(opts.headers as Record<string, string> | undefined) } });
|
|
if (res.status === 401 && auth) {
|
|
clearToken();
|
|
if (!window.location.pathname.startsWith("/share/")) window.location.reload();
|
|
throw new ApiError(401, "Session expired, please log in again.");
|
|
}
|
|
const data = (await res.json().catch(() => ({}))) as { error?: string } & T;
|
|
if (!res.ok) throw new ApiError(res.status, (data as { error?: string }).error || `Request failed (${res.status})`);
|
|
return data as T;
|
|
}
|
|
|
|
export const api = {
|
|
login: (username: string, key: string) =>
|
|
req<{ token: string; expiresAt: number; user: User } | { totpRequired: true; totpToken: string; username: string }>("/api/auth/login", {
|
|
method: "POST",
|
|
body: JSON.stringify({ username, key }),
|
|
}, false),
|
|
totpLogin: (totpToken: string, code: string) =>
|
|
req<{ token: string; expiresAt: number; user: User }>("/api/auth/totp", {
|
|
method: "POST",
|
|
body: JSON.stringify({ totpToken, code }),
|
|
}, false),
|
|
verify: () => req<{ ok: boolean; user: User }>("/api/auth/verify"),
|
|
logout: () => req<{ ok: boolean }>("/api/auth/logout", { method: "POST" }).catch(() => ({ ok: true as const })),
|
|
|
|
methods: () => req<{ recovery: boolean; from?: string; registration: boolean; accessRequest: boolean }>("/api/auth/methods", {}, false),
|
|
register: (u: { username: string; displayName?: string; email?: string }) =>
|
|
req<{ user: User; key: string }>("/api/auth/register", { method: "POST", body: JSON.stringify(u) }, false),
|
|
recover: (username: string) =>
|
|
req<{ ok: boolean }>("/api/auth/recover", { method: "POST", body: JSON.stringify({ username }) }, false),
|
|
resetCheck: (token: string) => req<{ ok: boolean; username: string }>(`/api/auth/reset/${token}`, {}, false),
|
|
resetConsume: (token: string) => req<{ key: string }>(`/api/auth/reset/${token}`, { method: "POST" }, false),
|
|
|
|
me: () => req<{ user: User }>("/api/me"),
|
|
updateMe: (patch: { displayName?: string; avatarUrl?: string; theme?: string; email?: string }) =>
|
|
req<{ user: User }>("/api/me", { method: "PATCH", body: JSON.stringify(patch) }),
|
|
|
|
/** Rotate your own access key (old sessions revoked, key shown once). */
|
|
rotateKey: () => req<{ key: string }>("/api/me/key/rotate", { method: "POST" }),
|
|
|
|
/** Permanently delete your own account (chats, shares, sessions). */
|
|
deleteMe: () => req<{ ok: boolean }>("/api/me", { method: "DELETE" }),
|
|
|
|
/** TOTP two-factor self-service. */
|
|
totpStatus: () => req<{ enabled: boolean }>("/api/me/totp"),
|
|
totpSetup: () => req<{ secret: string; otpauthUrl: string }>("/api/me/totp/setup", { method: "POST" }),
|
|
totpVerify: (secret: string, code: string) =>
|
|
req<{ enabled: boolean }>("/api/me/totp/verify", { method: "POST", body: JSON.stringify({ secret, code }) }),
|
|
totpDisable: (code: string) =>
|
|
req<{ enabled: boolean }>("/api/me/totp", { method: "DELETE", body: JSON.stringify({ code }) }),
|
|
|
|
adminList: (p: { q?: string; sort?: string; filter?: string; page?: number; per?: number } = {}) => {
|
|
const qs = new URLSearchParams();
|
|
if (p.q) qs.set("q", p.q);
|
|
if (p.sort) qs.set("sort", p.sort);
|
|
if (p.filter) qs.set("filter", p.filter);
|
|
if (p.page) qs.set("page", String(p.page));
|
|
if (p.per) qs.set("per", String(p.per));
|
|
const s = qs.toString();
|
|
return req<{ users: User[]; total: number; page: number; perPage: number; pages: number }>(
|
|
`/api/admin/users${s ? `?${s}` : ""}`,
|
|
);
|
|
},
|
|
adminCreate: (u: { username: string; displayName?: string; avatarUrl?: string; theme?: string; email?: string }) =>
|
|
req<{ user: User; key: string }>("/api/admin/users", { method: "POST", body: JSON.stringify(u) }),
|
|
adminDelete: (id: string) => req<{ ok: boolean }>(`/api/admin/users/${id}`, { method: "DELETE" }),
|
|
adminRegenerate: (id: string) => req<{ key: string }>(`/api/admin/users/${id}/regenerate`, { method: "POST" }),
|
|
adminPatch: (id: string, patch: { displayName?: string; avatarUrl?: string; theme?: string; email?: string }) =>
|
|
req<{ user: User }>(`/api/admin/users/${id}`, { method: "PATCH", body: JSON.stringify(patch) }),
|
|
|
|
adminGetSettings: () => req<{ settings: { registrationEnabled: boolean; accessRequestEnabled: boolean; ocrEnabled: boolean } }>("/api/admin/settings"),
|
|
adminPatchSettings: (patch: { registrationEnabled?: boolean; accessRequestEnabled?: boolean; ocrEnabled?: boolean }) =>
|
|
req<{ settings: { registrationEnabled: boolean; accessRequestEnabled: boolean; ocrEnabled: boolean } }>("/api/admin/settings", { method: "PATCH", body: JSON.stringify(patch) }),
|
|
|
|
/** Admin: SMTP credentials viewer (password included, blur it by default) + connectivity. */
|
|
adminMailStatus: () =>
|
|
req<{ smtp: { enabled: boolean; host: string; port: number; secure: boolean; user: string; pass: string; hasPass: boolean; from: string; appUrl: string } }>("/api/admin/mail"),
|
|
adminMailVerify: () => req<{ ok: boolean }>("/api/admin/mail/verify", { method: "POST", body: JSON.stringify({}) }),
|
|
adminMailTest: (to: string) =>
|
|
req<{ ok: boolean; messageId: string }>("/api/admin/mail/test", { method: "POST", body: JSON.stringify({ to }) }),
|
|
|
|
convs: () => req<{ conversations: Conversation[] }>("/api/conversations"),
|
|
/** Search your old chats (titles, topics and message content). */
|
|
searchConvs: (q: string) =>
|
|
req<{ conversations: (Conversation & { snippet: string | null; snippetRole: string | null })[] }>(
|
|
`/api/conversations/search?q=${encodeURIComponent(q)}`,
|
|
),
|
|
createConv: (c: { title?: string; topic?: string; model?: string }) =>
|
|
req<{ conversation: Conversation }>("/api/conversations", { method: "POST", body: JSON.stringify(c) }),
|
|
getConv: (id: string) => req<{ conversation: Conversation; messages: ChatMessage[] }>(`/api/conversations/${id}`),
|
|
patchConv: (id: string, patch: { title?: string; topic?: string; model?: string }) =>
|
|
req<{ conversation: Conversation }>(`/api/conversations/${id}`, { method: "PATCH", body: JSON.stringify(patch) }),
|
|
deleteConv: (id: string) => req<{ ok: boolean }>(`/api/conversations/${id}`, { method: "DELETE" }),
|
|
|
|
share: (id: string) => req<{ publicId: string; url: string }>(`/api/conversations/${id}/share`, { method: "POST" }),
|
|
getShare: (id: string) => req<{ publicId: string; url: string } | { shared: false }>(`/api/conversations/${id}/share`),
|
|
unshare: (id: string) => req<{ ok: boolean }>(`/api/conversations/${id}/share`, { method: "DELETE" }),
|
|
publicShare: (publicId: string) => req<SharedChat>(`/api/share/${publicId}`, {}, false),
|
|
|
|
/** Archived chats (hidden from the sidebar, managed in settings). */
|
|
archivedConvs: () => req<{ conversations: Conversation[] }>("/api/conversations/archived"),
|
|
archiveConv: (id: string) =>
|
|
req<{ conversation: Conversation }>(`/api/conversations/${id}/archive`, { method: "POST" }),
|
|
unarchiveConv: (id: string) =>
|
|
req<{ conversation: Conversation }>(`/api/conversations/${id}/unarchive`, { method: "POST" }),
|
|
|
|
models: (opts: { refresh?: boolean } = {}) =>
|
|
req<{ models: DriverModel[] }>(`/api/models${opts.refresh ? "?refresh=1" : ""}`),
|
|
|
|
/** Access-request wishlist (public, no auth). */
|
|
accessRequest: (a: { username: string; email: string; message: string }) =>
|
|
req<{ request: AccessRequest; reviewUrl: string }>("/api/access/request", {
|
|
method: "POST",
|
|
body: JSON.stringify(a),
|
|
}, false),
|
|
accessTicket: (id: string) =>
|
|
req<{ request: AccessRequest; messages: AccessMessage[] }>(`/api/access/ticket/${id}`, {}, false),
|
|
accessReply: (id: string, body: string) =>
|
|
req<{ message: AccessMessage }>(`/api/access/ticket/${id}/message`, {
|
|
method: "POST",
|
|
body: JSON.stringify({ body }),
|
|
}, false),
|
|
|
|
/** Admin: access-request triage. */
|
|
adminAccessList: () => req<{ requests: (AccessRequest & { message_count: number })[] }>("/api/admin/access"),
|
|
adminAccessGet: (id: string) =>
|
|
req<{ request: AccessRequest; messages: AccessMessage[] }>(`/api/admin/access/${id}`),
|
|
adminAccessPatch: (id: string, patch: { status: AccessStatus; reason?: string }) =>
|
|
req<{ request: AccessRequest; key?: string }>(`/api/admin/access/${id}`, {
|
|
method: "PATCH",
|
|
body: JSON.stringify(patch),
|
|
}),
|
|
adminAccessReply: (id: string, body: string) =>
|
|
req<{ message: AccessMessage }>(`/api/admin/access/${id}/message`, {
|
|
method: "POST",
|
|
body: JSON.stringify({ body }),
|
|
}),
|
|
|
|
/** Content reports (flagged AI responses). */
|
|
createReport: (r: {
|
|
conversationId?: string;
|
|
messageIndex?: number;
|
|
reason: ReportReason;
|
|
details?: string;
|
|
content?: string;
|
|
prompt?: string;
|
|
model?: string;
|
|
}) =>
|
|
req<{ report: Report }>("/api/reports", {
|
|
method: "POST",
|
|
body: JSON.stringify(r),
|
|
}),
|
|
|
|
/** Admin: report triage. */
|
|
adminReportList: () => req<{ reports: Report[] }>("/api/admin/reports"),
|
|
adminReportPatch: (id: string, patch: { status: ReportStatus; adminNote?: string }) =>
|
|
req<{ report: Report }>(`/api/admin/reports/${id}`, {
|
|
method: "PATCH",
|
|
body: JSON.stringify(patch),
|
|
}),
|
|
ollamaPull: async (
|
|
name: string,
|
|
onProgress: (p: { status?: string; digest?: string; total?: number; completed?: number; error?: string }) => void,
|
|
): Promise<void> => {
|
|
const res = await fetch("/api/admin/ollama/pull", {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json", Authorization: `Bearer ${getToken()}` },
|
|
body: JSON.stringify({ name }),
|
|
});
|
|
if (res.status === 401) {
|
|
clearToken();
|
|
window.location.reload();
|
|
throw new ApiError(401, "Session expired.");
|
|
}
|
|
if (!res.ok || !res.body) {
|
|
const err = (await res.json().catch(() => ({}))) as { error?: string };
|
|
throw new ApiError(res.status, err.error || `Pull failed (${res.status})`);
|
|
}
|
|
const reader = res.body.getReader();
|
|
const decoder = new TextDecoder();
|
|
let buf = "";
|
|
for (;;) {
|
|
const { done, value } = await reader.read();
|
|
if (done) break;
|
|
buf += decoder.decode(value, { stream: true });
|
|
const lines = buf.split("\n");
|
|
buf = lines.pop() ?? "";
|
|
for (const line of lines) {
|
|
const t = line.trim();
|
|
if (t) onProgress(JSON.parse(t));
|
|
}
|
|
}
|
|
},
|
|
|
|
/** Admin: delete a local Ollama model (frees disk on the Ollama host). */
|
|
ollamaDelete: (name: string) => req<{ ok: boolean }>(`/api/admin/ollama/models/${encodeURIComponent(name)}`, { method: "DELETE" }),
|
|
|
|
tools: () => req<{ tools: { name: string; description: string; available: boolean; reason: string | null }[] }>("/api/tools"),
|
|
|
|
/** Send an image to the platform OCR tool. Returns editable text (never the raw image). */
|
|
ocrImage: async (file: File): Promise<{ text: string; truncated: boolean; chars: number }> => {
|
|
const res = await fetch("/api/tools/ocr", {
|
|
method: "POST",
|
|
headers: { Authorization: `Bearer ${getToken()}`, "Content-Type": file.type || "application/octet-stream" },
|
|
body: file,
|
|
});
|
|
if (res.status === 401) {
|
|
clearToken();
|
|
window.location.reload();
|
|
throw new ApiError(401, "Session expired.");
|
|
}
|
|
const data = (await res.json().catch(() => ({}))) as { error?: string; text?: string; truncated?: boolean; chars?: number };
|
|
if (!res.ok) throw new ApiError(res.status, data.error || `OCR failed (${res.status})`);
|
|
return { text: data.text ?? "", truncated: !!data.truncated, chars: data.chars ?? 0 };
|
|
},
|
|
|
|
/** Avatar upload to the local CDN. Returns the public /cdn/… URL. */
|
|
uploadAvatar: async (userId: string, file: File): Promise<{ url: string }> => {
|
|
const res = await fetch(`/cdn/avatar/${userId}`, {
|
|
method: "PUT",
|
|
headers: { Authorization: `Bearer ${getToken()}`, "Content-Type": file.type || "application/octet-stream" },
|
|
body: file,
|
|
});
|
|
if (res.status === 401) {
|
|
clearToken();
|
|
window.location.reload();
|
|
throw new ApiError(401, "Session expired.");
|
|
}
|
|
const data = (await res.json().catch(() => ({}))) as { error?: string; url?: string };
|
|
if (!res.ok) throw new ApiError(res.status, data.error || `Upload failed (${res.status})`);
|
|
return { url: data.url! };
|
|
},
|
|
|
|
/** Streaming chat. Calls onToken per token; resolves with the full text. */
|
|
chatStream: async (
|
|
args: { model: string; messages: ChatMessage[]; conversationId?: string },
|
|
onToken: (t: string) => void,
|
|
): Promise<string> => {
|
|
const res = await fetch("/api/chat", {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json", Authorization: `Bearer ${getToken()}` },
|
|
body: JSON.stringify({ ...args, stream: true }),
|
|
});
|
|
if (res.status === 401) {
|
|
clearToken();
|
|
window.location.reload();
|
|
throw new ApiError(401, "Session expired.");
|
|
}
|
|
if (!res.ok || !res.body) {
|
|
const err = (await res.json().catch(() => ({}))) as { error?: string };
|
|
throw new ApiError(res.status, err.error || `Chat failed (${res.status})`);
|
|
}
|
|
const reader = res.body.getReader();
|
|
const decoder = new TextDecoder();
|
|
let buf = "";
|
|
let full = "";
|
|
for (;;) {
|
|
const { done, value } = await reader.read();
|
|
if (done) break;
|
|
buf += decoder.decode(value, { stream: true });
|
|
const events = buf.split("\n\n");
|
|
buf = events.pop() ?? "";
|
|
for (const ev of events) {
|
|
const m = ev.match(/^event: (\w+)\ndata: ([\s\S]*)$/m);
|
|
if (!m) continue;
|
|
const [, event, data] = m as [string, string, string];
|
|
if (event === "token") {
|
|
const token = (JSON.parse(data) as { token: string }).token;
|
|
full += token;
|
|
onToken(token);
|
|
} else if (event === "error") {
|
|
throw new ApiError(502, (JSON.parse(data) as { error?: string }).error || "stream error");
|
|
}
|
|
}
|
|
}
|
|
return full;
|
|
},
|
|
};
|