soraacode 0.1.0

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

@@ -0,0 +1,208 @@
+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: "opencode experimental HttpApi",
+      version: "0.0.1",
+      description: "Experimental HttpApi surface for selected instance routes.",
+    }),
+  )

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

@@ -0,0 +1,141 @@
+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: "opencode experimental HttpApi",
+      version: "0.0.1",
+      description: "Experimental HttpApi surface for selected instance routes.",
+    }),
+  )

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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,37 @@
+import { MoveSession } from "@opencode-ai/core/control-plane/move-session"
+import { SessionV2 } from "@opencode-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

@@ -0,0 +1,43 @@
+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 "@opencode-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

@@ -0,0 +1,99 @@
+import { EventV2Bridge } from "@/event-v2-bridge"
+import { InstanceState } from "@/effect/instance-state"
+import { GlobalBus } from "@/bus/global"
+import { EventV2 } from "@opencode-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)
+      }),
+    )
+  }),
+)