iris-chatbot 0.2.4

package/template/src/lib/data.ts

@@ -0,0 +1,324 @@
+import { nanoid } from "nanoid";
+import { db } from "./db";
+import type {
+  LocalToolsSettings,
+  MemorySettings,
+  MessageNode,
+  Settings,
+  Thread,
+} from "./types";
+import { DEFAULT_LOCAL_TOOLS_SETTINGS, DEFAULT_MEMORY_SETTINGS } from "./types";
+import { deriveTitle } from "./utils";
+import { BUILTIN_CONNECTION_IDS, migrateLegacyConnections } from "./connections";
+
+const DEFAULT_SETTINGS: Settings = {
+  id: "settings",
+  openaiKey: undefined,
+  anthropicKey: undefined,
+  geminiKey: undefined,
+  defaultProvider: "openai",
+  defaultModel: "gpt-5.2",
+  connections: [],
+  defaultConnectionId: BUILTIN_CONNECTION_IDS.openai,
+  defaultModelByConnection: {},
+  showExtendedOpenAIModels: false,
+  enableWebSources: true,
+  accentColor: "#66706e",
+  font: "manrope",
+  theme: "dark",
+  localTools: { ...DEFAULT_LOCAL_TOOLS_SETTINGS },
+  memory: { ...DEFAULT_MEMORY_SETTINGS },
+};
+
+const LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS: LocalToolsSettings = {
+  ...DEFAULT_LOCAL_TOOLS_SETTINGS,
+  approvalMode: "always_confirm_writes",
+};
+
+function sameStringArray(a: string[], b: readonly string[]): boolean {
+  if (a.length !== b.length) {
+    return false;
+  }
+  return a.every((value, index) => value === b[index]);
+}
+
+function isLegacyDefaultLocalToolsSettings(localTools: LocalToolsSettings): boolean {
+  return (
+    localTools.enabled === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.enabled &&
+    localTools.approvalMode === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.approvalMode &&
+    localTools.safetyProfile === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.safetyProfile &&
+    sameStringArray(localTools.allowedRoots, LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.allowedRoots) &&
+    localTools.enableNotes === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.enableNotes &&
+    localTools.enableApps === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.enableApps &&
+    localTools.enableNumbers === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.enableNumbers &&
+    localTools.enableWeb === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.enableWeb &&
+    localTools.enableMusic === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.enableMusic &&
+    localTools.enableCalendar === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.enableCalendar &&
+    localTools.enableMail === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.enableMail &&
+    localTools.enableWorkflow === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.enableWorkflow &&
+    localTools.enableSystem === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.enableSystem &&
+    localTools.webSearchBackend === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.webSearchBackend &&
+    localTools.dryRun === LEGACY_DEFAULT_LOCAL_TOOLS_SETTINGS.dryRun
+  );
+}
+
+function normalizeLocalToolsSettings(
+  localTools: LocalToolsSettings | undefined,
+): LocalToolsSettings {
+  if (!localTools) {
+    return { ...DEFAULT_LOCAL_TOOLS_SETTINGS };
+  }
+
+  const normalized: LocalToolsSettings = {
+    enabled:
+      typeof localTools.enabled === "boolean"
+        ? localTools.enabled
+        : DEFAULT_LOCAL_TOOLS_SETTINGS.enabled,
+    approvalMode:
+      localTools.approvalMode ?? DEFAULT_LOCAL_TOOLS_SETTINGS.approvalMode,
+    safetyProfile:
+      localTools.safetyProfile ?? DEFAULT_LOCAL_TOOLS_SETTINGS.safetyProfile,
+    allowedRoots:
+      Array.isArray(localTools.allowedRoots) && localTools.allowedRoots.length > 0
+        ? localTools.allowedRoots.filter((root) => typeof root === "string" && root.trim())
+        : [...DEFAULT_LOCAL_TOOLS_SETTINGS.allowedRoots],
+    enableNotes:
+      typeof localTools.enableNotes === "boolean"
+        ? localTools.enableNotes
+        : DEFAULT_LOCAL_TOOLS_SETTINGS.enableNotes,
+    enableApps:
+      typeof localTools.enableApps === "boolean"
+        ? localTools.enableApps
+        : DEFAULT_LOCAL_TOOLS_SETTINGS.enableApps,
+    enableNumbers:
+      typeof localTools.enableNumbers === "boolean"
+        ? localTools.enableNumbers
+        : DEFAULT_LOCAL_TOOLS_SETTINGS.enableNumbers,
+    enableWeb:
+      typeof localTools.enableWeb === "boolean"
+        ? localTools.enableWeb
+        : DEFAULT_LOCAL_TOOLS_SETTINGS.enableWeb,
+    enableMusic:
+      typeof localTools.enableMusic === "boolean"
+        ? localTools.enableMusic
+        : DEFAULT_LOCAL_TOOLS_SETTINGS.enableMusic,
+    enableCalendar:
+      typeof localTools.enableCalendar === "boolean"
+        ? localTools.enableCalendar
+        : DEFAULT_LOCAL_TOOLS_SETTINGS.enableCalendar,
+    enableMail:
+      typeof localTools.enableMail === "boolean"
+        ? localTools.enableMail
+        : DEFAULT_LOCAL_TOOLS_SETTINGS.enableMail,
+    enableWorkflow:
+      typeof localTools.enableWorkflow === "boolean"
+        ? localTools.enableWorkflow
+        : DEFAULT_LOCAL_TOOLS_SETTINGS.enableWorkflow,
+    enableSystem:
+      typeof localTools.enableSystem === "boolean"
+        ? localTools.enableSystem
+        : DEFAULT_LOCAL_TOOLS_SETTINGS.enableSystem,
+    webSearchBackend:
+      localTools.webSearchBackend ?? DEFAULT_LOCAL_TOOLS_SETTINGS.webSearchBackend,
+    dryRun:
+      typeof localTools.dryRun === "boolean"
+        ? localTools.dryRun
+        : DEFAULT_LOCAL_TOOLS_SETTINGS.dryRun,
+  };
+
+  // Migrate legacy defaults so approvals are opt-in by mode instead of always-on.
+  if (isLegacyDefaultLocalToolsSettings(normalized)) {
+    normalized.approvalMode = DEFAULT_LOCAL_TOOLS_SETTINGS.approvalMode;
+  }
+
+  return normalized;
+}
+
+function normalizeMemorySettings(memory: MemorySettings | undefined): MemorySettings {
+  return {
+    enabled:
+      typeof memory?.enabled === "boolean"
+        ? memory.enabled
+        : DEFAULT_MEMORY_SETTINGS.enabled,
+    autoCapture:
+      typeof memory?.autoCapture === "boolean"
+        ? memory.autoCapture
+        : DEFAULT_MEMORY_SETTINGS.autoCapture,
+    toolInfluence:
+      typeof memory?.toolInfluence === "boolean"
+        ? memory.toolInfluence
+        : DEFAULT_MEMORY_SETTINGS.toolInfluence,
+    extractionMode: "conservative",
+  };
+}
+
+export async function ensureDefaults() {
+  const settings = await db.settings.get("settings");
+  if (!settings) {
+    const migrated = migrateLegacyConnections(DEFAULT_SETTINGS);
+    await db.settings.put({
+      ...DEFAULT_SETTINGS,
+      ...migrated,
+    });
+  } else {
+    const updates: Partial<Settings> = {};
+    if (!settings.accentColor) {
+      updates.accentColor = DEFAULT_SETTINGS.accentColor;
+    }
+    if (!settings.font) {
+      updates.font = DEFAULT_SETTINGS.font;
+    }
+    if (!settings.theme) {
+      updates.theme = DEFAULT_SETTINGS.theme;
+    }
+
+    const normalizedLocalTools = normalizeLocalToolsSettings(settings.localTools);
+    const localToolsChanged = JSON.stringify(normalizedLocalTools) !== JSON.stringify(settings.localTools);
+    if (localToolsChanged) {
+      updates.localTools = normalizedLocalTools;
+    }
+
+    const normalizedMemory = normalizeMemorySettings(settings.memory);
+    const memoryChanged = JSON.stringify(normalizedMemory) !== JSON.stringify(settings.memory);
+    if (memoryChanged) {
+      updates.memory = normalizedMemory;
+    }
+
+    const migratedConnections = migrateLegacyConnections(settings);
+    if (JSON.stringify(settings.connections ?? []) !== JSON.stringify(migratedConnections.connections)) {
+      updates.connections = migratedConnections.connections;
+    }
+    if (settings.defaultConnectionId !== migratedConnections.defaultConnectionId) {
+      updates.defaultConnectionId = migratedConnections.defaultConnectionId;
+    }
+    if (
+      JSON.stringify(settings.defaultModelByConnection ?? {}) !==
+      JSON.stringify(migratedConnections.defaultModelByConnection)
+    ) {
+      updates.defaultModelByConnection = migratedConnections.defaultModelByConnection;
+    }
+    if (!settings.defaultProvider) {
+      updates.defaultProvider = "openai";
+    }
+    if (!settings.defaultModel) {
+      updates.defaultModel = "gpt-5.2";
+    }
+    if (typeof settings.showExtendedOpenAIModels !== "boolean") {
+      updates.showExtendedOpenAIModels = false;
+    }
+    if (typeof settings.enableWebSources !== "boolean") {
+      updates.enableWebSources = true;
+    }
+
+    if (Object.keys(updates).length > 0) {
+      await db.settings.update("settings", updates);
+    }
+  }
+
+  const threadCount = await db.threads.count();
+  if (threadCount === 0) {
+    await createNewThread();
+  }
+}
+
+export async function createNewThread() {
+  const now = Date.now();
+  const conversationId = nanoid();
+  const thread: Thread = {
+    id: nanoid(),
+    conversationId,
+    headMessageId: null,
+    title: "New chat",
+    forkedFromMessageId: null,
+    updatedAt: now,
+  };
+  await db.threads.add(thread);
+  return thread;
+}
+
+export async function createThreadFromMessage(messageId: string, conversationId: string) {
+  const existing = await db.threads
+    .where("forkedFromMessageId")
+    .equals(messageId)
+    .toArray();
+  const count = existing.filter(
+    (thread) => thread.conversationId === conversationId
+  ).length;
+  // Base path is Thread 1, so only 4 additional forked threads are allowed.
+  if (count >= 4) {
+    throw new Error("Maximum of 5 threads reached for this output.");
+  }
+
+  const now = Date.now();
+  const thread: Thread = {
+    id: nanoid(),
+    conversationId,
+    headMessageId: messageId,
+    title: `Thread ${count + 2}`,
+    forkedFromMessageId: messageId,
+    updatedAt: now,
+  };
+  await db.threads.add(thread);
+  return thread;
+}
+
+export async function deleteThread(threadId: string) {
+  await db.threads.delete(threadId);
+}
+
+export async function deleteConversation(conversationId: string) {
+  await db.transaction(
+    "rw",
+    [db.threads, db.messages, db.toolEvents, db.toolApprovals, db.memories],
+    async () => {
+      await db.threads.where("conversationId").equals(conversationId).delete();
+      await db.messages.where("conversationId").equals(conversationId).delete();
+      await db.toolEvents.where("conversationId").equals(conversationId).delete();
+      await db.toolApprovals.where("conversationId").equals(conversationId).delete();
+      await db.memories.where("conversationId").equals(conversationId).delete();
+    },
+  );
+}
+
+export async function appendUserAndAssistant(params: {
+  thread: Thread;
+  content: string;
+  provider: string;
+  model: string;
+}) {
+  const { thread, content, provider, model } = params;
+  const now = Date.now();
+  const userId = nanoid();
+  const assistantId = nanoid();
+
+  const userMessage: MessageNode = {
+    id: userId,
+    conversationId: thread.conversationId,
+    parentId: thread.headMessageId,
+    role: "user",
+    content,
+    createdAt: now,
+  };
+
+  const assistantMessage: MessageNode = {
+    id: assistantId,
+    conversationId: thread.conversationId,
+    parentId: userId,
+    role: "assistant",
+    content: "",
+    createdAt: now + 1,
+    provider,
+    model,
+  };
+
+  await db.messages.bulkAdd([userMessage, assistantMessage]);
+
+  const title = thread.title === "New chat" ? deriveTitle(content) : thread.title;
+  await db.threads.update(thread.id, {
+    headMessageId: assistantId,
+    updatedAt: Date.now(),
+    title,
+  });
+
+  return { userMessage, assistantMessage };
+}

package/template/src/lib/db.ts

@@ -0,0 +1,49 @@
+import Dexie, { Table } from "dexie";
+import type { MemoryEntry, MessageNode, Settings, Thread, ToolApproval, ToolEvent } from "./types";
+
+class ZenithDB extends Dexie {
+  messages!: Table<MessageNode, string>;
+  threads!: Table<Thread, string>;
+  settings!: Table<Settings, string>;
+  toolEvents!: Table<ToolEvent, string>;
+  toolApprovals!: Table<ToolApproval, string>;
+  memories!: Table<MemoryEntry, string>;
+
+  constructor() {
+    super("zenith-chat");
+    this.version(1).stores({
+      messages: "id, conversationId, parentId, createdAt",
+      threads: "id, conversationId, headMessageId, updatedAt",
+      settings: "id",
+    });
+    this.version(2).stores({
+      messages: "id, conversationId, parentId, createdAt",
+      threads: "id, conversationId, headMessageId, forkedFromMessageId, updatedAt",
+      settings: "id",
+    });
+    this.version(3).stores({
+      messages: "id, conversationId, parentId, createdAt",
+      threads: "id, conversationId, headMessageId, forkedFromMessageId, updatedAt",
+      settings: "id",
+      toolEvents: "id, conversationId, threadId, assistantMessageId, toolCallId, createdAt",
+      toolApprovals: "id, conversationId, threadId, assistantMessageId, toolCallId, status, requestedAt",
+    });
+    this.version(4).stores({
+      messages: "id, conversationId, parentId, createdAt",
+      threads: "id, conversationId, headMessageId, forkedFromMessageId, updatedAt",
+      settings: "id",
+      toolEvents: "id, conversationId, threadId, assistantMessageId, toolCallId, createdAt",
+      toolApprovals: "id, conversationId, threadId, assistantMessageId, toolCallId, status, requestedAt",
+    });
+    this.version(5).stores({
+      messages: "id, conversationId, parentId, createdAt",
+      threads: "id, conversationId, headMessageId, forkedFromMessageId, updatedAt",
+      settings: "id",
+      toolEvents: "id, conversationId, threadId, assistantMessageId, toolCallId, createdAt",
+      toolApprovals: "id, conversationId, threadId, assistantMessageId, toolCallId, status, requestedAt",
+      memories: "id, kind, scope, conversationId, normalizedKey, updatedAt, lastUsedAt",
+    });
+  }
+}
+
+export const db = new ZenithDB();

package/template/src/lib/hooks.ts

@@ -0,0 +1,76 @@
+import { useLiveQuery } from "dexie-react-hooks";
+import { db } from "./db";
+import type { MemoryEntry, MessageNode, Settings, Thread, ToolApproval, ToolEvent } from "./types";
+
+export function useThreads(): Thread[] | undefined {
+  return useLiveQuery<Thread[], Thread[]>(
+    () => db.threads.orderBy("updatedAt").reverse().toArray(),
+    [],
+    [] as Thread[]
+  );
+}
+
+export function useSettings(): Settings | null | undefined {
+  return useLiveQuery<Settings | null, Settings | null>(
+    () => db.settings.get("settings").then((value) => value ?? null),
+    [],
+    null
+  );
+}
+
+export function useConversationMessages(
+  conversationId: string | null
+): MessageNode[] | undefined {
+  return useLiveQuery<MessageNode[], MessageNode[]>(
+    () =>
+      conversationId
+        ? db.messages.where("conversationId").equals(conversationId).toArray()
+        : Promise.resolve([] as MessageNode[]),
+    [conversationId],
+    [] as MessageNode[]
+  );
+}
+
+export function useToolEvents(
+  conversationId: string | null
+): ToolEvent[] | undefined {
+  return useLiveQuery<ToolEvent[], ToolEvent[]>(
+    () =>
+      conversationId
+        ? db.toolEvents.where("conversationId").equals(conversationId).sortBy("createdAt")
+        : Promise.resolve([] as ToolEvent[]),
+    [conversationId],
+    [] as ToolEvent[]
+  );
+}
+
+export function useToolApprovals(
+  conversationId: string | null
+): ToolApproval[] | undefined {
+  return useLiveQuery<ToolApproval[], ToolApproval[]>(
+    () =>
+      conversationId
+        ? db.toolApprovals.where("conversationId").equals(conversationId).sortBy("requestedAt")
+        : Promise.resolve([] as ToolApproval[]),
+    [conversationId],
+    [] as ToolApproval[]
+  );
+}
+
+export function useMemories(
+  conversationId?: string | null
+): MemoryEntry[] | undefined {
+  return useLiveQuery<MemoryEntry[], MemoryEntry[]>(
+    async () => {
+      const all = await db.memories.orderBy("updatedAt").reverse().toArray();
+      if (!conversationId) {
+        return all;
+      }
+      return all.filter(
+        (entry) => entry.scope === "global" || entry.conversationId === conversationId,
+      );
+    },
+    [conversationId],
+    [] as MemoryEntry[],
+  );
+}

package/template/src/lib/local-sync.ts

@@ -0,0 +1,192 @@
+"use client";
+
+import { db } from "./db";
+import type {
+  MemoryEntry,
+  MessageNode,
+  Settings,
+  Thread,
+  ToolApproval,
+  ToolEvent,
+} from "./types";
+
+export type SyncPayload = {
+  threads: Thread[];
+  messages: MessageNode[];
+  settings: Settings[];
+  toolEvents: ToolEvent[];
+  toolApprovals: ToolApproval[];
+  memories: MemoryEntry[];
+};
+
+export function isLocalhost(): boolean {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  const h = window.location.hostname;
+  return h === "localhost" || h === "127.0.0.1";
+}
+
+export async function exportAll(): Promise<SyncPayload> {
+  const [threads, messages, settings, toolEvents, toolApprovals, memories] =
+    await Promise.all([
+      db.threads.toArray(),
+      db.messages.toArray(),
+      db.settings.toArray(),
+      db.toolEvents.toArray(),
+      db.toolApprovals.toArray(),
+      db.memories.toArray(),
+    ]);
+  return {
+    threads,
+    messages,
+    settings,
+    toolEvents,
+    toolApprovals,
+    memories,
+  };
+}
+
+export async function importAll(payload: SyncPayload): Promise<void> {
+  await db.transaction(
+    "rw",
+    [
+      db.threads,
+      db.messages,
+      db.settings,
+      db.toolEvents,
+      db.toolApprovals,
+      db.memories,
+    ],
+    async () => {
+      await db.toolEvents.clear();
+      await db.toolApprovals.clear();
+      await db.memories.clear();
+      await db.messages.clear();
+      await db.threads.clear();
+      await db.settings.clear();
+
+      if (payload.settings.length > 0) {
+        await db.settings.bulkPut(payload.settings);
+      }
+      if (payload.threads.length > 0) {
+        await db.threads.bulkPut(payload.threads);
+      }
+      if (payload.messages.length > 0) {
+        await db.messages.bulkPut(payload.messages);
+      }
+      if (payload.toolEvents.length > 0) {
+        await db.toolEvents.bulkPut(payload.toolEvents);
+      }
+      if (payload.toolApprovals.length > 0) {
+        await db.toolApprovals.bulkPut(payload.toolApprovals);
+      }
+      if (payload.memories.length > 0) {
+        await db.memories.bulkPut(payload.memories);
+      }
+    },
+  );
+}
+
+export async function loadFromServer(): Promise<void> {
+  if (!isLocalhost()) {
+    return;
+  }
+  const res = await fetch("/api/local-sync");
+  if (!res.ok) {
+    return;
+  }
+  const data = (await res.json()) as SyncPayload;
+  const hasData =
+    data.threads?.length > 0 ||
+    data.messages?.length > 0 ||
+    (data.settings?.length ?? 0) > 0 ||
+    (data.toolEvents?.length ?? 0) > 0 ||
+    (data.toolApprovals?.length ?? 0) > 0 ||
+    (data.memories?.length ?? 0) > 0;
+  if (!hasData) {
+    return;
+  }
+  await importAll({
+    threads: Array.isArray(data.threads) ? data.threads : [],
+    messages: Array.isArray(data.messages) ? data.messages : [],
+    settings: Array.isArray(data.settings) ? data.settings : [],
+    toolEvents: Array.isArray(data.toolEvents) ? data.toolEvents : [],
+    toolApprovals: Array.isArray(data.toolApprovals) ? data.toolApprovals : [],
+    memories: Array.isArray(data.memories) ? data.memories : [],
+  });
+}
+
+const SAVE_DEBOUNCE_MS = 700;
+let saveTimeout: ReturnType<typeof setTimeout> | null = null;
+
+function scheduleSave(): void {
+  if (!isLocalhost()) {
+    return;
+  }
+  if (saveTimeout) {
+    clearTimeout(saveTimeout);
+  }
+  saveTimeout = setTimeout(async () => {
+    saveTimeout = null;
+    try {
+      const payload = await exportAll();
+      await fetch("/api/local-sync", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      });
+    } catch {
+      // Ignore sync errors (e.g. server down, offline)
+    }
+  }, SAVE_DEBOUNCE_MS);
+}
+
+export async function saveToServer(): Promise<void> {
+  if (!isLocalhost()) {
+    return;
+  }
+  if (saveTimeout) {
+    clearTimeout(saveTimeout);
+    saveTimeout = null;
+  }
+  try {
+    const payload = await exportAll();
+    await fetch("/api/local-sync", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+  } catch {
+    // Ignore
+  }
+}
+
+function registerTableHooks(): void {
+  const tables = [
+    db.threads,
+    db.messages,
+    db.settings,
+    db.toolEvents,
+    db.toolApprovals,
+    db.memories,
+  ] as const;
+  for (const table of tables) {
+    table.hook("creating", () => {
+      scheduleSave();
+    });
+    table.hook("updating", () => {
+      scheduleSave();
+    });
+    table.hook("deleting", () => {
+      scheduleSave();
+    });
+  }
+}
+
+export function registerSyncHooks(): void {
+  if (!isLocalhost()) {
+    return;
+  }
+  registerTableHooks();
+}