soraacode 0.2.0 → 0.2.2

package/src/question/index.ts

@@ -1,161 +0,0 @@
-import { LayerNode } from "@soraacode/core/effect/layer-node"
-import { Deferred, Effect, Layer, Schema, Context } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-import { SessionID } from "@/session/schema"
-import { QuestionID } from "./schema"
-import { EventV2Bridge } from "@/event-v2-bridge"
-import { QuestionV1 } from "@soraacode/schema/question-v1"
-
-export const Option = QuestionV1.Option
-export type Option = typeof Option.Type
-export const Info = QuestionV1.Info
-export type Info = typeof Info.Type
-export const Prompt = QuestionV1.Prompt
-export type Prompt = typeof Prompt.Type
-export const Tool = QuestionV1.Tool
-export type Tool = typeof Tool.Type
-export const Request = QuestionV1.Request
-export type Request = typeof Request.Type
-export const Answer = QuestionV1.Answer
-export type Answer = typeof Answer.Type
-export const Reply = QuestionV1.Reply
-export type Reply = typeof Reply.Type
-export const Replied = QuestionV1.Replied
-export const Rejected = QuestionV1.Rejected
-export const Event = QuestionV1.Event
-
-export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("QuestionRejectedError", {}) {
-  override get message() {
-    return "The user dismissed this question"
-  }
-}
-
-export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Question.NotFoundError", {
-  requestID: QuestionID,
-}) {}
-
-interface PendingEntry {
-  info: Request
-  deferred: Deferred.Deferred<ReadonlyArray<Answer>, RejectedError>
-}
-
-interface State {
-  pending: Map<QuestionID, PendingEntry>
-}
-
-// Service
-
-export interface Interface {
-  readonly ask: (input: {
-    sessionID: SessionID
-    questions: ReadonlyArray<Info>
-    tool?: Tool
-  }) => Effect.Effect<ReadonlyArray<Answer>, RejectedError>
-  readonly reply: (input: {
-    requestID: QuestionID
-    answers: ReadonlyArray<Answer>
-  }) => Effect.Effect<void, NotFoundError>
-  readonly reject: (requestID: QuestionID) => Effect.Effect<void, NotFoundError>
-  readonly list: () => Effect.Effect<ReadonlyArray<Request>>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Question") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const events = yield* EventV2Bridge.Service
-    const state = yield* InstanceState.make<State>(
-      Effect.fn("Question.state")(function* () {
-        const state = {
-          pending: new Map<QuestionID, PendingEntry>(),
-        }
-
-        yield* Effect.addFinalizer(() =>
-          Effect.gen(function* () {
-            for (const item of state.pending.values()) {
-              yield* Deferred.fail(item.deferred, new RejectedError())
-            }
-            state.pending.clear()
-          }),
-        )
-
-        return state
-      }),
-    )
-
-    const ask = Effect.fn("Question.ask")(function* (input: {
-      sessionID: SessionID
-      questions: ReadonlyArray<Info>
-      tool?: Tool
-    }) {
-      const pending = (yield* InstanceState.get(state)).pending
-      const id = QuestionID.ascending()
-      yield* Effect.logInfo("asking", { id, questions: input.questions.length })
-
-      const deferred = yield* Deferred.make<ReadonlyArray<Answer>, RejectedError>()
-      const info: Request = {
-        id,
-        sessionID: input.sessionID,
-        questions: input.questions,
-        tool: input.tool,
-      }
-      pending.set(id, { info, deferred })
-      yield* events.publish(Event.Asked, info)
-
-      return yield* Effect.ensuring(
-        Deferred.await(deferred),
-        Effect.sync(() => {
-          pending.delete(id)
-        }),
-      )
-    })
-
-    const reply = Effect.fn("Question.reply")(function* (input: {
-      requestID: QuestionID
-      answers: ReadonlyArray<Answer>
-    }) {
-      const pending = (yield* InstanceState.get(state)).pending
-      const existing = pending.get(input.requestID)
-      if (!existing) {
-        yield* Effect.logWarning("reply for unknown request", { requestID: input.requestID })
-        return yield* new NotFoundError({ requestID: input.requestID })
-      }
-      pending.delete(input.requestID)
-      yield* Effect.logInfo("replied", { requestID: input.requestID, answers: input.answers })
-      yield* events.publish(Event.Replied, {
-        sessionID: existing.info.sessionID,
-        requestID: existing.info.id,
-        answers: input.answers.map((a) => [...a]),
-      })
-      yield* Deferred.succeed(existing.deferred, input.answers)
-    })
-
-    const reject = Effect.fn("Question.reject")(function* (requestID: QuestionID) {
-      const pending = (yield* InstanceState.get(state)).pending
-      const existing = pending.get(requestID)
-      if (!existing) {
-        yield* Effect.logWarning("reject for unknown request", { requestID })
-        return yield* new NotFoundError({ requestID })
-      }
-      pending.delete(requestID)
-      yield* Effect.logInfo("rejected", { requestID })
-      yield* events.publish(Event.Rejected, {
-        sessionID: existing.info.sessionID,
-        requestID: existing.info.id,
-      })
-      yield* Deferred.fail(existing.deferred, new RejectedError())
-    })
-
-    const list = Effect.fn("Question.list")(function* () {
-      const pending = (yield* InstanceState.get(state)).pending
-      return Array.from(pending.values(), (x) => x.info)
-    })
-
-    return Service.of({ ask, reply, reject, list })
-  }),
-)
-
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [EventV2Bridge.node] })
-
-export * as Question from "."

package/src/question/schema.ts

@@ -1,4 +0,0 @@
-import { QuestionV1 } from "@soraacode/schema/question-v1"
-
-export const QuestionID = QuestionV1.ID
-export type QuestionID = typeof QuestionID.Type

package/src/server/auth.ts

@@ -1,48 +0,0 @@
-export * as ServerAuth from "./auth"
-
-import { ConfigService } from "@/effect/config-service"
-import { Flag } from "@soraacode/core/flag/flag"
-import { Config as EffectConfig, Context, Option, Redacted } from "effect"
-
-export type Credentials = {
-  password?: string
-  username?: string
-}
-
-export type DecodedCredentials = {
-  readonly username: string
-  readonly password: Redacted.Redacted
-}
-
-export class Config extends ConfigService.Service<Config>()("@opencode/ServerAuthConfig", {
-  password: EffectConfig.string("OPENCODE_SERVER_PASSWORD").pipe(EffectConfig.option),
-  username: EffectConfig.string("OPENCODE_SERVER_USERNAME").pipe(EffectConfig.withDefault("opencode")),
-}) {}
-
-export type Info = Context.Service.Shape<typeof Config>
-
-export function required(config: Info) {
-  return Option.isSome(config.password) && config.password.value !== ""
-}
-
-export function authorized(credentials: DecodedCredentials, config: Info) {
-  return (
-    Option.isSome(config.password) &&
-    credentials.username === config.username &&
-    Redacted.value(credentials.password) === config.password.value
-  )
-}
-
-export function header(credentials?: Credentials) {
-  const password = credentials?.password ?? Flag.OPENCODE_SERVER_PASSWORD
-  if (!password) return undefined
-
-  const username = credentials?.username ?? Flag.OPENCODE_SERVER_USERNAME ?? "opencode"
-  return `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`
-}
-
-export function headers(credentials?: Credentials) {
-  const authorization = header(credentials)
-  if (!authorization) return undefined
-  return { Authorization: authorization }
-}

package/src/server/event.ts

@@ -1,10 +0,0 @@
-import { Schema } from "effect"
-import { ServerEvent } from "@soraacode/schema/server-event"
-
-export const Event = ServerEvent
-
-export const InstanceDisposed = Schema.Struct({
-  id: Schema.String,
-  type: Schema.Literal("server.instance.disposed"),
-  properties: Schema.Struct({ directory: Schema.String }),
-}).annotate({ identifier: "Event.server.instance.disposed" })

package/src/server/global-lifecycle.ts

@@ -1,28 +0,0 @@
-import { GlobalBus } from "@/bus/global"
-import { InstanceStore } from "@/project/instance-store"
-import { Effect } from "effect"
-import { Event } from "./event"
-
-export const emitGlobalDisposed = Effect.sync(() =>
-  GlobalBus.emit("event", {
-    directory: "global",
-    payload: {
-      type: Event.Disposed.type,
-      properties: {},
-    },
-  }),
-)
-
-export const disposeAllInstancesAndEmitGlobalDisposed = Effect.fn("Server.disposeAllInstancesAndEmitGlobalDisposed")(
-  function* (options?: { swallowErrors?: boolean }) {
-    const store = yield* InstanceStore.Service
-    yield* Effect.gen(function* () {
-      yield* options?.swallowErrors
-        ? store.disposeAll().pipe(Effect.catchCause((cause) => Effect.logWarning("global disposal failed", { cause })))
-        : store.disposeAll()
-      yield* emitGlobalDisposed
-    }).pipe(Effect.uninterruptible)
-  },
-)
-
-export * as GlobalLifecycle from "./global-lifecycle"

package/src/server/mdns.ts

@@ -1,47 +0,0 @@
-import { Bonjour } from "bonjour-service"
-
-let bonjour: Bonjour | undefined
-let currentPort: number | undefined
-
-export function publish(port: number, domain?: string) {
-  if (currentPort === port) return
-  if (bonjour) unpublish()
-
-  try {
-    const host = domain ?? "opencode.local"
-    const name = `opencode-${port}`
-    bonjour = new Bonjour()
-    const service = bonjour.publish({
-      name,
-      type: "http",
-      host,
-      port,
-      txt: { path: "/" },
-    })
-
-    service.on("error", () => {})
-
-    currentPort = port
-  } catch {
-    if (bonjour) {
-      try {
-        bonjour.destroy()
-      } catch {}
-    }
-    bonjour = undefined
-    currentPort = undefined
-  }
-}
-
-export function unpublish() {
-  if (bonjour) {
-    try {
-      bonjour.unpublishAll()
-      bonjour.destroy()
-    } catch {}
-    bonjour = undefined
-    currentPort = undefined
-  }
-}
-
-export * as MDNS from "./mdns"

package/src/server/proxy-util.ts

@@ -1,48 +0,0 @@
-const hop = new Set([
-  "connection",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "proxy-connection",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade",
-  "host",
-])
-
-function sanitize(out: Headers) {
-  for (const key of hop) out.delete(key)
-  out.delete("accept-encoding")
-  out.delete("x-opencode-directory")
-  out.delete("x-opencode-workspace")
-}
-
-export function headers(input: Request | HeadersInit | Record<string, string>, extra?: HeadersInit) {
-  const raw = input instanceof Request ? input.headers : input
-  const out = new Headers(raw instanceof Headers ? raw : Object.entries(raw as Record<string, string>))
-  sanitize(out)
-  if (!extra) return out
-  for (const [key, value] of new Headers(extra).entries()) {
-    out.set(key, value)
-  }
-  return out
-}
-
-export function websocketProtocols(input: Request | Record<string, string | undefined>) {
-  const value = input instanceof Request ? input.headers.get("sec-websocket-protocol") : input["sec-websocket-protocol"]
-  if (!value) return []
-  return value
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean)
-}
-
-export function websocketTargetURL(url: string | URL) {
-  const next = new URL(url)
-  if (next.protocol === "http:") next.protocol = "ws:"
-  if (next.protocol === "https:") next.protocol = "wss:"
-  return next.toString()
-}
-
-export * as ProxyUtil from "./proxy-util"

package/src/server/routes/instance/httpapi/AGENTS.md

@@ -1,39 +0,0 @@
-# HttpApi Route Patterns
-
-Use `HttpApiBuilder.group(...)` for normal HTTP endpoints, including streaming HTTP responses such as server-sent events. Handlers should yield stable services once while building the handler layer, then close over those services in endpoint implementations.
-
-```ts
-export const sessionHandlers = HttpApiBuilder.group(InstanceHttpApi, "session", (handlers) =>
-  Effect.gen(function* () {
-    const session = yield* Session.Service
-
-    return handlers.handle("list", () => session.list())
-  }),
-)
-```
-
-For SSE endpoints, stay in `HttpApiBuilder.group(...)` and return `HttpServerResponse.stream(...)` from the handler. Annotate the endpoint success schema with `HttpApiSchema.asText({ contentType: "text/event-stream" })` so OpenAPI documents the stream content type.
-
-Use `HttpApiBuilder.group(...)` with `handleRaw(...)` for declared endpoints that need the raw request or response, including WebSocket upgrade routes. This keeps endpoint middleware, routing context, and OpenAPI metadata on one typed route tree.
-
-```ts
-export const ptyConnectHandlers = HttpApiBuilder.group(PtyConnectApi, "pty-connect", (handlers) =>
-  Effect.gen(function* () {
-    const pty = yield* Pty.Service
-
-    return handlers.handleRaw("connect", (ctx) => connectPty(ctx.request, pty))
-  }),
-)
-```
-
-Use raw `HttpRouter.use(...)` only for routes outside the declared API surface, such as a catch-all UI fallback.
-
-Avoid `Effect.provide(SomeLayer)` inside request handlers or raw route callbacks. Stable layers should be provided once at the application/layer boundary, not rebuilt or scoped per request.
-
-Avoid `HttpRouter.provideRequest(...)` unless the dependency is intentionally request-level. Prefer `HttpRouter.use(...)` for stable app services.
-
-Use `Effect.provideService(...)` in middleware only for request-derived context, such as `WorkspaceRouteContext`, `InstanceRef`, or `WorkspaceRef`. Do not use it to smuggle stable services through request effects when they can be yielded at layer construction.
-
-Public JSON errors should be explicit `Schema.ErrorClass` contracts declared on each endpoint. Use built-in `HttpApiError.*` classes only when their empty/tagged body is the intended wire shape; for SDK-visible errors with messages, define an API error schema such as `ApiNotFoundError` and fail with that exact declared error. Keep domain and storage services free of HttpApi types, and translate expected domain errors at the handler boundary.
-
-When adding middleware, declare endpoint-contract middleware on the owning `HttpApiGroup` and provide its implementation layer at the assembly boundary in `server.ts`. Keep router middleware for truly raw fallback routes or global transport policy.

package/src/server/routes/instance/httpapi/api.ts

@@ -1,97 +0,0 @@
-import { Schema } from "effect"
-import { HttpApi } from "effect/unstable/httpapi"
-import { EventV2 } from "@soraacode/core/event"
-import { EventManifest } from "@/event-manifest"
-import { Credential } from "@soraacode/core/credential"
-import { Integration } from "@soraacode/core/integration"
-import { SkillV2 } from "@soraacode/core/skill"
-import { InstanceDisposed } from "@/server/event"
-import { Question } from "@/question"
-import { ConfigApi } from "./groups/config"
-import { ControlApi } from "./groups/control"
-import { ControlPlaneApi } from "./groups/control-plane"
-import { EventApi } from "./groups/event"
-import { ExperimentalApi } from "./groups/experimental"
-import { FileApi } from "./groups/file"
-import { InstanceApi } from "./groups/instance"
-import { McpApi } from "./groups/mcp"
-import { PermissionApi } from "./groups/permission"
-import { ProjectApi } from "./groups/project"
-import { ProjectCopyApi } from "./groups/project-copy"
-import { ProviderApi } from "./groups/provider"
-import { PtyApi, PtyConnectApi } from "./groups/pty"
-import { QuestionApi } from "./groups/question"
-import { SessionApi } from "./groups/session"
-import { SyncApi } from "./groups/sync"
-import { TuiApi } from "./groups/tui"
-import { WorkspaceApi } from "./groups/workspace"
-import { makeApi } from "@soraacode/protocol/api"
-import { LocationMiddleware } from "@soraacode/server/location"
-import { SessionLocationMiddleware } from "@soraacode/server/middleware/session-location"
-import { GlobalApi } from "./groups/global"
-import { Authorization } from "./middleware/authorization"
-import { SchemaErrorMiddleware } from "./middleware/schema-error"
-
-const EventSchema = Schema.Union([
-  ...EventManifest.Latest.values()
-    .map((definition) =>
-      Schema.Struct({
-        id: EventV2.ID,
-        type: Schema.Literal(definition.type),
-        properties: definition.data,
-      }).annotate({ identifier: `Event.${definition.type}` }),
-    )
-    .toArray(),
-  InstanceDisposed,
-]).annotate({ identifier: "Event" })
-
-export const ServerApi = makeApi({
-  definitions: EventManifest.Latest.values().toArray(),
-  locationMiddleware: LocationMiddleware,
-  sessionLocationMiddleware: SessionLocationMiddleware,
-})
-
-export const RootHttpApi = HttpApi.make("opencode-root")
-  .addHttpApi(ControlApi)
-  .addHttpApi(ControlPlaneApi)
-  .addHttpApi(GlobalApi)
-  .middleware(SchemaErrorMiddleware)
-  .middleware(Authorization)
-
-export const InstanceHttpApi = HttpApi.make("opencode-instance")
-  .addHttpApi(ConfigApi)
-  .addHttpApi(ExperimentalApi)
-  .addHttpApi(FileApi)
-  .addHttpApi(InstanceApi)
-  .addHttpApi(McpApi)
-  .addHttpApi(ProjectApi)
-  .addHttpApi(ProjectCopyApi)
-  .addHttpApi(PtyApi)
-  .addHttpApi(QuestionApi)
-  .addHttpApi(PermissionApi)
-  .addHttpApi(ProviderApi)
-  .addHttpApi(SessionApi)
-  .addHttpApi(SyncApi)
-  .addHttpApi(TuiApi)
-  .addHttpApi(WorkspaceApi)
-  .middleware(SchemaErrorMiddleware)
-
-export const OpenCodeHttpApi = HttpApi.make("opencode")
-  .addHttpApi(RootHttpApi)
-  .addHttpApi(EventApi)
-  .addHttpApi(InstanceHttpApi)
-  .addHttpApi(ServerApi)
-  .addHttpApi(PtyConnectApi)
-  .annotate(HttpApi.AdditionalSchemas, [
-    EventSchema,
-    Question.Replied,
-    Question.Rejected,
-    Credential.Value,
-    Integration.Inputs,
-    Integration.Method,
-    Integration.Ref,
-    SkillV2.Source,
-  ])
-
-export type RootHttpApiType = typeof RootHttpApi
-export type InstanceHttpApiType = typeof InstanceHttpApi

package/src/server/routes/instance/httpapi/errors.ts

@@ -1,193 +0,0 @@
-import { Schema } from "effect"
-
-export class InvalidRequestError extends Schema.TaggedErrorClass<InvalidRequestError>()(
-  "InvalidRequestError",
-  {
-    message: Schema.String,
-    kind: Schema.optional(Schema.String),
-    field: Schema.optional(Schema.String),
-  },
-  { httpApiStatus: 400 },
-) {}
-
-export class UnauthorizedError extends Schema.TaggedErrorClass<UnauthorizedError>()(
-  "UnauthorizedError",
-  { message: Schema.String },
-  { httpApiStatus: 401 },
-) {}
-
-export class ForbiddenError extends Schema.TaggedErrorClass<ForbiddenError>()(
-  "ForbiddenError",
-  { message: Schema.String },
-  { httpApiStatus: 403 },
-) {}
-
-export class ConflictError extends Schema.TaggedErrorClass<ConflictError>()(
-  "ConflictError",
-  {
-    message: Schema.String,
-    resource: Schema.optional(Schema.String),
-  },
-  { httpApiStatus: 409 },
-) {}
-
-export class UpstreamError extends Schema.TaggedErrorClass<UpstreamError>()(
-  "UpstreamError",
-  {
-    message: Schema.String,
-    service: Schema.optional(Schema.String),
-    status: Schema.optional(Schema.Number),
-  },
-  { httpApiStatus: 502 },
-) {}
-
-export class ServiceUnavailableError extends Schema.TaggedErrorClass<ServiceUnavailableError>()(
-  "ServiceUnavailableError",
-  {
-    message: Schema.String,
-    service: Schema.optional(Schema.String),
-  },
-  { httpApiStatus: 503 },
-) {}
-
-export class TimeoutError extends Schema.TaggedErrorClass<TimeoutError>()(
-  "TimeoutError",
-  {
-    message: Schema.String,
-    operation: Schema.optional(Schema.String),
-  },
-  { httpApiStatus: 504 },
-) {}
-
-export class UnknownError extends Schema.TaggedErrorClass<UnknownError>()(
-  "UnknownError",
-  {
-    message: Schema.String,
-    ref: Schema.optional(Schema.String),
-  },
-  { httpApiStatus: 500 },
-) {}
-
-export class ProviderNotFoundError extends Schema.TaggedErrorClass<ProviderNotFoundError>()(
-  "ProviderNotFoundError",
-  {
-    providerID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class ModelNotFoundError extends Schema.TaggedErrorClass<ModelNotFoundError>()(
-  "ModelNotFoundError",
-  {
-    providerID: Schema.String,
-    modelID: Schema.String,
-    suggestions: Schema.Array(Schema.String),
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class SessionNotFoundError extends Schema.TaggedErrorClass<SessionNotFoundError>()(
-  "SessionNotFoundError",
-  {
-    sessionID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class MessageNotFoundError extends Schema.TaggedErrorClass<MessageNotFoundError>()(
-  "MessageNotFoundError",
-  {
-    sessionID: Schema.String,
-    messageID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class InvalidCursorError extends Schema.TaggedErrorClass<InvalidCursorError>()(
-  "InvalidCursorError",
-  { message: Schema.String },
-  { httpApiStatus: 400 },
-) {}
-
-export class SessionBusyError extends Schema.TaggedErrorClass<SessionBusyError>()(
-  "SessionBusyError",
-  {
-    sessionID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 409 },
-) {}
-
-export class QuestionNotFoundError extends Schema.TaggedErrorClass<QuestionNotFoundError>()(
-  "QuestionNotFoundError",
-  {
-    requestID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class PermissionNotFoundError extends Schema.TaggedErrorClass<PermissionNotFoundError>()(
-  "PermissionNotFoundError",
-  {
-    requestID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class McpServerNotFoundError extends Schema.TaggedErrorClass<McpServerNotFoundError>()(
-  "McpServerNotFoundError",
-  {
-    name: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class PtyNotFoundError extends Schema.TaggedErrorClass<PtyNotFoundError>()(
-  "PtyNotFoundError",
-  {
-    ptyID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class PtyForbiddenError extends Schema.TaggedErrorClass<PtyForbiddenError>()(
-  "PtyForbiddenError",
-  {
-    message: Schema.String,
-  },
-  { httpApiStatus: 403 },
-) {}
-
-export class ProjectNotFoundError extends Schema.TaggedErrorClass<ProjectNotFoundError>()(
-  "ProjectNotFoundError",
-  {
-    projectID: Schema.String,
-    message: Schema.String,
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export class ApiNotFoundError extends Schema.ErrorClass<ApiNotFoundError>("NotFoundError")(
-  {
-    name: Schema.Literal("NotFoundError"),
-    data: Schema.Struct({
-      message: Schema.String,
-    }),
-  },
-  { httpApiStatus: 404 },
-) {}
-
-export function notFound(message: string) {
-  return new ApiNotFoundError({
-    name: "NotFoundError",
-    data: { message },
-  })
-}