anymous 1.2.7 → 1.3.1

package/src/server/routes/instance/httpapi/groups/tui.ts

@@ -1,208 +0,0 @@
-import { TuiEvent } from "@/server/tui-event"
-import { TuiRequest as TuiRequestPayload } from "@/server/shared/tui-control"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { Authorization } from "../middleware/authorization"
-import { InstanceContextMiddleware } from "../middleware/instance-context"
-import { WorkspaceRoutingMiddleware, WorkspaceRoutingQuery } from "../middleware/workspace-routing"
-import { ApiNotFoundError } from "../errors"
-import { described } from "./metadata"
-
-const root = "/tui"
-export const CommandPayload = Schema.Struct({ command: Schema.String })
-const EventTuiPromptAppend = Schema.Struct({
-  type: Schema.Literal(TuiEvent.PromptAppend.type),
-  properties: TuiEvent.PromptAppend.data,
-}).annotate({ identifier: "EventTuiPromptAppend" })
-const EventTuiCommandExecute = Schema.Struct({
-  type: Schema.Literal(TuiEvent.CommandExecute.type),
-  properties: TuiEvent.CommandExecute.data,
-}).annotate({ identifier: "EventTuiCommandExecute" })
-const EventTuiToastShow = Schema.Struct({
-  type: Schema.Literal(TuiEvent.ToastShow.type),
-  properties: TuiEvent.ToastShow.data,
-}).annotate({ identifier: "EventTuiToastShow" })
-const EventTuiSessionSelect = Schema.Struct({
-  type: Schema.Literal(TuiEvent.SessionSelect.type),
-  properties: TuiEvent.SessionSelect.data,
-}).annotate({ identifier: "EventTuiSessionSelect" })
-export const TuiPublishPayload = Schema.Union([
-  EventTuiPromptAppend,
-  EventTuiCommandExecute,
-  EventTuiToastShow,
-  EventTuiSessionSelect,
-])
-
-export const TuiPaths = {
-  appendPrompt: `${root}/append-prompt`,
-  openHelp: `${root}/open-help`,
-  openSessions: `${root}/open-sessions`,
-  openThemes: `${root}/open-themes`,
-  openModels: `${root}/open-models`,
-  submitPrompt: `${root}/submit-prompt`,
-  clearPrompt: `${root}/clear-prompt`,
-  executeCommand: `${root}/execute-command`,
-  showToast: `${root}/show-toast`,
-  publish: `${root}/publish`,
-  selectSession: `${root}/select-session`,
-  controlNext: `${root}/control/next`,
-  controlResponse: `${root}/control/response`,
-} as const
-
-export const TuiApi = HttpApi.make("tui")
-  .add(
-    HttpApiGroup.make("tui")
-      .add(
-        HttpApiEndpoint.post("appendPrompt", TuiPaths.appendPrompt, {
-          query: WorkspaceRoutingQuery,
-          payload: TuiEvent.PromptAppend.data,
-          success: described(Schema.Boolean, "Prompt processed successfully"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tui.appendPrompt",
-            summary: "Append TUI prompt",
-            description: "Append prompt to the TUI.",
-          }),
-        ),
-        HttpApiEndpoint.post("openHelp", TuiPaths.openHelp, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Boolean, "Help dialog opened successfully"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tui.openHelp",
-            summary: "Open help dialog",
-            description: "Open the help dialog in the TUI to display user assistance information.",
-          }),
-        ),
-        HttpApiEndpoint.post("openSessions", TuiPaths.openSessions, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Boolean, "Session dialog opened successfully"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tui.openSessions",
-            summary: "Open sessions dialog",
-            description: "Open the session dialog.",
-          }),
-        ),
-        HttpApiEndpoint.post("openThemes", TuiPaths.openThemes, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Boolean, "Theme dialog opened successfully"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tui.openThemes",
-            summary: "Open themes dialog",
-            description: "Open the theme dialog.",
-          }),
-        ),
-        HttpApiEndpoint.post("openModels", TuiPaths.openModels, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Boolean, "Model dialog opened successfully"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tui.openModels",
-            summary: "Open models dialog",
-            description: "Open the model dialog.",
-          }),
-        ),
-        HttpApiEndpoint.post("submitPrompt", TuiPaths.submitPrompt, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Boolean, "Prompt submitted successfully"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tui.submitPrompt",
-            summary: "Submit TUI prompt",
-            description: "Submit the prompt.",
-          }),
-        ),
-        HttpApiEndpoint.post("clearPrompt", TuiPaths.clearPrompt, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Boolean, "Prompt cleared successfully"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tui.clearPrompt",
-            summary: "Clear TUI prompt",
-            description: "Clear the prompt.",
-          }),
-        ),
-        HttpApiEndpoint.post("executeCommand", TuiPaths.executeCommand, {
-          query: WorkspaceRoutingQuery,
-          payload: CommandPayload,
-          success: described(Schema.Boolean, "Command executed successfully"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tui.executeCommand",
-            summary: "Execute TUI command",
-            description: "Execute a TUI command.",
-          }),
-        ),
-        HttpApiEndpoint.post("showToast", TuiPaths.showToast, {
-          query: WorkspaceRoutingQuery,
-          payload: TuiEvent.ToastShow.data,
-          success: described(Schema.Boolean, "Toast notification shown successfully"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tui.showToast",
-            summary: "Show TUI toast",
-            description: "Show a toast notification in the TUI.",
-          }),
-        ),
-        HttpApiEndpoint.post("publish", TuiPaths.publish, {
-          query: WorkspaceRoutingQuery,
-          payload: TuiPublishPayload,
-          success: described(Schema.Boolean, "Event published successfully"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tui.publish",
-            summary: "Publish TUI event",
-            description: "Publish a TUI event.",
-          }),
-        ),
-        HttpApiEndpoint.post("selectSession", TuiPaths.selectSession, {
-          query: WorkspaceRoutingQuery,
-          payload: TuiEvent.SessionSelect.data,
-          success: described(Schema.Boolean, "Session selected successfully"),
-          error: [HttpApiError.BadRequest, ApiNotFoundError],
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tui.selectSession",
-            summary: "Select session",
-            description: "Navigate the TUI to display the specified session.",
-          }),
-        ),
-        HttpApiEndpoint.get("controlNext", TuiPaths.controlNext, {
-          query: WorkspaceRoutingQuery,
-          success: described(TuiRequestPayload, "Next TUI request"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tui.control.next",
-            summary: "Get next TUI request",
-            description: "Retrieve the next TUI request from the queue for processing.",
-          }),
-        ),
-        HttpApiEndpoint.post("controlResponse", TuiPaths.controlResponse, {
-          query: WorkspaceRoutingQuery,
-          payload: Schema.Unknown,
-          success: described(Schema.Boolean, "Response submitted successfully"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tui.control.response",
-            summary: "Submit TUI response",
-            description: "Submit a response to the TUI request queue to complete a pending request.",
-          }),
-        ),
-      )
-      .annotateMerge(OpenApi.annotations({ title: "tui", description: "Experimental HttpApi TUI routes." }))
-      .middleware(InstanceContextMiddleware)
-      .middleware(WorkspaceRoutingMiddleware)
-      .middleware(Authorization),
-  )
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "anymous experimental HttpApi",
-      version: "0.0.1",
-      description: "Experimental HttpApi surface for selected instance routes.",
-    }),
-  )

package/src/server/routes/instance/httpapi/groups/workspace.ts

@@ -1,141 +0,0 @@
-import { Workspace } from "@/control-plane/workspace"
-import { WorkspaceAdapterEntry } from "@/control-plane/types"
-import { Schema, Struct } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { ApiVcsApplyError } from "./instance"
-import { ApiNotFoundError } from "../errors"
-import { Authorization } from "../middleware/authorization"
-import { InstanceContextMiddleware } from "../middleware/instance-context"
-import { WorkspaceRoutingMiddleware, WorkspaceRoutingQuery } from "../middleware/workspace-routing"
-import { described } from "./metadata"
-
-const root = "/experimental/workspace"
-export const CreatePayload = Schema.Struct(Struct.omit(Workspace.CreateInput.fields, ["projectID"]))
-export const WarpPayload = Schema.Struct({
-  id: Schema.NullOr(Workspace.Info.fields.id),
-  sessionID: Workspace.SessionWarpInput.fields.sessionID,
-  copyChanges: Workspace.SessionWarpInput.fields.copyChanges,
-})
-
-export class ApiWorkspaceWarpError extends Schema.ErrorClass<ApiWorkspaceWarpError>("WorkspaceWarpError")(
-  {
-    name: Schema.Literal("WorkspaceWarpError"),
-    data: Schema.Struct({
-      message: Schema.String,
-    }),
-  },
-  { httpApiStatus: 400 },
-) {}
-
-export class ApiWorkspaceCreateError extends Schema.ErrorClass<ApiWorkspaceCreateError>("WorkspaceCreateError")(
-  {
-    name: Schema.Literal("WorkspaceCreateError"),
-    data: Schema.Struct({
-      message: Schema.String,
-    }),
-  },
-  { httpApiStatus: 400 },
-) {}
-
-export const WorkspacePaths = {
-  adapters: `${root}/adapter`,
-  list: root,
-  syncList: `${root}/sync-list`,
-  status: `${root}/status`,
-  remove: `${root}/:id`,
-  warp: `${root}/warp`,
-} as const
-
-export const WorkspaceApi = HttpApi.make("workspace")
-  .add(
-    HttpApiGroup.make("workspace")
-      .add(
-        HttpApiEndpoint.get("adapters", WorkspacePaths.adapters, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(WorkspaceAdapterEntry), "Workspace adapters"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.workspace.adapter.list",
-            summary: "List workspace adapters",
-            description: "List all available workspace adapters for the current project.",
-          }),
-        ),
-        HttpApiEndpoint.get("list", WorkspacePaths.list, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(Workspace.Info), "Workspaces"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.workspace.list",
-            summary: "List workspaces",
-            description: "List all workspaces.",
-          }),
-        ),
-        HttpApiEndpoint.post("create", WorkspacePaths.list, {
-          query: WorkspaceRoutingQuery,
-          payload: CreatePayload,
-          success: described(Workspace.Info, "Workspace created"),
-          error: [ApiWorkspaceCreateError, HttpApiError.BadRequest],
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.workspace.create",
-            summary: "Create workspace",
-            description: "Create a workspace for the current project.",
-          }),
-        ),
-        HttpApiEndpoint.post("syncList", WorkspacePaths.syncList, {
-          query: WorkspaceRoutingQuery,
-          success: described(HttpApiSchema.NoContent, "Workspace list synced"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.workspace.syncList",
-            summary: "Sync workspace list",
-            description: "Register missing workspaces returned by workspace adapters.",
-          }),
-        ),
-        HttpApiEndpoint.get("status", WorkspacePaths.status, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(Workspace.ConnectionStatus), "Workspace status"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.workspace.status",
-            summary: "Workspace status",
-            description: "Get connection status for workspaces in the current project.",
-          }),
-        ),
-        HttpApiEndpoint.delete("remove", WorkspacePaths.remove, {
-          params: { id: Workspace.Info.fields.id },
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.UndefinedOr(Workspace.Info), "Workspace removed"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.workspace.remove",
-            summary: "Remove workspace",
-            description: "Remove an existing workspace.",
-          }),
-        ),
-        HttpApiEndpoint.post("warp", WorkspacePaths.warp, {
-          query: WorkspaceRoutingQuery,
-          payload: WarpPayload,
-          success: described(HttpApiSchema.NoContent, "Session warped"),
-          error: [ApiWorkspaceWarpError, ApiVcsApplyError, ApiNotFoundError],
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.workspace.warp",
-            summary: "Warp session into workspace",
-            description: "Move a session's sync history into the target workspace, or detach it to the local project.",
-          }),
-        ),
-      )
-      .annotateMerge(OpenApi.annotations({ title: "workspace", description: "Experimental HttpApi workspace routes." }))
-      .middleware(InstanceContextMiddleware)
-      .middleware(WorkspaceRoutingMiddleware)
-      .middleware(Authorization),
-  )
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "anymous experimental HttpApi",
-      version: "0.0.1",
-      description: "Experimental HttpApi surface for selected instance routes.",
-    }),
-  )

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

@@ -1,34 +0,0 @@
-import { Config } from "@/config/config"
-import { Provider } from "@/provider/provider"
-import * as InstanceState from "@/effect/instance-state"
-import { Effect } from "effect"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { InstanceHttpApi } from "../api"
-import { markInstanceForDisposal } from "../lifecycle"
-
-export const configHandlers = HttpApiBuilder.group(InstanceHttpApi, "config", (handlers) =>
-  Effect.gen(function* () {
-    const providerSvc = yield* Provider.Service
-    const configSvc = yield* Config.Service
-
-    const get = Effect.fn("ConfigHttpApi.get")(function* () {
-      return yield* configSvc.get()
-    })
-
-    const update = Effect.fn("ConfigHttpApi.update")(function* (ctx) {
-      yield* configSvc.update(ctx.payload)
-      yield* markInstanceForDisposal(yield* InstanceState.context)
-      return ctx.payload
-    })
-
-    const providers = Effect.fn("ConfigHttpApi.providers")(function* () {
-      const providers = yield* providerSvc.list()
-      return {
-        providers: Object.values(providers).map(Provider.toPublicInfo),
-        default: Provider.defaultModelIDs(providers),
-      }
-    })
-
-    return handlers.handle("get", get).handle("update", update).handle("providers", providers)
-  }),
-)

package/src/server/routes/instance/httpapi/handlers/control-plane.ts

@@ -1,37 +0,0 @@
-import { MoveSession } from "@anymous-ai/core/control-plane/move-session"
-import { SessionV2 } from "@anymous-ai/core/session"
-import { Effect } from "effect"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { RootHttpApi } from "../api"
-import { ApiMoveSessionError, MoveSessionPayload } from "../groups/control-plane"
-
-export const controlPlaneHandlers = HttpApiBuilder.group(RootHttpApi, "controlPlane", (handlers) =>
-  Effect.gen(function* () {
-    const service = yield* MoveSession.Service
-
-    const moveSession = Effect.fn("ControlPlaneHttpApi.moveSession")(function* (ctx: {
-      payload: typeof MoveSessionPayload.Type
-    }) {
-      yield* service.moveSession(ctx.payload).pipe(
-        Effect.mapError(
-          (error) =>
-            new ApiMoveSessionError({
-              name: "MoveSessionError",
-              data: { message: message(error) },
-            }),
-        ),
-      )
-    })
-
-    return handlers.handle("moveSession", moveSession)
-  }),
-)
-
-function message(error: MoveSession.Error) {
-  if (error instanceof SessionV2.NotFoundError) return `Session not found: ${error.sessionID}`
-  if (error instanceof MoveSession.DestinationProjectMismatchError)
-    return "Destination directory belongs to another project"
-  if (error instanceof MoveSession.ApplyChangesError)
-    return `Unable to apply your changes in the destination directory. The files may conflict with existing changes.`
-  return error.message
-}

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

@@ -1,43 +0,0 @@
-import { Auth } from "@/auth"
-
-import { Effect } from "effect"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import { RootHttpApi } from "../api"
-import { LogInput } from "../groups/control"
-import { ProviderV2 } from "@anymous-ai/core/provider"
-
-export const controlHandlers = HttpApiBuilder.group(RootHttpApi, "control", (handlers) =>
-  Effect.gen(function* () {
-    const auth = yield* Auth.Service
-
-    const authSet = Effect.fn("ControlHttpApi.authSet")(function* (ctx: {
-      params: { providerID: ProviderV2.ID }
-      payload: Auth.Info
-    }) {
-      yield* auth.set(ctx.params.providerID, ctx.payload).pipe(Effect.orDie)
-      return true
-    })
-
-    const authRemove = Effect.fn("ControlHttpApi.authRemove")(function* (ctx: {
-      params: { providerID: ProviderV2.ID }
-    }) {
-      yield* auth.remove(ctx.params.providerID).pipe(Effect.orDie)
-      return true
-    })
-
-    const log = Effect.fn("ControlHttpApi.log")(function* (ctx: { payload: typeof LogInput.Type }) {
-      const write =
-        ctx.payload.level === "debug"
-          ? Effect.logDebug
-          : ctx.payload.level === "info"
-            ? Effect.logInfo
-            : ctx.payload.level === "warn"
-              ? Effect.logWarning
-              : Effect.logError
-      yield* write(ctx.payload.message).pipe(Effect.annotateLogs(ctx.payload.extra ?? {}))
-      return true
-    })
-
-    return handlers.handle("authSet", authSet).handle("authRemove", authRemove).handle("log", log)
-  }),
-)

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

@@ -1,99 +0,0 @@
-import { EventV2Bridge } from "@/event-v2-bridge"
-import { InstanceState } from "@/effect/instance-state"
-import { GlobalBus } from "@/bus/global"
-import { EventV2 } from "@anymous-ai/core/event"
-import { Effect, Queue } from "effect"
-import * as Stream from "effect/Stream"
-import { HttpServerResponse } from "effect/unstable/http"
-import { HttpApiBuilder } from "effect/unstable/httpapi"
-import * as Sse from "effect/unstable/encoding/Sse"
-import { EventApi } from "../groups/event"
-
-function eventData(data: unknown): Sse.Event {
-  return {
-    _tag: "Event",
-    event: "message",
-    id: undefined,
-    data: JSON.stringify(data),
-  }
-}
-
-function eventID() {
-  return EventV2.ID.create()
-}
-
-function eventResponse(events: EventV2.Interface) {
-  return Effect.gen(function* () {
-    const instance = yield* InstanceState.context
-    const workspaceID = yield* InstanceState.workspaceID
-    // Listener registration is eager, so events published after this point cannot
-    // be lost while the HTTP body fiber is starting or emitting server.connected.
-    const queue = yield* Queue.unbounded<EventV2.Payload>()
-    const unsubscribe = yield* events.listen((event) => Effect.sync(() => Queue.offerUnsafe(queue, event)))
-    yield* Effect.addFinalizer(() => unsubscribe)
-    const stream = Stream.fromQueue(queue).pipe(
-      Stream.filter(
-        (event) =>
-          event.location?.directory === instance.directory &&
-          (event.location.workspaceID === undefined || event.location.workspaceID === workspaceID),
-      ),
-      Stream.map((event) => ({ id: event.id, type: event.type, properties: event.data })),
-    )
-    const disposed = Stream.callback<{ id: string; type: string; properties: unknown }>((queue) => {
-      const listener = (event: {
-        directory?: string
-        payload: { id?: string; type?: string; properties?: unknown }
-      }) => {
-        if (event.directory !== instance.directory || event.payload.type !== "server.instance.disposed") return
-        Queue.offerUnsafe(queue, {
-          id: event.payload.id ?? eventID(),
-          type: "server.instance.disposed",
-          properties: event.payload.properties ?? {},
-        })
-      }
-      return Effect.acquireRelease(
-        Effect.sync(() => GlobalBus.on("event", listener)),
-        () => Effect.sync(() => GlobalBus.off("event", listener)),
-      )
-    })
-    const output = stream.pipe(
-      Stream.merge(disposed, { haltStrategy: "left" }),
-      Stream.takeUntil((event) => event.type === "server.instance.disposed"),
-    )
-    const heartbeat = Stream.tick("10 seconds").pipe(
-      Stream.drop(1),
-      Stream.map(() => ({ id: eventID(), type: "server.heartbeat", properties: {} })),
-    )
-
-    yield* Effect.logInfo("event connected")
-    return HttpServerResponse.stream(
-      Stream.make({ id: eventID(), type: "server.connected", properties: {} }).pipe(
-        Stream.concat(output.pipe(Stream.merge(heartbeat, { haltStrategy: "left" }))),
-        Stream.map(eventData),
-        Stream.pipeThroughChannel(Sse.encode()),
-        Stream.encodeText,
-        Stream.ensuring(Effect.logInfo("event disconnected")),
-      ),
-      {
-        contentType: "text/event-stream",
-        headers: {
-          "Cache-Control": "no-cache, no-transform",
-          "X-Accel-Buffering": "no",
-          "X-Content-Type-Options": "nosniff",
-        },
-      },
-    )
-  })
-}
-
-export const eventHandlers = HttpApiBuilder.group(EventApi, "event", (handlers) =>
-  Effect.gen(function* () {
-    const events = yield* EventV2Bridge.Service
-    return handlers.handleRaw(
-      "subscribe",
-      Effect.fn("EventHttpApi.subscribe")(function* () {
-        return yield* eventResponse(events)
-      }),
-    )
-  }),
-)