stave/electron/main/ipc/persistence.ts at 0497d78cf9678f128bc5323be030f00493995fa7 · sendbird/stave · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
import { ipcMain } from "electron";
import type { PersistenceWorkspaceSnapshot } from "../../persistence/types";
import {
  ListLatestWorkspaceTurnsArgsSchema,
  ListTaskTurnsArgsSchema,
  ListTurnEventsArgsSchema,
  PersistenceUpsertArgsSchema,
  WorkspaceIdArgsSchema,
} from "./schemas";
import { ensurePersistenceReady, ensurePersistenceReadySync } from "../state";

export function registerPersistenceHandlers() {
  ipcMain.handle("persistence:list-workspaces", async () => {
    const store = await ensurePersistenceReady();
    const rows = store.listWorkspaceSummaries();
    return { ok: true, rows };
  });

  ipcMain.handle("persistence:load-workspace", async (_event, args: unknown) => {
    const parsedArgs = WorkspaceIdArgsSchema.safeParse(args);
    if (!parsedArgs.success) {
      return { ok: false, snapshot: null };
    }
    const store = await ensurePersistenceReady();
    const snapshot = store.loadWorkspaceSnapshot({ workspaceId: parsedArgs.data.workspaceId });
    return { ok: true, snapshot };
  });

  ipcMain.handle("persistence:upsert-workspace", async (_event, args: unknown) => {
    const parsedArgs = PersistenceUpsertArgsSchema.safeParse(args);
    if (!parsedArgs.success) {
      return { ok: false };
    }
    const store = await ensurePersistenceReady();
    store.upsertWorkspace({
      id: parsedArgs.data.id,
      name: parsedArgs.data.name,
      snapshot: parsedArgs.data.snapshot as PersistenceWorkspaceSnapshot,
    });
    return { ok: true };
  });

  ipcMain.on("persistence:upsert-workspace-sync", (event, args: unknown) => {
    const parsedArgs = PersistenceUpsertArgsSchema.safeParse(args);
    if (!parsedArgs.success) {
      event.returnValue = { ok: false, message: "Invalid workspace persistence request." };
      return;
    }
    try {
      const store = ensurePersistenceReadySync();
      store.upsertWorkspace({
        id: parsedArgs.data.id,
        name: parsedArgs.data.name,
        snapshot: parsedArgs.data.snapshot as PersistenceWorkspaceSnapshot,
      });
      event.returnValue = { ok: true };
    } catch (error) {
      console.error("[persistence] upsert-workspace-sync failed:", error);
      event.returnValue = { ok: false, message: String(error) };
    }
  });

  ipcMain.handle("persistence:delete-workspace", async (_event, args: unknown) => {
    const parsedArgs = WorkspaceIdArgsSchema.safeParse(args);
    if (!parsedArgs.success) {
      return { ok: false };
    }
    const store = await ensurePersistenceReady();
    store.deleteWorkspace({ workspaceId: parsedArgs.data.workspaceId });
    return { ok: true };
  });

  ipcMain.handle("persistence:list-turn-events", async (_event, args: unknown) => {
    const parsedArgs = ListTurnEventsArgsSchema.safeParse(args);
    if (!parsedArgs.success) {
      return { ok: false, events: [] };
    }
    const store = await ensurePersistenceReady();
    const events = store.listTurnEvents({
      turnId: parsedArgs.data.turnId,
      afterSequence: parsedArgs.data.afterSequence,
      limit: parsedArgs.data.limit,
    });
    return { ok: true, events };
  });

  ipcMain.handle("persistence:list-task-turns", async (_event, args: unknown) => {
    const parsedArgs = ListTaskTurnsArgsSchema.safeParse(args);
    if (!parsedArgs.success) {
      return { ok: false, turns: [] };
    }
    const store = await ensurePersistenceReady();
    const turns = store.listTurns({
      workspaceId: parsedArgs.data.workspaceId,
      taskId: parsedArgs.data.taskId,
      limit: parsedArgs.data.limit,
    });
    return { ok: true, turns };
  });

  ipcMain.handle("persistence:list-latest-workspace-turns", async (_event, args: unknown) => {
    const parsedArgs = ListLatestWorkspaceTurnsArgsSchema.safeParse(args);
    if (!parsedArgs.success) {
      return { ok: false, turns: [] };
    }
    const store = await ensurePersistenceReady();
    const turns = store.listLatestTurnsForWorkspace({
      workspaceId: parsedArgs.data.workspaceId,
      limit: parsedArgs.data.limit,
    });
    return { ok: true, turns };
  });
}