@miaws/miaw 1.18.5 → 1.18.6

package/src/server/routes/instance/httpapi/handlers/question.ts

@@ -1,54 +0,0 @@
-import { Question } from "@/question"
-import { QuestionID } from "@/question/schema"
-import { Effect } from "effect"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { InstanceHttpApi } from "../api"
-import { QuestionNotFoundError } from "../errors"
-
-export const questionHandlers = HttpApiBuilder.group(InstanceHttpApi, "question", (handlers) =>
-  Effect.gen(function* () {
-    const svc = yield* Question.Service
-
-    const list = Effect.fn("QuestionHttpApi.list")(function* () {
-      return yield* svc.list()
-    })
-
-    const reply = Effect.fn("QuestionHttpApi.reply")(function* (ctx: {
-      params: { requestID: QuestionID }
-      payload: Question.Reply
-    }) {
-      yield* svc
-        .reply({
-          requestID: ctx.params.requestID,
-          answers: ctx.payload.answers,
-        })
-        .pipe(
-          Effect.catchTag("Question.NotFoundError", (error) =>
-            Effect.fail(
-              new QuestionNotFoundError({
-                requestID: String(error.requestID),
-                message: `Question request not found: ${error.requestID}`,
-              }),
-            ),
-          ),
-        )
-      return true
-    })
-
-    const reject = Effect.fn("QuestionHttpApi.reject")(function* (ctx: { params: { requestID: QuestionID } }) {
-      yield* svc.reject(ctx.params.requestID).pipe(
-        Effect.catchTag("Question.NotFoundError", (error) =>
-          Effect.fail(
-            new QuestionNotFoundError({
-              requestID: String(error.requestID),
-              message: `Question request not found: ${error.requestID}`,
-            }),
-          ),
-        ),
-      )
-      return true
-    })
-
-    return handlers.handle("list", list).handle("reply", reply).handle("reject", reject)
-  }),
-)

package/src/server/routes/instance/httpapi/handlers/session-errors.ts

@@ -1,21 +0,0 @@
-import type { NotFoundError as StorageNotFoundError } from "@/storage/storage"
-import type { Session } from "@/session/session"
-import { Effect } from "effect"
-import * as ApiError from "../errors"
-
-export function mapStorageNotFound<A, R>(self: Effect.Effect<A, StorageNotFoundError, R>) {
-  return self.pipe(Effect.mapError((error) => ApiError.notFound(error.message)))
-}
-
-export function mapBusy<A, R>(self: Effect.Effect<A, Session.BusyError, R>) {
-  return self.pipe(
-    Effect.catchTag("SessionBusyError", (error) =>
-      Effect.fail(
-        new ApiError.SessionBusyError({
-          sessionID: error.sessionID,
-          message: `Session is busy: ${error.sessionID}`,
-        }),
-      ),
-    ),
-  )
-}

package/src/server/routes/instance/httpapi/handlers/session.ts

@@ -1,440 +0,0 @@
-import { PermissionV1 } from "@miaw/core/v1/permission"
-import { Agent } from "@/agent/agent"
-import { SessionV1 } from "@miaw/core/v1/session"
-import { EventV2Bridge } from "@/event-v2-bridge"
-import { Command } from "@/command"
-import { Permission } from "@/permission"
-import { SessionShare } from "@/share/session"
-import { Session } from "@/session/session"
-import { SessionCompaction } from "@/session/compaction"
-import { MessageV2 } from "@/session/message-v2"
-import { SessionPrompt } from "@/session/prompt"
-import { SessionRevert } from "@/session/revert"
-import { SessionRunState } from "@/session/run-state"
-import { SessionStatus } from "@/session/status"
-import { SessionSummary } from "@/session/summary"
-import { Todo } from "@/session/todo"
-import { MessageID, PartID, SessionID } from "@/session/schema"
-import { NamedError } from "@miaw/core/util/error"
-import { Cause, Effect, Option, Schema, Scope } from "effect"
-import * as Stream from "effect/Stream"
-import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
-import { HttpApiBuilder, HttpApiError, HttpApiSchema } from "effect/unstable/httpapi"
-import { InstanceHttpApi } from "../api"
-import {
-  CommandPayload,
-  DiffQuery,
-  ForkPayload,
-  InitPayload,
-  ListQuery,
-  MessagesQuery,
-  PermissionResponsePayload,
-  PromptPayload,
-  RevertPayload,
-  ShellPayload,
-  SummarizePayload,
-  UpdatePayload,
-} from "../groups/session"
-import { PermissionNotFoundError } from "../errors"
-import * as SessionError from "./session-errors"
-
-const tryParseJson = (text: string) =>
-  Effect.try({
-    try: () => JSON.parse(text) as unknown,
-    catch: () => new HttpApiError.BadRequest({}),
-  })
-
-export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session", (handlers) =>
-  Effect.gen(function* () {
-    const session = yield* Session.Service
-    const shareSvc = yield* SessionShare.Service
-    const promptSvc = yield* SessionPrompt.Service
-    const revertSvc = yield* SessionRevert.Service
-    const compactSvc = yield* SessionCompaction.Service
-    const runState = yield* SessionRunState.Service
-    const agentSvc = yield* Agent.Service
-    const permissionSvc = yield* Permission.Service
-    const statusSvc = yield* SessionStatus.Service
-    const todoSvc = yield* Todo.Service
-    const summary = yield* SessionSummary.Service
-    const events = yield* EventV2Bridge.Service
-    const scope = yield* Scope.Scope
-
-    const list = Effect.fn("SessionHttpApi.list")(function* (ctx: { query: typeof ListQuery.Type }) {
-      return yield* session.list({
-        directory: ctx.query.scope === "project" ? undefined : ctx.query.directory,
-        scope: ctx.query.scope,
-        path: ctx.query.path,
-        roots: ctx.query.roots,
-        start: ctx.query.start,
-        search: ctx.query.search,
-        limit: ctx.query.limit,
-      })
-    })
-
-    const status = Effect.fn("SessionHttpApi.status")(function* () {
-      return Object.fromEntries(yield* statusSvc.list())
-    })
-
-    const requireSession = Effect.fn("SessionHttpApi.requireSession")(function* (sessionID: SessionID) {
-      return yield* SessionError.mapStorageNotFound(session.get(sessionID))
-    })
-
-    const get = Effect.fn("SessionHttpApi.get")(function* (ctx: { params: { sessionID: SessionID } }) {
-      return yield* requireSession(ctx.params.sessionID)
-    })
-
-    const children = Effect.fn("SessionHttpApi.children")(function* (ctx: { params: { sessionID: SessionID } }) {
-      yield* requireSession(ctx.params.sessionID)
-      return yield* session.children(ctx.params.sessionID)
-    })
-
-    const todo = Effect.fn("SessionHttpApi.todo")(function* (ctx: { params: { sessionID: SessionID } }) {
-      yield* requireSession(ctx.params.sessionID)
-      return yield* todoSvc.get(ctx.params.sessionID)
-    })
-
-    const diff = Effect.fn("SessionHttpApi.diff")(function* (ctx: {
-      params: { sessionID: SessionID }
-      query: typeof DiffQuery.Type
-    }) {
-      return yield* summary.diff({ sessionID: ctx.params.sessionID, messageID: ctx.query.messageID })
-    })
-
-    const messages = Effect.fn("SessionHttpApi.messages")(function* (ctx: {
-      params: { sessionID: SessionID }
-      query: typeof MessagesQuery.Type
-    }) {
-      if (ctx.query.before && ctx.query.limit === undefined) return yield* new HttpApiError.BadRequest({})
-      if (ctx.query.before) {
-        const before = ctx.query.before
-        yield* Effect.try({
-          try: () => MessageV2.cursor.decode(before),
-          catch: () => new HttpApiError.BadRequest({}),
-        })
-      }
-      yield* requireSession(ctx.params.sessionID)
-      if (ctx.query.limit === undefined || ctx.query.limit === 0) {
-        return yield* SessionError.mapStorageNotFound(session.messages({ sessionID: ctx.params.sessionID }))
-      }
-
-      const page = yield* SessionError.mapStorageNotFound(
-        MessageV2.page({
-          sessionID: ctx.params.sessionID,
-          limit: ctx.query.limit,
-          before: ctx.query.before,
-        }),
-      )
-      if (!page.cursor) return page.items
-
-      const request = yield* HttpServerRequest.HttpServerRequest
-      // toURL() honors the Host + x-forwarded-proto headers, so the Link
-      // header echoes the real origin instead of a hard-coded localhost.
-      const url = Option.getOrElse(HttpServerRequest.toURL(request), () => new URL(request.url, "http://localhost"))
-      url.searchParams.set("limit", ctx.query.limit.toString())
-      url.searchParams.set("before", page.cursor)
-      return HttpServerResponse.jsonUnsafe(page.items, {
-        headers: {
-          "Access-Control-Expose-Headers": "Link, X-Next-Cursor",
-          Link: `<${url.toString()}>; rel="next"`,
-          "X-Next-Cursor": page.cursor,
-        },
-      })
-    })
-
-    const message = Effect.fn("SessionHttpApi.message")(function* (ctx: {
-      params: { sessionID: SessionID; messageID: MessageID }
-    }) {
-      return yield* SessionError.mapStorageNotFound(
-        MessageV2.get({ sessionID: ctx.params.sessionID, messageID: ctx.params.messageID }),
-      )
-    })
-
-    const create = Effect.fn("SessionHttpApi.create")(function* (ctx: { payload?: Session.CreateInput }) {
-      return yield* shareSvc.create(ctx.payload)
-    })
-
-    const createRaw = Effect.fn("SessionHttpApi.createRaw")(function* (ctx: {
-      request: HttpServerRequest.HttpServerRequest
-    }) {
-      const body = yield* Effect.orDie(ctx.request.text)
-      if (body.trim().length === 0) return yield* create({})
-
-      const json = yield* tryParseJson(body)
-      const decoded = yield* Schema.decodeUnknownEffect(Session.CreateInput)(json).pipe(
-        Effect.mapError(() => new HttpApiError.BadRequest({})),
-      )
-      const payload = decoded
-        ? {
-            ...decoded,
-            permission: decoded.permission ? [...decoded.permission] : undefined,
-          }
-        : decoded
-      return yield* create({ payload })
-    })
-
-    const remove = Effect.fn("SessionHttpApi.remove")(function* (ctx: { params: { sessionID: SessionID } }) {
-      yield* SessionError.mapStorageNotFound(session.remove(ctx.params.sessionID))
-      return true
-    })
-
-    const update = Effect.fn("SessionHttpApi.update")(function* (ctx: {
-      params: { sessionID: SessionID }
-      payload: typeof UpdatePayload.Type
-    }) {
-      const current = yield* requireSession(ctx.params.sessionID)
-      if (ctx.payload.title !== undefined) {
-        yield* session.setTitle({ sessionID: ctx.params.sessionID, title: ctx.payload.title })
-      }
-      if (ctx.payload.metadata !== undefined) {
-        yield* session.setMetadata({ sessionID: ctx.params.sessionID, metadata: ctx.payload.metadata })
-      }
-      if (ctx.payload.permission !== undefined) {
-        yield* session.setPermission({
-          sessionID: ctx.params.sessionID,
-          permission: Permission.merge(current.permission ?? [], ctx.payload.permission),
-        })
-      }
-      if (ctx.payload.time?.archived !== undefined) {
-        yield* session.setArchived({ sessionID: ctx.params.sessionID, time: ctx.payload.time.archived })
-      }
-      return yield* requireSession(ctx.params.sessionID)
-    })
-
-    const fork = Effect.fn("SessionHttpApi.fork")(function* (ctx: {
-      params: { sessionID: SessionID }
-      payload?: typeof ForkPayload.Type
-    }) {
-      return yield* SessionError.mapStorageNotFound(
-        session.fork({
-          sessionID: ctx.params.sessionID,
-          messageID: ctx.payload?.messageID,
-        }),
-      )
-    })
-
-    const forkRaw = Effect.fn("SessionHttpApi.forkRaw")(function* (ctx: {
-      params: { sessionID: SessionID }
-      request: HttpServerRequest.HttpServerRequest
-    }) {
-      const body = yield* Effect.orDie(ctx.request.text)
-      if (body.trim().length === 0) return yield* fork({ params: ctx.params })
-
-      const json = yield* tryParseJson(body)
-      const payload = yield* Schema.decodeUnknownEffect(ForkPayload)(json).pipe(
-        Effect.mapError(() => new HttpApiError.BadRequest({})),
-      )
-      return yield* fork({ params: ctx.params, payload })
-    })
-
-    const abort = Effect.fn("SessionHttpApi.abort")(function* (ctx: { params: { sessionID: SessionID } }) {
-      yield* promptSvc.cancel(ctx.params.sessionID)
-      return true
-    })
-
-    const init = Effect.fn("SessionHttpApi.init")(function* (ctx: {
-      params: { sessionID: SessionID }
-      payload: typeof InitPayload.Type
-    }) {
-      yield* requireSession(ctx.params.sessionID)
-      yield* promptSvc
-        .command({
-          sessionID: ctx.params.sessionID,
-          messageID: ctx.payload.messageID,
-          model: `${ctx.payload.providerID}/${ctx.payload.modelID}`,
-          command: Command.Default.INIT,
-          arguments: "",
-        })
-        .pipe(Effect.mapError(() => new HttpApiError.BadRequest({})))
-      return true
-    })
-
-    // share/unshare errors aren't all client-induced — storage and network
-    // failures from SessionShare are real possibilities. Map to a typed 500
-    // (matches the legacy route behavior which routed any failure through
-    // ErrorMiddleware → NamedError.Unknown 500) instead of blanket-mapping
-    // every failure to a 400 BadRequest.
-    const share = Effect.fn("SessionHttpApi.share")(function* (ctx: { params: { sessionID: SessionID } }) {
-      yield* requireSession(ctx.params.sessionID)
-      yield* shareSvc.share(ctx.params.sessionID).pipe(Effect.mapError(() => new HttpApiError.InternalServerError({})))
-      return yield* requireSession(ctx.params.sessionID)
-    })
-
-    const unshare = Effect.fn("SessionHttpApi.unshare")(function* (ctx: { params: { sessionID: SessionID } }) {
-      yield* requireSession(ctx.params.sessionID)
-      yield* shareSvc
-        .unshare(ctx.params.sessionID)
-        .pipe(Effect.mapError(() => new HttpApiError.InternalServerError({})))
-      return yield* requireSession(ctx.params.sessionID)
-    })
-
-    const summarize = Effect.fn("SessionHttpApi.summarize")(function* (ctx: {
-      params: { sessionID: SessionID }
-      payload: typeof SummarizePayload.Type
-    }) {
-      yield* revertSvc.cleanup(yield* requireSession(ctx.params.sessionID))
-      const messages = yield* SessionError.mapStorageNotFound(session.messages({ sessionID: ctx.params.sessionID }))
-      const defaultAgent = yield* agentSvc.defaultAgent()
-      const currentAgent = messages.findLast((message) => message.info.role === "user")?.info.agent ?? defaultAgent
-
-      yield* compactSvc.create({
-        sessionID: ctx.params.sessionID,
-        agent: currentAgent,
-        model: {
-          providerID: ctx.payload.providerID,
-          modelID: ctx.payload.modelID,
-        },
-        auto: ctx.payload.auto ?? false,
-      })
-      yield* promptSvc.loop({ sessionID: ctx.params.sessionID })
-      return true
-    })
-
-    const prompt = Effect.fn("SessionHttpApi.prompt")(function* (ctx: {
-      params: { sessionID: SessionID }
-      payload: typeof PromptPayload.Type
-    }) {
-      yield* requireSession(ctx.params.sessionID)
-      const message = yield* promptSvc
-        .prompt({
-          ...ctx.payload,
-          sessionID: ctx.params.sessionID,
-        })
-        .pipe(Effect.mapError(() => new HttpApiError.BadRequest({})))
-      return HttpServerResponse.stream(Stream.make(JSON.stringify(message)).pipe(Stream.encodeText), {
-        contentType: "application/json",
-      })
-    })
-
-    const promptAsync = Effect.fn("SessionHttpApi.promptAsync")(function* (ctx: {
-      params: { sessionID: SessionID }
-      payload: typeof PromptPayload.Type
-    }) {
-      yield* requireSession(ctx.params.sessionID)
-      yield* promptSvc.prompt({ ...ctx.payload, sessionID: ctx.params.sessionID }).pipe(
-        Effect.catchCause((cause) =>
-          Effect.gen(function* () {
-            yield* Effect.logError("prompt_async failed", { sessionID: ctx.params.sessionID, cause })
-            yield* events.publish(Session.Event.Error, {
-              sessionID: ctx.params.sessionID,
-              error: new NamedError.Unknown({ message: Cause.pretty(cause) }).toObject(),
-            })
-          }),
-        ),
-        Effect.forkIn(scope, { startImmediately: true }),
-      )
-      return HttpApiSchema.NoContent.make()
-    })
-
-    const command = Effect.fn("SessionHttpApi.command")(function* (ctx: {
-      params: { sessionID: SessionID }
-      payload: typeof CommandPayload.Type
-    }) {
-      yield* requireSession(ctx.params.sessionID)
-      return yield* promptSvc
-        .command({ ...ctx.payload, sessionID: ctx.params.sessionID })
-        .pipe(Effect.mapError(() => new HttpApiError.BadRequest({})))
-    })
-
-    const shell = Effect.fn("SessionHttpApi.shell")(function* (ctx: {
-      params: { sessionID: SessionID }
-      payload: typeof ShellPayload.Type
-    }) {
-      yield* requireSession(ctx.params.sessionID)
-      return yield* SessionError.mapBusy(promptSvc.shell({ ...ctx.payload, sessionID: ctx.params.sessionID }))
-    })
-
-    const revert = Effect.fn("SessionHttpApi.revert")(function* (ctx: {
-      params: { sessionID: SessionID }
-      payload: typeof RevertPayload.Type
-    }) {
-      yield* requireSession(ctx.params.sessionID)
-      return yield* SessionError.mapBusy(revertSvc.revert({ sessionID: ctx.params.sessionID, ...ctx.payload }))
-    })
-
-    const unrevert = Effect.fn("SessionHttpApi.unrevert")(function* (ctx: { params: { sessionID: SessionID } }) {
-      yield* requireSession(ctx.params.sessionID)
-      return yield* SessionError.mapBusy(revertSvc.unrevert({ sessionID: ctx.params.sessionID }))
-    })
-
-    const permissionRespond = Effect.fn("SessionHttpApi.permissionRespond")(function* (ctx: {
-      params: { sessionID: SessionID; permissionID: PermissionV1.ID }
-      payload: typeof PermissionResponsePayload.Type
-    }) {
-      yield* requireSession(ctx.params.sessionID)
-      yield* permissionSvc.reply({ requestID: ctx.params.permissionID, reply: ctx.payload.response }).pipe(
-        Effect.catchTag("Permission.NotFoundError", (error) =>
-          Effect.fail(
-            new PermissionNotFoundError({
-              requestID: String(error.requestID),
-              message: `Permission request not found: ${error.requestID}`,
-            }),
-          ),
-        ),
-      )
-      return true
-    })
-
-    const deleteMessage = Effect.fn("SessionHttpApi.deleteMessage")(function* (ctx: {
-      params: { sessionID: SessionID; messageID: MessageID }
-    }) {
-      yield* requireSession(ctx.params.sessionID)
-      yield* SessionError.mapBusy(runState.assertNotBusy(ctx.params.sessionID))
-      yield* session.removeMessage(ctx.params)
-      return true
-    })
-
-    const deletePart = Effect.fn("SessionHttpApi.deletePart")(function* (ctx: {
-      params: { sessionID: SessionID; messageID: MessageID; partID: PartID }
-    }) {
-      yield* requireSession(ctx.params.sessionID)
-      yield* session.removePart(ctx.params)
-      return true
-    })
-
-    const updatePart = Effect.fn("SessionHttpApi.updatePart")(function* (ctx: {
-      params: { sessionID: SessionID; messageID: MessageID; partID: PartID }
-      payload: typeof SessionV1.Part.Type
-    }) {
-      yield* requireSession(ctx.params.sessionID)
-      const payload = ctx.payload as SessionV1.Part
-      if (
-        payload.id !== ctx.params.partID ||
-        payload.messageID !== ctx.params.messageID ||
-        payload.sessionID !== ctx.params.sessionID
-      ) {
-        return yield* new HttpApiError.BadRequest({})
-      }
-      return yield* session.updatePart(payload)
-    })
-
-    return handlers
-      .handle("list", list)
-      .handle("status", status)
-      .handle("get", get)
-      .handle("children", children)
-      .handle("todo", todo)
-      .handle("diff", diff)
-      .handle("messages", messages)
-      .handle("message", message)
-      .handleRaw("create", createRaw)
-      .handle("remove", remove)
-      .handle("update", update)
-      .handleRaw("fork", forkRaw)
-      .handle("abort", abort)
-      .handle("init", init)
-      .handle("share", share)
-      .handle("unshare", unshare)
-      .handle("summarize", summarize)
-      .handle("prompt", prompt)
-      .handle("promptAsync", promptAsync)
-      .handle("command", command)
-      .handle("shell", shell)
-      .handle("revert", revert)
-      .handle("unrevert", unrevert)
-      .handle("permissionRespond", permissionRespond)
-      .handle("deleteMessage", deleteMessage)
-      .handle("deletePart", deletePart)
-      .handle("updatePart", updatePart)
-  }),
-)

package/src/server/routes/instance/httpapi/handlers/sync.ts

@@ -1,89 +0,0 @@
-import { Workspace } from "@/control-plane/workspace"
-import * as InstanceState from "@/effect/instance-state"
-import { Session } from "@/session/session"
-import { Database } from "@miaw/core/database/database"
-import { EventV2 } from "@miaw/core/event"
-import { EventV2Bridge } from "@/event-v2-bridge"
-import { EventTable } from "@miaw/core/event/sql"
-import { asc } from "drizzle-orm"
-import { and } from "drizzle-orm"
-import { eq } from "drizzle-orm"
-import { lte } from "drizzle-orm"
-import { not } from "drizzle-orm"
-import { or } from "drizzle-orm"
-import { Effect, Scope } from "effect"
-import { HttpApiBuilder, HttpApiError } from "effect/unstable/httpapi"
-import { InstanceHttpApi } from "../api"
-import { HistoryPayload, ReplayPayload, SessionPayload } from "../groups/sync"
-
-export const syncHandlers = HttpApiBuilder.group(InstanceHttpApi, "sync", (handlers) =>
-  Effect.gen(function* () {
-    const workspace = yield* Workspace.Service
-    const session = yield* Session.Service
-    const scope = yield* Scope.Scope
-    const events = yield* EventV2Bridge.Service
-    const { db } = yield* Database.Service
-
-    const start = Effect.fn("SyncHttpApi.start")(function* () {
-      yield* workspace
-        .startWorkspaceSyncing((yield* InstanceState.context).project.id)
-        .pipe(Effect.ignore, Effect.forkIn(scope))
-      return true
-    })
-
-    const replay = Effect.fn("SyncHttpApi.replay")(function* (ctx: { payload: typeof ReplayPayload.Type }) {
-      const payload: EventV2.SerializedEvent[] = ctx.payload.events.map((event) => ({
-        id: event.id,
-        aggregateID: event.aggregateID,
-        seq: event.seq,
-        type: event.type,
-        data: { ...event.data },
-      }))
-      const source = payload[0].aggregateID
-      yield* Effect.logInfo("sync replay requested", {
-        sessionID: source,
-        events: payload.length,
-        first: payload[0]?.seq,
-        last: payload.at(-1)?.seq,
-        directory: ctx.payload.directory,
-      })
-      const ownerID = yield* InstanceState.workspaceID
-      yield* events.replayAll(payload, { ownerID, strictOwner: true })
-      yield* Effect.logInfo("sync replay complete", {
-        sessionID: source,
-        events: payload.length,
-        first: payload[0]?.seq,
-        last: payload.at(-1)?.seq,
-      })
-      return { sessionID: source }
-    })
-
-    const steal = Effect.fn("SyncHttpApi.steal")(function* (ctx: { payload: typeof SessionPayload.Type }) {
-      const workspaceID = yield* InstanceState.workspaceID
-      if (!workspaceID) return yield* new HttpApiError.BadRequest({})
-
-      yield* session.setWorkspace({ sessionID: ctx.payload.sessionID, workspaceID })
-
-      yield* Effect.logInfo("sync session stolen", { sessionID: ctx.payload.sessionID, workspaceID })
-
-      return { sessionID: ctx.payload.sessionID }
-    })
-
-    const history = Effect.fn("SyncHttpApi.history")(function* (ctx: { payload: typeof HistoryPayload.Type }) {
-      const exclude = Object.entries(ctx.payload)
-      return yield* db
-        .select()
-        .from(EventTable)
-        .where(
-          exclude.length > 0
-            ? not(or(...exclude.map(([id, seq]) => and(eq(EventTable.aggregate_id, id), lte(EventTable.seq, seq))))!)
-            : undefined,
-        )
-        .orderBy(asc(EventTable.seq))
-        .all()
-        .pipe(Effect.orDie)
-    })
-
-    return handlers.handle("start", start).handle("replay", replay).handle("steal", steal).handle("history", history)
-  }),
-)