@zyraxon-ai/server 19.0.3 → 19.0.5

package/src/handlers/command.ts

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

package/src/handlers/credential.ts

@@ -1,22 +0,0 @@
-import { Integration } from "@zyraxon-ai/core/integration"
-import { Effect } from "effect"
-import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
-import { Api } from "../api"
-
-export const CredentialHandler = HttpApiBuilder.group(Api, "server.credential", (handlers) =>
-  handlers
-    .handle(
-      "credential.update",
-      Effect.fn(function* (ctx) {
-        yield* (yield* Integration.Service).connection.update(ctx.params.credentialID, { label: ctx.payload.label })
-        return HttpApiSchema.NoContent.make()
-      }),
-    )
-    .handle(
-      "credential.remove",
-      Effect.fn(function* (ctx) {
-        yield* (yield* Integration.Service).connection.remove(ctx.params.credentialID)
-        return HttpApiSchema.NoContent.make()
-      }),
-    ),
-)

package/src/handlers/event.ts

@@ -1,52 +0,0 @@
-import { EventV2 } from "@zyraxon-ai/core/event"
-import { ZyraxonEvent } from "@zyraxon-ai/protocol/groups/event"
-import { Effect, Schema, Stream } from "effect"
-import { HttpServerResponse } from "effect/unstable/http"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import * as Sse from "effect/unstable/encoding/Sse"
-import { Api } from "../api"
-
-const subscriberCapacity = 256
-
-function eventData(data: unknown): Sse.Event {
-  return {
-    _tag: "Event",
-    event: "message",
-    id: undefined,
-    data: JSON.stringify(Schema.encodeUnknownSync(ZyraxonEvent)(data)),
-  }
-}
-
-export const EventHandler = HttpApiBuilder.group(Api, "server.event", (handlers) =>
-  Effect.gen(function* () {
-    const events = yield* EventV2.Service
-    return handlers.handleRaw("event.subscribe", () =>
-      Effect.gen(function* () {
-        const connected = {
-          id: EventV2.ID.create(),
-          type: "server.connected",
-          data: {},
-        }
-        const output = Stream.unwrap(
-          Effect.gen(function* () {
-            // Acquiring the bounded stream installs its listener before readiness is observable.
-            const live = yield* EventV2.allBounded(events, subscriberCapacity)
-            return Stream.make(connected).pipe(Stream.concat(live))
-          }),
-        ).pipe(Stream.map(eventData), Stream.pipeThroughChannel(Sse.encode()))
-        const heartbeat = Stream.tick("15 seconds").pipe(Stream.map(() => ": heartbeat\n\n"))
-        return HttpServerResponse.stream(
-          output.pipe(Stream.merge(heartbeat, { haltStrategy: "left" }), Stream.encodeText),
-          {
-            contentType: "text/event-stream",
-            headers: {
-              "Cache-Control": "no-cache, no-transform",
-              "X-Accel-Buffering": "no",
-              "X-Content-Type-Options": "nosniff",
-            },
-          },
-        )
-      }),
-    )
-  }),
-)

package/src/handlers/fs.ts

@@ -1,39 +0,0 @@
-import { FileSystem } from "@zyraxon-ai/core/filesystem"
-import { RelativePath } from "@zyraxon-ai/core/schema"
-import { Effect } from "effect"
-import { HttpServerResponse } from "effect/unstable/http"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { Api } from "../api"
-import { response } from "../location"
-
-export const FileSystemHandler = HttpApiBuilder.group(Api, "server.fs", (handlers) =>
-  Effect.gen(function* () {
-    return handlers
-      .handleRaw("fs.read", (ctx) =>
-        Effect.gen(function* () {
-          const file = yield* (yield* FileSystem.Service).read({
-            path: RelativePath.make(
-              decodeURIComponent(new URL(ctx.request.url, "http://localhost").pathname.slice(13)),
-            ),
-          })
-          return HttpServerResponse.uint8Array(file.content, { contentType: file.mime })
-        }),
-      )
-      .handle("fs.list", (ctx) =>
-        response(
-          Effect.gen(function* () {
-            const fs = yield* FileSystem.Service
-            return yield* fs.list(ctx.query)
-          }),
-        ),
-      )
-      .handle("fs.find", (ctx) =>
-        response(
-          Effect.gen(function* () {
-            const fs = yield* FileSystem.Service
-            return yield* fs.find(ctx.query)
-          }),
-        ),
-      )
-  }),
-)

package/src/handlers/health.ts

@@ -1,7 +0,0 @@
-import { Effect } from "effect"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { Api } from "../api"
-
-export const HealthHandler = HttpApiBuilder.group(Api, "server.health", (handlers) =>
-  handlers.handle("health.get", () => Effect.succeed({ healthy: true as const })),
-)

package/src/handlers/integration.ts

@@ -1,104 +0,0 @@
-import { Integration } from "@zyraxon-ai/core/integration"
-import { Effect } from "effect"
-import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
-import { Api } from "../api"
-import { InvalidRequestError } from "@zyraxon-ai/protocol/errors"
-import { response } from "../location"
-
-const authorize = <A, R>(effect: Effect.Effect<A, Integration.AuthorizationError, R>) =>
-  effect.pipe(
-    Effect.mapError(
-      () =>
-        new InvalidRequestError({
-          message: "Authentication failed",
-          kind: "integration_authorization",
-        }),
-    ),
-  )
-
-export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration", (handlers) =>
-  Effect.gen(function* () {
-    return handlers
-      .handle(
-        "integration.list",
-        Effect.fn(function* () {
-          const service = yield* Integration.Service
-          return yield* response(service.list())
-        }),
-      )
-      .handle(
-        "integration.get",
-        Effect.fn(function* (ctx) {
-          const service = yield* Integration.Service
-          return yield* response(service.get(ctx.params.integrationID))
-        }),
-      )
-      .handle(
-        "integration.connect.key",
-        Effect.fn(function* (ctx) {
-          const service = yield* Integration.Service
-          yield* authorize(
-            service.connection.key({
-              integrationID: ctx.params.integrationID,
-              key: ctx.payload.key,
-              label: ctx.payload.label,
-            }),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-      .handle(
-        "integration.connect.oauth",
-        Effect.fn(function* (ctx) {
-          const service = yield* Integration.Service
-          return yield* response(
-            authorize(
-              service.connection.oauth({
-                integrationID: ctx.params.integrationID,
-                methodID: ctx.payload.methodID,
-                inputs: ctx.payload.inputs,
-                label: ctx.payload.label,
-              }),
-            ),
-          )
-        }),
-      )
-      .handle(
-        "integration.attempt.status",
-        Effect.fn(function* (ctx) {
-          const service = yield* Integration.Service
-          return yield* response(service.attempt.status(ctx.params.attemptID))
-        }),
-      )
-      .handle(
-        "integration.attempt.complete",
-        Effect.fn(function* (ctx) {
-          const service = yield* Integration.Service
-          yield* service.attempt.complete({ attemptID: ctx.params.attemptID, code: ctx.payload.code }).pipe(
-            Effect.mapError(
-              (error) =>
-                new InvalidRequestError({
-                  message:
-                    error._tag === "Integration.CodeRequired"
-                      ? "Authorization code is required"
-                      : "Authentication failed",
-                  kind:
-                    error._tag === "Integration.CodeRequired"
-                      ? "integration_code_required"
-                      : "integration_authorization",
-                }),
-            ),
-          )
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-      .handle(
-        "integration.attempt.cancel",
-        Effect.fn(function* (ctx) {
-          const service = yield* Integration.Service
-          yield* service.attempt.cancel(ctx.params.attemptID)
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-  }),
-)

package/src/handlers/location.ts

@@ -1,18 +0,0 @@
-import { Location } from "@zyraxon-ai/core/location"
-import { Effect } from "effect"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { Api } from "../api"
-
-export const LocationHandler = HttpApiBuilder.group(Api, "server.location", (handlers) =>
-  handlers.handle(
-    "location.get",
-    Effect.fn(function* () {
-      const location = yield* Location.Service
-      return new Location.Info({
-        directory: location.directory,
-        workspaceID: location.workspaceID,
-        project: location.project,
-      })
-    }),
-  ),
-)

package/src/handlers/message.ts

@@ -1,81 +0,0 @@
-import { SessionMessage } from "@zyraxon-ai/core/session/message"
-import { SessionV2 } from "@zyraxon-ai/core/session"
-import { Effect, Schema } from "effect"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { Api } from "../api"
-import { InvalidCursorError, SessionNotFoundError, UnknownError } from "@zyraxon-ai/protocol/errors"
-
-const DefaultMessagesLimit = 50
-
-const Cursor = Schema.Struct({
-  id: SessionMessage.ID,
-  order: Schema.Union([Schema.Literal("asc"), Schema.Literal("desc")]),
-  direction: Schema.Union([Schema.Literal("previous"), Schema.Literal("next")]),
-})
-
-const decodeCursor = Schema.decodeUnknownSync(Cursor)
-
-const cursor = {
-  encode(message: SessionMessage.Message, order: "asc" | "desc", direction: "previous" | "next") {
-    return Buffer.from(JSON.stringify({ id: message.id, order, direction })).toString("base64url")
-  },
-  decode(input: string) {
-    return decodeCursor(JSON.parse(Buffer.from(input, "base64url").toString("utf8")))
-  },
-}
-
-export const MessageHandler = HttpApiBuilder.group(Api, "server.message", (handlers) =>
-  Effect.gen(function* () {
-    const session = yield* SessionV2.Service
-
-    return handlers.handle(
-      "session.messages",
-      Effect.fn(function* (ctx) {
-        if (ctx.query.cursor && ctx.query.order !== undefined)
-          return yield* new InvalidCursorError({ message: "Cursor cannot be combined with order" })
-        const decoded = yield* Effect.try({
-          try: () => (ctx.query.cursor ? cursor.decode(ctx.query.cursor) : undefined),
-          catch: () => new InvalidCursorError({ message: "Invalid cursor" }),
-        })
-        const order = decoded?.order ?? ctx.query.order ?? "desc"
-        const messages = yield* session
-          .messages({
-            sessionID: ctx.params.sessionID,
-            limit: ctx.query.limit ?? DefaultMessagesLimit,
-            order,
-            cursor: decoded ? { id: decoded.id, direction: decoded.direction } : undefined,
-          })
-          .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 }),
-                  ),
-                ),
-              )
-            }),
-          )
-        const first = messages[0]
-        const last = messages.at(-1)
-        return {
-          data: messages,
-          cursor: {
-            previous: first ? cursor.encode(first, order, "previous") : undefined,
-            next: last ? cursor.encode(last, order, "next") : undefined,
-          },
-        }
-      }),
-    )
-  }),
-)

package/src/handlers/model.ts

@@ -1,17 +0,0 @@
-import { Catalog } from "@zyraxon-ai/core/catalog"
-import { Effect } from "effect"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { Api } from "../api"
-import { response } from "../location"
-
-export const ModelHandler = HttpApiBuilder.group(Api, "server.model", (handlers) =>
-  Effect.gen(function* () {
-    return handlers.handle(
-      "model.list",
-      Effect.fn(function* () {
-        const catalog = yield* Catalog.Service
-        return yield* response(catalog.model.available())
-      }),
-    )
-  }),
-)

package/src/handlers/permission.ts

@@ -1,98 +0,0 @@
-import { Location } from "@zyraxon-ai/core/location"
-import { PermissionV2 } from "@zyraxon-ai/core/permission"
-import { PermissionSaved } from "@zyraxon-ai/core/permission/saved"
-import { Effect } from "effect"
-import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
-import { Api } from "../api"
-import { PermissionNotFoundError, SessionNotFoundError } from "@zyraxon-ai/protocol/errors"
-import { response } from "../location"
-
-function missingRequest(id: PermissionV2.ID) {
-  return new PermissionNotFoundError({ requestID: id, message: `Permission request not found: ${id}` })
-}
-
-export const PermissionHandler = HttpApiBuilder.group(Api, "server.permission", (handlers) =>
-  Effect.gen(function* () {
-    return handlers
-      .handle(
-        "permission.request.list",
-        Effect.fn(function* () {
-          return yield* response((yield* PermissionV2.Service).list())
-        }),
-      )
-      .handle(
-        "session.permission.create",
-        Effect.fn(function* (ctx) {
-          const permission = yield* PermissionV2.Service
-          return {
-            data: yield* permission
-              .ask({
-                id: ctx.payload.id,
-                sessionID: ctx.params.sessionID,
-                action: ctx.payload.action,
-                resources: ctx.payload.resources,
-                save: ctx.payload.save,
-                metadata: ctx.payload.metadata,
-                source: ctx.payload.source,
-                agent: ctx.payload.agent,
-              })
-              .pipe(
-                Effect.catchTag(
-                  "Session.NotFoundError",
-                  (error) =>
-                    new SessionNotFoundError({
-                      sessionID: error.sessionID,
-                      message: `Session not found: ${error.sessionID}`,
-                    }),
-                ),
-              ),
-          }
-        }),
-      )
-      .handle(
-        "session.permission.list",
-        Effect.fn(function* (ctx) {
-          const permission = yield* PermissionV2.Service
-          return { data: yield* permission.forSession(ctx.params.sessionID) }
-        }),
-      )
-      .handle(
-        "session.permission.get",
-        Effect.fn(function* (ctx) {
-          const request = yield* (yield* PermissionV2.Service).get(ctx.params.requestID)
-          if (!request || request.sessionID !== ctx.params.sessionID) return yield* missingRequest(ctx.params.requestID)
-          return { data: request }
-        }),
-      )
-      .handle(
-        "session.permission.reply",
-        Effect.fn(function* (ctx) {
-          const permission = yield* PermissionV2.Service
-          const request = yield* permission.get(ctx.params.requestID)
-          if (!request || request.sessionID !== ctx.params.sessionID) return yield* missingRequest(ctx.params.requestID)
-          yield* permission
-            .reply({ requestID: ctx.params.requestID, reply: ctx.payload.reply, message: ctx.payload.message })
-            .pipe(Effect.catchTag("PermissionV2.NotFoundError", () => missingRequest(ctx.params.requestID)))
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-      .handle(
-        "permission.saved.list",
-        Effect.fn(function* (ctx) {
-          const location = yield* Location.Service
-          return {
-            data: yield* (yield* PermissionSaved.Service).list({
-              projectID: ctx.query.projectID ?? location.project.id,
-            }),
-          }
-        }),
-      )
-      .handle(
-        "permission.saved.remove",
-        Effect.fn(function* (ctx) {
-          yield* (yield* PermissionSaved.Service).remove(ctx.params.id)
-          return HttpApiSchema.NoContent.make()
-        }),
-      )
-  }),
-)

package/src/handlers/project-copy.ts

@@ -1,68 +0,0 @@
-import { Location } from "@zyraxon-ai/core/location"
-import { ProjectCopy } from "@zyraxon-ai/core/project/copy"
-import { Git } from "@zyraxon-ai/core/git"
-import { Effect } from "effect"
-import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
-import { Api } from "../api"
-import { ProjectCopyError } from "@zyraxon-ai/protocol/groups/project-copy"
-
-export const ProjectCopyHandler = HttpApiBuilder.group(Api, "server.projectCopy", (handlers) =>
-  Effect.succeed(
-    handlers
-      .handle("projectCopy.create", (ctx) =>
-        Effect.gen(function* () {
-          const copies = yield* ProjectCopy.Service
-          const location = yield* Location.Service
-          return yield* badRequest(
-            copies.create({
-              ...ctx.payload,
-              projectID: ctx.params.projectID,
-              sourceDirectory: location.project.directory,
-            }),
-          )
-        }),
-      )
-      .handle("projectCopy.remove", (ctx) =>
-        ProjectCopy.Service.use((copies) =>
-          badRequest(copies.remove({ ...ctx.payload, projectID: ctx.params.projectID })).pipe(
-            Effect.as(HttpApiSchema.NoContent.make()),
-          ),
-        ),
-      )
-      .handle("projectCopy.refresh", (ctx) =>
-        ProjectCopy.Service.use((copies) =>
-          badRequest(copies.refresh({ projectID: ctx.params.projectID })).pipe(
-            Effect.as(HttpApiSchema.NoContent.make()),
-          ),
-        ),
-      ),
-  ),
-)
-
-function badRequest<A, R>(effect: Effect.Effect<A, ProjectCopy.Error, R>) {
-  return effect.pipe(
-    Effect.mapError(
-      (error) =>
-        new ProjectCopyError({
-          name: "ProjectCopyError",
-          data: {
-            message: message(error),
-            forceRequired: error instanceof Git.WorktreeError ? error.forceRequired : undefined,
-          },
-        }),
-    ),
-  )
-}
-
-function message(error: ProjectCopy.Error) {
-  if (error instanceof ProjectCopy.SourceDirectoryNotFoundError)
-    return `Project copy source not found: ${error.directory}`
-  if (error instanceof ProjectCopy.DestinationExistsError)
-    return `Project copy destination already exists: ${error.directory}`
-  if (error instanceof ProjectCopy.DirectoryUnavailableError)
-    return `Project copy directory unavailable: ${error.directory}`
-  if (error instanceof ProjectCopy.InvalidDirectoryError) return `Invalid project copy directory: ${error.directory}`
-  if (error instanceof ProjectCopy.StrategyUnavailableError)
-    return `Project copy strategy unavailable: ${error.strategy}`
-  return error.message
-}

package/src/handlers/provider.ts

@@ -1,32 +0,0 @@
-import { Catalog } from "@zyraxon-ai/core/catalog"
-import { Effect } from "effect"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { Api } from "../api"
-import { ProviderNotFoundError } from "@zyraxon-ai/protocol/errors"
-import { response } from "../location"
-
-export const ProviderHandler = HttpApiBuilder.group(Api, "server.provider", (handlers) =>
-  Effect.gen(function* () {
-    return handlers
-      .handle(
-        "provider.list",
-        Effect.fn(function* () {
-          const catalog = yield* Catalog.Service
-          return yield* response(catalog.provider.all())
-        }),
-      )
-      .handle(
-        "provider.get",
-        Effect.fn(function* (ctx) {
-          const catalog = yield* Catalog.Service
-          const provider = yield* catalog.provider.get(ctx.params.providerID)
-          if (!provider)
-            return yield* new ProviderNotFoundError({
-              providerID: ctx.params.providerID,
-              message: `Provider not found: ${ctx.params.providerID}`,
-            })
-          return yield* response(Effect.succeed(provider))
-        }),
-      )
-  }),
-)