@neurocode-ai/server 1.18.8

package/package.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@neurocode-ai/server",
+  "version": "1.18.8",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    "./*": "./src/*.ts"
+  },
+  "scripts": {
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "@neurocode-ai/core": "1.18.8",
+    "@neurocode-ai/protocol": "1.18.8",
+    "drizzle-orm": "1.0.0-rc.2",
+    "effect": "4.0.0-beta.83"
+  },
+  "devDependencies": {
+    "@tsconfig/bun": "1.0.9",
+    "@types/bun": "1.3.13",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1"
+  }
+}

package/src/api.ts

@@ -0,0 +1,8 @@
+import { makeDefaultApi } from "@neurocode-ai/protocol/api"
+import { LocationMiddleware } from "./location"
+import { SessionLocationMiddleware } from "./middleware/session-location"
+
+export const Api = makeDefaultApi({
+  locationMiddleware: LocationMiddleware,
+  sessionLocationMiddleware: SessionLocationMiddleware,
+})

package/src/auth.ts

@@ -0,0 +1,63 @@
+export * as ServerAuth from "./auth"
+
+import { Config as EffectConfig, Context, Effect, Layer, Option, Redacted } from "effect"
+
+export type Credentials = {
+  password?: string
+  username?: string
+}
+
+export type DecodedCredentials = {
+  readonly username: string
+  readonly password: Redacted.Redacted
+}
+
+export type Info = {
+  readonly password: Option.Option<string>
+  readonly username: string
+}
+
+export class Config extends Context.Service<Config, Info>()("@neurocode/ServerAuthConfig") {
+  static configLayer(input: Info) {
+    return Layer.succeed(this, this.of(input))
+  }
+
+  static get layer() {
+    return Layer.effect(
+      this,
+      Effect.gen(function* () {
+        return Config.of(
+          yield* EffectConfig.all({
+            password: EffectConfig.string("NEUROCODE_SERVER_PASSWORD").pipe(EffectConfig.option),
+            username: EffectConfig.string("NEUROCODE_SERVER_USERNAME").pipe(EffectConfig.withDefault("opencode")),
+          }),
+        )
+      }),
+    )
+  }
+}
+
+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 ?? process.env.NEUROCODE_SERVER_PASSWORD
+  if (!password) return undefined
+
+  return `Basic ${Buffer.from(`${credentials?.username ?? process.env.NEUROCODE_SERVER_USERNAME ?? "opencode"}:${password}`).toString("base64")}`
+}
+
+export function headers(credentials?: Credentials) {
+  const authorization = header(credentials)
+  if (!authorization) return undefined
+  return { Authorization: authorization }
+}

package/src/cors.ts

@@ -0,0 +1,34 @@
+import { Context } from "effect"
+
+const opencodeOrigin = /^https:\/\/([a-z0-9-]+\.)*opencode\.ai$/
+
+export type CorsOptions = { readonly cors?: ReadonlyArray<string> }
+
+export const CorsConfig = Context.Reference<CorsOptions | undefined>("@neurocode/ServerCorsConfig", {
+  defaultValue: () => undefined,
+})
+
+export function isAllowedCorsOrigin(input: string | undefined, opts?: CorsOptions) {
+  if (!input) return true
+  if (input.startsWith("http://localhost:")) return true
+  if (input.startsWith("http://127.0.0.1:")) return true
+  if (input.startsWith("oc://renderer")) return true
+  if (input === "tauri://localhost" || input === "http://tauri.localhost" || input === "https://tauri.localhost")
+    return true
+  if (opencodeOrigin.test(input)) return true
+  return opts?.cors?.includes(input) ?? false
+}
+
+export function isAllowedRequestOrigin(input: string | undefined, host: string | undefined, opts?: CorsOptions) {
+  if (!input) return true
+  if (host && sameHost(input, host)) return true
+  return isAllowedCorsOrigin(input, opts)
+}
+
+function sameHost(origin: string, host: string) {
+  try {
+    return new URL(origin).host === host
+  } catch {
+    return false
+  }
+}

package/src/handlers/agent.ts

@@ -0,0 +1,13 @@
+import { AgentV2 } from "@neurocode-ai/core/agent"
+import { Effect } from "effect"
+import { HttpApiBuilder } from "effect/unstable/httpapi"
+import { Api } from "../api"
+import { response } from "../location"
+
+export const AgentHandler = HttpApiBuilder.group(Api, "server.agent", (handlers) =>
+  handlers.handle("agent.list", () =>
+    Effect.gen(function* () {
+      return yield* response(AgentV2.Service.use((agent) => agent.all()))
+    }),
+  ),
+)

package/src/handlers/command.ts

@@ -0,0 +1,8 @@
+import { CommandV2 } from "@neurocode-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

@@ -0,0 +1,22 @@
+import { Integration } from "@neurocode-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

@@ -0,0 +1,52 @@
+import { EventV2 } from "@neurocode-ai/core/event"
+import { OpenCodeEvent } from "@neurocode-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(OpenCodeEvent)(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

@@ -0,0 +1,39 @@
+import { FileSystem } from "@neurocode-ai/core/filesystem"
+import { RelativePath } from "@neurocode-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

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

@@ -0,0 +1,104 @@
+import { Integration } from "@neurocode-ai/core/integration"
+import { Effect } from "effect"
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
+import { Api } from "../api"
+import { InvalidRequestError } from "@neurocode-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

@@ -0,0 +1,18 @@
+import { Location } from "@neurocode-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

@@ -0,0 +1,81 @@
+import { SessionMessage } from "@neurocode-ai/core/session/message"
+import { SessionV2 } from "@neurocode-ai/core/session"
+import { Effect, Schema } from "effect"
+import { HttpApiBuilder } from "effect/unstable/httpapi"
+import { Api } from "../api"
+import { InvalidCursorError, SessionNotFoundError, UnknownError } from "@neurocode-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

@@ -0,0 +1,17 @@
+import { Catalog } from "@neurocode-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

@@ -0,0 +1,98 @@
+import { Location } from "@neurocode-ai/core/location"
+import { PermissionV2 } from "@neurocode-ai/core/permission"
+import { PermissionSaved } from "@neurocode-ai/core/permission/saved"
+import { Effect } from "effect"
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
+import { Api } from "../api"
+import { PermissionNotFoundError, SessionNotFoundError } from "@neurocode-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

@@ -0,0 +1,68 @@
+import { Location } from "@neurocode-ai/core/location"
+import { ProjectCopy } from "@neurocode-ai/core/project/copy"
+import { Git } from "@neurocode-ai/core/git"
+import { Effect } from "effect"
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
+import { Api } from "../api"
+import { ProjectCopyError } from "@neurocode-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
+}