@zyraxon-ai/server 19.0.3 → 19.0.5

package/src/handlers/pty.ts

@@ -1,223 +0,0 @@
-import { Pty } from "@zyraxon-ai/core/pty"
-import { PtyProtocol } from "@zyraxon-ai/core/pty/protocol"
-import { PtyTicket } from "@zyraxon-ai/core/pty/ticket"
-import { Location } from "@zyraxon-ai/core/location"
-import { Effect, Queue } from "effect"
-import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
-import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
-import * as Socket from "effect/unstable/socket/Socket"
-import { Api } from "../api"
-import { CorsConfig, isAllowedRequestOrigin } from "../cors"
-import { ForbiddenError, PtyNotFoundError } from "@zyraxon-ai/protocol/errors"
-import {
-  PTY_CONNECT_TICKET_QUERY,
-  PTY_CONNECT_TOKEN_HEADER,
-  PTY_CONNECT_TOKEN_HEADER_VALUE,
-} from "@zyraxon-ai/protocol/groups/pty"
-import { response } from "../location"
-import { PtyEnvironment } from "../pty-environment"
-
-const ticketScope = Effect.gen(function* () {
-  const location = yield* Location.Service
-  return { directory: location.directory as string, workspaceID: location.workspaceID }
-})
-
-export const PtyHandler = HttpApiBuilder.group(Api, "server.pty", (handlers) =>
-  Effect.gen(function* () {
-    const tickets = yield* PtyTicket.Service
-    const cors = yield* CorsConfig
-    const environment = yield* PtyEnvironment.Service
-
-    return handlers
-      .handle(
-        "pty.list",
-        Effect.fn(function* () {
-          return yield* response((yield* Pty.Service).list())
-        }),
-      )
-      .handle(
-        "pty.create",
-        Effect.fn(function* (ctx) {
-          const pty = yield* Pty.Service
-          const location = yield* Location.Service
-          const cwd = ctx.payload.cwd || location.directory
-          return yield* response(
-            pty.create({
-              ...ctx.payload,
-              args: ctx.payload.args ? [...ctx.payload.args] : undefined,
-              cwd,
-              env: {
-                ...ctx.payload.env,
-                ...(yield* environment.get({ directory: location.directory, cwd })),
-              },
-            }),
-          )
-        }),
-      )
-      .handle(
-        "pty.get",
-        Effect.fn(function* (ctx) {
-          const pty = yield* Pty.Service
-          return yield* response(
-            pty.get(ctx.params.ptyID).pipe(
-              Effect.catchTag(
-                "Pty.NotFoundError",
-                () =>
-                  new PtyNotFoundError({
-                    ptyID: ctx.params.ptyID,
-                    message: `PTY session not found: ${ctx.params.ptyID}`,
-                  }),
-              ),
-            ),
-          )
-        }),
-      )
-      .handle(
-        "pty.update",
-        Effect.fn(function* (ctx) {
-          const pty = yield* Pty.Service
-          return yield* response(
-            pty
-              .update(ctx.params.ptyID, {
-                ...ctx.payload,
-                size: ctx.payload.size ? { ...ctx.payload.size } : undefined,
-              })
-              .pipe(
-                Effect.catchTag(
-                  "Pty.NotFoundError",
-                  () =>
-                    new PtyNotFoundError({
-                      ptyID: ctx.params.ptyID,
-                      message: `PTY session not found: ${ctx.params.ptyID}`,
-                    }),
-                ),
-              ),
-          )
-        }),
-      )
-      .handle(
-        "pty.remove",
-        Effect.fn(function* (ctx) {
-          const pty = yield* Pty.Service
-          yield* pty.remove(ctx.params.ptyID).pipe(
-            Effect.catchTag(
-              "Pty.NotFoundError",
-              () =>
-                new PtyNotFoundError({
-                  ptyID: ctx.params.ptyID,
-                  message: `PTY session not found: ${ctx.params.ptyID}`,
-                }),
-            ),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-      .handle(
-        "pty.connectToken",
-        Effect.fn(function* (ctx) {
-          const request = yield* HttpServerRequest.HttpServerRequest
-          // The custom header forces a CORS preflight, so cross-origin browser pages cannot
-          // mint tickets without passing the server's origin policy.
-          if (
-            request.headers[PTY_CONNECT_TOKEN_HEADER] !== PTY_CONNECT_TOKEN_HEADER_VALUE ||
-            !isAllowedRequestOrigin(request.headers.origin, request.headers.host, cors)
-          )
-            return yield* new ForbiddenError({ message: "Invalid PTY connect token request" })
-          const pty = yield* Pty.Service
-          yield* pty.get(ctx.params.ptyID).pipe(
-            Effect.catchTag(
-              "Pty.NotFoundError",
-              () =>
-                new PtyNotFoundError({
-                  ptyID: ctx.params.ptyID,
-                  message: `PTY session not found: ${ctx.params.ptyID}`,
-                }),
-            ),
-          )
-          return yield* response(tickets.issue({ ptyID: ctx.params.ptyID, ...(yield* ticketScope) }))
-        }),
-      )
-      .handleRaw(
-        "pty.connect",
-        Effect.fn("PtyHandler.connect")(function* (ctx) {
-          const pty = yield* Pty.Service
-          const exists = yield* pty.get(ctx.params.ptyID).pipe(
-            Effect.as(true),
-            Effect.catchTag("Pty.NotFoundError", () => Effect.succeed(false)),
-          )
-          if (!exists) return HttpServerResponse.empty({ status: 404 })
-
-          const url = new URL(ctx.request.url, "http://localhost")
-          const ticket = url.searchParams.get(PTY_CONNECT_TICKET_QUERY)
-          if (ticket) {
-            const valid = isAllowedRequestOrigin(ctx.request.headers.origin, ctx.request.headers.host, cors)
-              ? yield* tickets.consume({ ticket, ptyID: ctx.params.ptyID, ...(yield* ticketScope) })
-              : false
-            if (!valid) return HttpServerResponse.empty({ status: 403 })
-          }
-          const parsedCursor = url.searchParams.get("cursor")
-          const cursorNumber = parsedCursor === null ? undefined : Number(parsedCursor)
-          const cursor =
-            cursorNumber !== undefined && Number.isSafeInteger(cursorNumber) && cursorNumber >= -1
-              ? cursorNumber
-              : undefined
-
-          const socket = yield* Effect.orDie(ctx.request.upgrade)
-          const write = yield* socket.writer
-          const closeAccepted = (event: Socket.CloseEvent) =>
-            socket
-              .runRaw(() => Effect.void, { onOpen: write(event).pipe(Effect.catch(() => Effect.void)) })
-              .pipe(
-                Effect.timeout("1 second"),
-                Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void),
-                Effect.catch(() => Effect.void),
-              )
-
-          // Outbound frames flow through one queue drained by a single writer so replay, live
-          // output, and the close frame keep their order.
-          // TODO: Integrate graceful-shutdown socket tracking before clients migrate to this route.
-          const outbox = yield* Queue.unbounded<string | Uint8Array | Socket.CloseEvent>()
-          const attachment = yield* pty
-            .attach(ctx.params.ptyID, {
-              cursor,
-              onData: (chunk) => Queue.offerUnsafe(outbox, chunk),
-              onEnd: () => Queue.offerUnsafe(outbox, new Socket.CloseEvent(1000)),
-            })
-            .pipe(
-              Effect.catchTags({
-                "Pty.NotFoundError": () =>
-                  closeAccepted(new Socket.CloseEvent(4404, "session not found")).pipe(Effect.as(undefined)),
-                "Pty.ExitedError": () =>
-                  closeAccepted(new Socket.CloseEvent(4404, "session exited")).pipe(Effect.as(undefined)),
-              }),
-            )
-          if (!attachment) return HttpServerResponse.empty()
-
-          for (const chunk of PtyProtocol.chunks(attachment.replay)) Queue.offerUnsafe(outbox, chunk)
-          Queue.offerUnsafe(outbox, PtyProtocol.metaFrame(attachment.cursor))
-          attachment.activate()
-
-          const drain = Effect.gen(function* () {
-            while (true) {
-              const item = yield* Queue.take(outbox)
-              yield* write(item)
-              if (item instanceof Socket.CloseEvent) return
-            }
-          })
-
-          yield* Effect.race(
-            drain,
-            socket.runRaw((message) => {
-              const decoded = PtyProtocol.decodeInput(message)
-              if (decoded !== undefined) attachment.write(decoded)
-            }),
-          ).pipe(
-            Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void),
-            Effect.ensuring(Effect.sync(() => attachment.detach())),
-            Effect.orDie,
-          )
-          return HttpServerResponse.empty()
-        }),
-      )
-  }),
-)

package/src/handlers/question.ts

@@ -1,62 +0,0 @@
-import { QuestionV2 } from "@zyraxon-ai/core/question"
-import { Effect } from "effect"
-import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
-import { Api } from "../api"
-import { QuestionNotFoundError } from "@zyraxon-ai/protocol/errors"
-import { response } from "../location"
-
-function missingRequest(id: QuestionV2.ID) {
-  return new QuestionNotFoundError({ requestID: id, message: `Question request not found: ${id}` })
-}
-
-export const QuestionHandler = HttpApiBuilder.group(Api, "server.question", (handlers) =>
-  Effect.gen(function* () {
-    const withOwnedQuestion = Effect.fnUntraced(function* <A, E>(
-      sessionID: QuestionV2.Request["sessionID"],
-      requestID: QuestionV2.ID,
-      use: (question: QuestionV2.Interface) => Effect.Effect<A, E>,
-    ) {
-      const question = yield* QuestionV2.Service
-      const request = (yield* question.list()).find((request) => request.id === requestID)
-      if (!request || request.sessionID !== sessionID) return yield* missingRequest(requestID)
-      return yield* use(question)
-    })
-
-    return handlers
-      .handle(
-        "question.request.list",
-        Effect.fn(function* () {
-          return yield* response((yield* QuestionV2.Service).list())
-        }),
-      )
-      .handle(
-        "session.question.list",
-        Effect.fn(function* (ctx) {
-          const requests = yield* (yield* QuestionV2.Service).list()
-          return { data: requests.filter((request) => request.sessionID === ctx.params.sessionID) }
-        }),
-      )
-      .handle(
-        "session.question.reply",
-        Effect.fn(function* (ctx) {
-          yield* withOwnedQuestion(ctx.params.sessionID, ctx.params.requestID, (question) =>
-            question
-              .reply({ requestID: ctx.params.requestID, answers: ctx.payload.answers })
-              .pipe(Effect.catchTag("QuestionV2.NotFoundError", () => missingRequest(ctx.params.requestID))),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-      .handle(
-        "session.question.reject",
-        Effect.fn(function* (ctx) {
-          yield* withOwnedQuestion(ctx.params.sessionID, ctx.params.requestID, (question) =>
-            question
-              .reject(ctx.params.requestID)
-              .pipe(Effect.catchTag("QuestionV2.NotFoundError", () => missingRequest(ctx.params.requestID))),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-  }),
-)

package/src/handlers/reference.ts

@@ -1,8 +0,0 @@
-import { Reference } from "@zyraxon-ai/core/reference"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { Api } from "../api"
-import { response } from "../location"
-
-export const ReferenceHandler = HttpApiBuilder.group(Api, "server.reference", (handlers) =>
-  handlers.handle("reference.list", () => response(Reference.Service.use((reference) => reference.list()))),
-)

package/src/handlers/session.ts

@@ -1,385 +0,0 @@
-import { SessionV2 } from "@zyraxon-ai/core/session"
-import { DateTime, Effect, Stream } from "effect"
-import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
-import { Api } from "../api"
-import { SessionsCursor } from "@zyraxon-ai/protocol/groups/session"
-import {
-  ConflictError,
-  InvalidCursorError,
-  MessageNotFoundError,
-  ServiceUnavailableError,
-  SessionNotFoundError,
-  UnknownError,
-} from "@zyraxon-ai/protocol/errors"
-import { AbsolutePath } from "@zyraxon-ai/core/schema"
-
-const DefaultSessionsLimit = 50
-const DefaultSessionHistoryLimit = 50
-
-export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handlers) =>
-  Effect.gen(function* () {
-    const session = yield* SessionV2.Service
-
-    return handlers
-      .handle(
-        "session.list",
-        Effect.fn(function* (ctx) {
-          const query =
-            ctx.query.cursor !== undefined
-              ? yield* SessionsCursor.parse(ctx.query.cursor).pipe(
-                  Effect.mapError(() => new InvalidCursorError({ message: "Invalid cursor" })),
-                )
-              : ctx.query
-          const sessions = yield* session.list({
-            ...query,
-            workspaceID: query.workspace,
-            limit: ctx.query.limit ?? DefaultSessionsLimit,
-          })
-          const first = sessions[0]
-          const last = sessions.at(-1)
-          return {
-            data: sessions,
-            cursor: {
-              previous: first
-                ? SessionsCursor.make({
-                    ...query,
-                    anchor: {
-                      id: first.id,
-                      time: DateTime.toEpochMillis(first.time.created),
-                      direction: "previous",
-                    },
-                  })
-                : undefined,
-              next: last
-                ? SessionsCursor.make({
-                    ...query,
-                    anchor: {
-                      id: last.id,
-                      time: DateTime.toEpochMillis(last.time.created),
-                      direction: "next",
-                    },
-                  })
-                : undefined,
-            },
-          }
-        }),
-      )
-      .handle(
-        "session.create",
-        Effect.fn(function* (ctx) {
-          return {
-            data: yield* session.create({
-              id: ctx.payload.id,
-              agent: ctx.payload.agent,
-              model: ctx.payload.model,
-              location: ctx.payload.location ?? { directory: AbsolutePath.make(process.cwd()) },
-            }),
-          }
-        }),
-      )
-      .handle(
-        "session.active",
-        Effect.fn(function* () {
-          return {
-            data: Object.fromEntries(
-              Array.from(yield* session.active, (sessionID) => [sessionID, { type: "running" as const }]),
-            ),
-          }
-        }),
-      )
-      .handle(
-        "session.get",
-        Effect.fn(function* (ctx) {
-          return {
-            data: yield* session.get(ctx.params.sessionID).pipe(
-              Effect.catchTag(
-                "Session.NotFoundError",
-                (error) =>
-                  new SessionNotFoundError({
-                    sessionID: error.sessionID,
-                    message: `Session not found: ${error.sessionID}`,
-                  }),
-              ),
-            ),
-          }
-        }),
-      )
-      .handle(
-        "session.switchAgent",
-        Effect.fn(function* (ctx) {
-          yield* session.switchAgent({ sessionID: ctx.params.sessionID, agent: ctx.payload.agent }).pipe(
-            Effect.catchTag("Session.NotFoundError", (error) =>
-              Effect.fail(
-                new SessionNotFoundError({
-                  sessionID: error.sessionID,
-                  message: `Session not found: ${error.sessionID}`,
-                }),
-              ),
-            ),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-      .handle(
-        "session.switchModel",
-        Effect.fn(function* (ctx) {
-          yield* session.switchModel({ sessionID: ctx.params.sessionID, model: ctx.payload.model }).pipe(
-            Effect.catchTag("Session.NotFoundError", (error) =>
-              Effect.fail(
-                new SessionNotFoundError({
-                  sessionID: error.sessionID,
-                  message: `Session not found: ${error.sessionID}`,
-                }),
-              ),
-            ),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-      .handle(
-        "session.prompt",
-        Effect.fn(function* (ctx) {
-          return {
-            data: yield* session
-              .prompt({
-                sessionID: ctx.params.sessionID,
-                id: ctx.payload.id,
-                prompt: ctx.payload.prompt,
-                delivery: ctx.payload.delivery,
-                resume: ctx.payload.resume,
-              })
-              .pipe(
-                Effect.catchTag("Session.NotFoundError", (error) =>
-                  Effect.fail(
-                    new SessionNotFoundError({
-                      sessionID: error.sessionID,
-                      message: `Session not found: ${error.sessionID}`,
-                    }),
-                  ),
-                ),
-                Effect.catchTag("Session.PromptConflictError", (error) =>
-                  Effect.fail(
-                    new ConflictError({
-                      message: `Prompt message ID conflicts with an existing durable record: ${error.messageID}`,
-                      resource: error.messageID,
-                    }),
-                  ),
-                ),
-              ),
-          }
-        }),
-      )
-      .handle(
-        "session.compact",
-        Effect.fn(function* (ctx) {
-          yield* session.compact({ sessionID: ctx.params.sessionID }).pipe(
-            Effect.catchTag("Session.NotFoundError", (error) =>
-              Effect.fail(
-                new SessionNotFoundError({
-                  sessionID: error.sessionID,
-                  message: `Session not found: ${error.sessionID}`,
-                }),
-              ),
-            ),
-            Effect.catchTag("Session.OperationUnavailableError", (error) =>
-              Effect.fail(
-                new ServiceUnavailableError({
-                  message: `Session ${error.operation} is not available yet`,
-                  service: `session.${error.operation}`,
-                }),
-              ),
-            ),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-      .handle(
-        "session.wait",
-        Effect.fn(function* (ctx) {
-          yield* session.wait(ctx.params.sessionID).pipe(
-            Effect.catchTag("Session.NotFoundError", (error) =>
-              Effect.fail(
-                new SessionNotFoundError({
-                  sessionID: error.sessionID,
-                  message: `Session not found: ${error.sessionID}`,
-                }),
-              ),
-            ),
-            Effect.catchTag("Session.OperationUnavailableError", (error) =>
-              Effect.fail(
-                new ServiceUnavailableError({
-                  message: `Session ${error.operation} is not available yet`,
-                  service: `session.${error.operation}`,
-                }),
-              ),
-            ),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-      .handle(
-        "session.revert.stage",
-        Effect.fn(function* (ctx) {
-          return {
-            data: yield* session.revert.stage({ ...ctx.params, ...ctx.payload }).pipe(
-              Effect.catchTag(
-                "Session.NotFoundError",
-                (error) =>
-                  new SessionNotFoundError({
-                    sessionID: error.sessionID,
-                    message: `Session not found: ${error.sessionID}`,
-                  }),
-              ),
-              Effect.catchTag(
-                "Session.MessageNotFoundError",
-                (error) =>
-                  new MessageNotFoundError({
-                    sessionID: error.sessionID,
-                    messageID: error.messageID,
-                    message: `Message not found: ${error.messageID}`,
-                  }),
-              ),
-              Effect.catchTag("Snapshot.Error", (error) => {
-                const ref = `err_${crypto.randomUUID().slice(0, 8)}`
-                return Effect.logError("failed to stage session revert", { cause: error }).pipe(
-                  Effect.andThen(
-                    Effect.fail(
-                      new UnknownError({
-                        message: "Unexpected server error. Check server logs for details.",
-                        ref,
-                      }),
-                    ),
-                  ),
-                )
-              }),
-            ),
-          }
-        }),
-      )
-      .handle(
-        "session.revert.clear",
-        Effect.fn(function* (ctx) {
-          yield* session.revert.clear(ctx.params.sessionID).pipe(
-            Effect.catchTag(
-              "Session.NotFoundError",
-              (error) =>
-                new SessionNotFoundError({
-                  sessionID: error.sessionID,
-                  message: `Session not found: ${error.sessionID}`,
-                }),
-            ),
-            Effect.catchTag("Snapshot.Error", (error) => {
-              const ref = `err_${crypto.randomUUID().slice(0, 8)}`
-              return Effect.logError("failed to clear session revert", { cause: error }).pipe(
-                Effect.andThen(
-                  Effect.fail(
-                    new UnknownError({
-                      message: "Unexpected server error. Check server logs for details.",
-                      ref,
-                    }),
-                  ),
-                ),
-              )
-            }),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-      .handle(
-        "session.revert.commit",
-        Effect.fn(function* (ctx) {
-          yield* session.revert.commit(ctx.params.sessionID).pipe(
-            Effect.catchTag(
-              "Session.NotFoundError",
-              (error) =>
-                new SessionNotFoundError({
-                  sessionID: error.sessionID,
-                  message: `Session not found: ${error.sessionID}`,
-                }),
-            ),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-      .handle(
-        "session.context",
-        Effect.fn(function* (ctx) {
-          return {
-            data: yield* session.context(ctx.params.sessionID).pipe(
-              Effect.catchTag("Session.NotFoundError", (error) =>
-                Effect.fail(
-                  new SessionNotFoundError({
-                    sessionID: error.sessionID,
-                    message: `Session not found: ${error.sessionID}`,
-                  }),
-                ),
-              ),
-              Effect.catchTag("Session.MessageDecodeError", (error) => {
-                const ref = `err_${crypto.randomUUID().slice(0, 8)}`
-                return Effect.logError("failed to decode session message").pipe(
-                  Effect.annotateLogs({ ref, sessionID: error.sessionID, messageID: error.messageID }),
-                  Effect.andThen(
-                    Effect.fail(
-                      new UnknownError({ message: "Unexpected server error. Check server logs for details.", ref }),
-                    ),
-                  ),
-                )
-              }),
-            ),
-          }
-        }),
-      )
-      .handle(
-        "session.history",
-        Effect.fn(function* (ctx) {
-          return yield* session
-            .history({
-              sessionID: ctx.params.sessionID,
-              after: ctx.query.after,
-              limit: ctx.query.limit ?? DefaultSessionHistoryLimit,
-            })
-            .pipe(
-              Effect.map((page) => ({
-                data: page.events,
-                hasMore: page.hasMore,
-              })),
-              Effect.catchTag(
-                "Session.NotFoundError",
-                (error) =>
-                  new SessionNotFoundError({
-                    sessionID: error.sessionID,
-                    message: `Session not found: ${error.sessionID}`,
-                  }),
-              ),
-            )
-        }),
-      )
-      .handle(
-        "session.events",
-        Effect.fn((ctx) =>
-          Effect.succeed(
-            session.events({ sessionID: ctx.params.sessionID, after: ctx.query.after }).pipe(Stream.orDie),
-          ),
-        ),
-      )
-      .handle(
-        "session.interrupt",
-        Effect.fn(function* (ctx) {
-          yield* session.interrupt(ctx.params.sessionID)
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-      .handle(
-        "session.message",
-        Effect.fn(function* (ctx) {
-          const message = yield* session.message(ctx.params)
-          if (message) return { data: message }
-          return yield* new MessageNotFoundError({
-            sessionID: ctx.params.sessionID,
-            messageID: ctx.params.messageID,
-            message: `Message not found: ${ctx.params.messageID}`,
-          })
-        }),
-      )
-  }),
-)

package/src/handlers/skill.ts

@@ -1,8 +0,0 @@
-import { SkillV2 } from "@zyraxon-ai/core/skill"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { Api } from "../api"
-import { response } from "../location"
-
-export const SkillHandler = HttpApiBuilder.group(Api, "server.skill", (handlers) =>
-  handlers.handle("skill.list", () => response(SkillV2.Service.use((skill) => skill.list()))),
-)