soraacode 0.2.0 → 0.2.1

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

@@ -1,139 +0,0 @@
-import { ConfigV1 } from "@soraacode/core/v1/config/config"
-import { EventV2 } from "@soraacode/core/event"
-import { EventManifest } from "@/event-manifest"
-import { InstanceDisposed } from "@/server/event"
-import "@soraacode/core/account"
-import "@/server/event"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import semver from "semver"
-import { described } from "./metadata"
-
-const GlobalHealth = Schema.Struct({
-  healthy: Schema.Literal(true),
-  version: Schema.String,
-})
-
-const SyncEventSchemas = EventManifest.Latest.values()
-  .flatMap((definition) => {
-    if (!definition.durable) return []
-    return [
-      Schema.Struct({
-        type: Schema.Literal("sync"),
-        id: EventV2.ID,
-        syncEvent: Schema.Struct({
-          type: Schema.Literal(EventV2.versionedType(definition.type, definition.durable.version)),
-          id: EventV2.ID,
-          seq: Schema.Finite,
-          aggregateID: Schema.String,
-          data: definition.data,
-        }),
-      }).annotate({ identifier: `SyncEvent.${definition.type}` }),
-    ]
-  })
-  .toArray()
-
-const GlobalEventSchema = Schema.Struct({
-  directory: Schema.String,
-  project: Schema.optional(Schema.String),
-  workspace: Schema.optional(Schema.String),
-  payload: Schema.Union([
-    ...EventManifest.Latest.values()
-      .map((definition) =>
-        Schema.Struct({ id: EventV2.ID, type: Schema.Literal(definition.type), properties: definition.data }),
-      )
-      .toArray(),
-    InstanceDisposed,
-    ...SyncEventSchemas,
-  ]),
-}).annotate({ identifier: "GlobalEvent" })
-
-export const GlobalUpgradeInput = Schema.Struct({
-  target: Schema.String.check(
-    Schema.makeFilter((value) => (semver.valid(value) === null ? "Expected a semantic version" : undefined)),
-  ),
-})
-
-const GlobalUpgradeResult = Schema.Union([
-  Schema.Struct({
-    success: Schema.Literal(true),
-    version: Schema.String,
-  }),
-  Schema.Struct({
-    success: Schema.Literal(false),
-    error: Schema.String,
-  }),
-])
-
-export const GlobalPaths = {
-  health: "/global/health",
-  event: "/global/event",
-  config: "/global/config",
-  dispose: "/global/dispose",
-  upgrade: "/global/upgrade",
-} as const
-
-export const GlobalApi = HttpApi.make("global").add(
-  HttpApiGroup.make("global")
-    .add(
-      HttpApiEndpoint.get("health", GlobalPaths.health, {
-        success: described(GlobalHealth, "Health information"),
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "global.health",
-          summary: "Get health",
-          description: "Get health information about the OpenCode server.",
-        }),
-      ),
-      HttpApiEndpoint.get("event", GlobalPaths.event, {
-        success: GlobalEventSchema,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "global.event",
-          summary: "Get global events",
-          description: "Subscribe to global events from the OpenCode system using server-sent events.",
-        }),
-      ),
-      HttpApiEndpoint.get("configGet", GlobalPaths.config, {
-        success: described(ConfigV1.Info, "Get global config info"),
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "global.config.get",
-          summary: "Get global configuration",
-          description: "Retrieve the current global OpenCode configuration settings and preferences.",
-        }),
-      ),
-      HttpApiEndpoint.patch("configUpdate", GlobalPaths.config, {
-        payload: ConfigV1.Info,
-        success: described(ConfigV1.Info, "Successfully updated global config"),
-        error: HttpApiError.BadRequest,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "global.config.update",
-          summary: "Update global configuration",
-          description: "Update global OpenCode configuration settings and preferences.",
-        }),
-      ),
-      HttpApiEndpoint.post("dispose", GlobalPaths.dispose, {
-        success: described(Schema.Boolean, "Global disposed"),
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "global.dispose",
-          summary: "Dispose instance",
-          description: "Clean up and dispose all OpenCode instances, releasing all resources.",
-        }),
-      ),
-      HttpApiEndpoint.post("upgrade", GlobalPaths.upgrade, {
-        payload: GlobalUpgradeInput,
-        success: described(GlobalUpgradeResult, "Upgrade result"),
-        error: HttpApiError.BadRequest,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "global.upgrade",
-          summary: "Upgrade opencode",
-          description: "Upgrade opencode to the specified version.",
-        }),
-      ),
-    )
-    .annotateMerge(OpenApi.annotations({ title: "global", description: "Global server routes." })),
-)

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

@@ -1,206 +0,0 @@
-import { Agent } from "@/agent/agent"
-import { Command } from "@/command"
-import { Format } from "@/format"
-import { LSP } from "@/lsp/lsp"
-import { Vcs } from "@/project/vcs"
-import { Skill } from "@/skill"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { Authorization } from "../middleware/authorization"
-import { InstanceContextMiddleware } from "../middleware/instance-context"
-import {
-  WorkspaceRoutingMiddleware,
-  WorkspaceRoutingQuery,
-  WorkspaceRoutingQueryFields,
-} from "../middleware/workspace-routing"
-import { described } from "./metadata"
-
-const PathInfo = Schema.Struct({
-  home: Schema.String,
-  state: Schema.String,
-  config: Schema.String,
-  worktree: Schema.String,
-  directory: Schema.String,
-}).annotate({ identifier: "Path" })
-
-export const VcsDiffQuery = Schema.Struct({
-  ...WorkspaceRoutingQueryFields,
-  mode: Vcs.Mode,
-  context: Schema.optional(Schema.NumberFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0))),
-})
-
-export class ApiVcsApplyError extends Schema.ErrorClass<ApiVcsApplyError>("VcsApplyError")(
-  {
-    name: Schema.Literal("VcsApplyError"),
-    data: Schema.Struct({
-      message: Schema.String,
-      reason: Schema.Literals(["non-git", "not-clean"]),
-    }),
-  },
-  { httpApiStatus: 400 },
-) {}
-
-export const InstancePaths = {
-  dispose: "/instance/dispose",
-  path: "/path",
-  vcs: "/vcs",
-  vcsStatus: "/vcs/status",
-  vcsDiff: "/vcs/diff",
-  vcsDiffRaw: "/vcs/diff/raw",
-  vcsApply: "/vcs/apply",
-  command: "/command",
-  agent: "/agent",
-  skill: "/skill",
-  lsp: "/lsp",
-  formatter: "/formatter",
-} as const
-
-export const InstanceApi = HttpApi.make("instance")
-  .add(
-    HttpApiGroup.make("instance")
-      .add(
-        HttpApiEndpoint.post("dispose", InstancePaths.dispose, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Boolean, "Instance disposed"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "instance.dispose",
-            summary: "Dispose instance",
-            description: "Clean up and dispose the current OpenCode instance, releasing all resources.",
-          }),
-        ),
-        HttpApiEndpoint.get("path", InstancePaths.path, {
-          query: WorkspaceRoutingQuery,
-          success: PathInfo,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "path.get",
-            summary: "Get paths",
-            description:
-              "Retrieve the current working directory and related path information for the OpenCode instance.",
-          }),
-        ),
-        HttpApiEndpoint.get("vcs", InstancePaths.vcs, {
-          query: WorkspaceRoutingQuery,
-          success: described(Vcs.Info, "VCS info"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "vcs.get",
-            summary: "Get VCS info",
-            description:
-              "Retrieve version control system (VCS) information for the current project, such as git branch.",
-          }),
-        ),
-        HttpApiEndpoint.get("vcsStatus", InstancePaths.vcsStatus, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(Vcs.FileStatus), "VCS status"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "vcs.status",
-            summary: "Get VCS status",
-            description: "Retrieve changed files in the current working tree without patches.",
-          }),
-        ),
-        HttpApiEndpoint.get("vcsDiff", InstancePaths.vcsDiff, {
-          query: VcsDiffQuery,
-          success: described(Schema.Array(Vcs.FileDiff), "VCS diff"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "vcs.diff",
-            summary: "Get VCS diff",
-            description: "Retrieve the current git diff for the working tree or against the default branch.",
-          }),
-        ),
-        HttpApiEndpoint.get("vcsDiffRaw", InstancePaths.vcsDiffRaw, {
-          query: WorkspaceRoutingQuery,
-          success: described(
-            Schema.String.pipe(HttpApiSchema.asText({ contentType: "text/x-diff; charset=utf-8" })),
-            "Raw VCS diff",
-          ),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "vcs.diff.raw",
-            summary: "Get raw VCS diff",
-            description: "Retrieve a raw patch for current uncommitted changes.",
-          }),
-        ),
-        HttpApiEndpoint.post("vcsApply", InstancePaths.vcsApply, {
-          query: WorkspaceRoutingQuery,
-          payload: Vcs.ApplyInput,
-          success: described(Vcs.ApplyResult, "VCS patch applied"),
-          error: ApiVcsApplyError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "vcs.apply",
-            summary: "Apply VCS patch",
-            description: "Apply a raw patch to the current working tree.",
-          }),
-        ),
-        HttpApiEndpoint.get("command", InstancePaths.command, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(Command.Info), "List of commands"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "command.list",
-            summary: "List commands",
-            description: "Get a list of all available commands in the OpenCode system.",
-          }),
-        ),
-        HttpApiEndpoint.get("agent", InstancePaths.agent, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(Agent.Info), "List of agents"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "app.agents",
-            summary: "List agents",
-            description: "Get a list of all available AI agents in the OpenCode system.",
-          }),
-        ),
-        HttpApiEndpoint.get("skill", InstancePaths.skill, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(Skill.Info), "List of skills"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "app.skills",
-            summary: "List skills",
-            description: "Get a list of all available skills in the OpenCode system.",
-          }),
-        ),
-        HttpApiEndpoint.get("lsp", InstancePaths.lsp, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(LSP.Status), "LSP server status"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "lsp.status",
-            summary: "Get LSP status",
-            description: "Get LSP server status",
-          }),
-        ),
-        HttpApiEndpoint.get("formatter", InstancePaths.formatter, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(Format.Status), "Formatter status"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "formatter.status",
-            summary: "Get formatter status",
-            description: "Get formatter status",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "instance",
-          description: "Experimental HttpApi instance read 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/mcp.ts

@@ -1,156 +0,0 @@
-import { MCP } from "@/mcp"
-import { ConfigMCPV1 } from "@soraacode/core/v1/config/mcp"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { McpServerNotFoundError } from "../errors"
-import { Authorization } from "../middleware/authorization"
-import { InstanceContextMiddleware } from "../middleware/instance-context"
-import { WorkspaceRoutingMiddleware, WorkspaceRoutingQuery } from "../middleware/workspace-routing"
-import { described } from "./metadata"
-
-export const AddPayload = Schema.Struct({
-  name: Schema.String,
-  config: ConfigMCPV1.Info,
-})
-
-export const StatusMap = Schema.Record(Schema.String, MCP.Status)
-export const AuthStartResponse = Schema.Struct({
-  authorizationUrl: Schema.String,
-  oauthState: Schema.String,
-})
-export const AuthCallbackPayload = Schema.Struct({
-  code: Schema.String,
-})
-export const AuthRemoveResponse = Schema.Struct({
-  success: Schema.Literal(true),
-})
-export class UnsupportedOAuthError extends Schema.ErrorClass<UnsupportedOAuthError>("McpUnsupportedOAuthError")(
-  { error: Schema.String },
-  { httpApiStatus: 400 },
-) {}
-
-export const McpPaths = {
-  status: "/mcp",
-  auth: "/mcp/:name/auth",
-  authCallback: "/mcp/:name/auth/callback",
-  authAuthenticate: "/mcp/:name/auth/authenticate",
-  connect: "/mcp/:name/connect",
-  disconnect: "/mcp/:name/disconnect",
-} as const
-
-export const McpApi = HttpApi.make("mcp")
-  .add(
-    HttpApiGroup.make("mcp")
-      .add(
-        HttpApiEndpoint.get("status", McpPaths.status, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Record(Schema.String, MCP.Status), "MCP server status"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "mcp.status",
-            summary: "Get MCP status",
-            description: "Get the status of all Model Context Protocol (MCP) servers.",
-          }),
-        ),
-        HttpApiEndpoint.post("add", McpPaths.status, {
-          query: WorkspaceRoutingQuery,
-          payload: AddPayload,
-          success: described(StatusMap, "MCP server added successfully"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "mcp.add",
-            summary: "Add MCP server",
-            description: "Dynamically add a new Model Context Protocol (MCP) server to the system.",
-          }),
-        ),
-        HttpApiEndpoint.post("authStart", McpPaths.auth, {
-          params: { name: Schema.String },
-          query: WorkspaceRoutingQuery,
-          success: described(AuthStartResponse, "OAuth flow started"),
-          error: [UnsupportedOAuthError, McpServerNotFoundError],
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "mcp.auth.start",
-            summary: "Start MCP OAuth",
-            description: "Start OAuth authentication flow for a Model Context Protocol (MCP) server.",
-          }),
-        ),
-        HttpApiEndpoint.post("authCallback", McpPaths.authCallback, {
-          params: { name: Schema.String },
-          query: WorkspaceRoutingQuery,
-          payload: AuthCallbackPayload,
-          success: described(MCP.Status, "OAuth authentication completed"),
-          error: [HttpApiError.BadRequest, McpServerNotFoundError],
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "mcp.auth.callback",
-            summary: "Complete MCP OAuth",
-            description:
-              "Complete OAuth authentication for a Model Context Protocol (MCP) server using the authorization code.",
-          }),
-        ),
-        HttpApiEndpoint.post("authAuthenticate", McpPaths.authAuthenticate, {
-          params: { name: Schema.String },
-          query: WorkspaceRoutingQuery,
-          success: described(MCP.Status, "OAuth authentication completed"),
-          error: [UnsupportedOAuthError, McpServerNotFoundError],
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "mcp.auth.authenticate",
-            summary: "Authenticate MCP OAuth",
-            description: "Start OAuth flow and wait for callback (opens browser).",
-          }),
-        ),
-        HttpApiEndpoint.delete("authRemove", McpPaths.auth, {
-          params: { name: Schema.String },
-          query: WorkspaceRoutingQuery,
-          success: described(AuthRemoveResponse, "OAuth credentials removed"),
-          error: McpServerNotFoundError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "mcp.auth.remove",
-            summary: "Remove MCP OAuth",
-            description: "Remove OAuth credentials for an MCP server.",
-          }),
-        ),
-        HttpApiEndpoint.post("connect", McpPaths.connect, {
-          params: { name: Schema.String },
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Boolean, "MCP server connected successfully"),
-          error: McpServerNotFoundError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "mcp.connect",
-            description: "Connect an MCP server.",
-          }),
-        ),
-        HttpApiEndpoint.post("disconnect", McpPaths.disconnect, {
-          params: { name: Schema.String },
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Boolean, "MCP server disconnected successfully"),
-          error: McpServerNotFoundError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "mcp.disconnect",
-            description: "Disconnect an MCP server.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "mcp",
-          description: "Experimental HttpApi MCP 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/metadata.ts

@@ -1,18 +0,0 @@
-import { Schema } from "effect"
-import { OpenApi } from "effect/unstable/httpapi"
-
-export function described<S extends Schema.Top>(schema: S, description: string): S {
-  return schema.annotate({ description }) as S
-}
-
-export function responseDescription(description: string) {
-  return OpenApi.annotations({
-    transform: (operation) => {
-      const response = operation.responses?.["200"]
-      if (response && typeof response === "object" && "description" in response) {
-        response.description = description
-      }
-      return operation
-    },
-  })
-}

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

@@ -1,61 +0,0 @@
-import { PermissionV1 } from "@soraacode/core/v1/permission"
-import { Permission } from "@/permission"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { PermissionNotFoundError } 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 = "/permission"
-const ReplyPayload = Schema.Struct({
-  reply: PermissionV1.Reply,
-  message: Schema.optional(Schema.String),
-})
-
-export const PermissionApi = HttpApi.make("permission")
-  .add(
-    HttpApiGroup.make("permission")
-      .add(
-        HttpApiEndpoint.get("list", root, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(PermissionV1.Request), "List of pending permissions"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "permission.list",
-            summary: "List pending permissions",
-            description: "Get all pending permission requests across all sessions.",
-          }),
-        ),
-        HttpApiEndpoint.post("reply", `${root}/:requestID/reply`, {
-          params: { requestID: PermissionV1.ID },
-          query: WorkspaceRoutingQuery,
-          payload: ReplyPayload,
-          success: described(Schema.Boolean, "Permission processed successfully"),
-          error: [HttpApiError.BadRequest, PermissionNotFoundError],
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "permission.reply",
-            summary: "Respond to permission request",
-            description: "Approve or deny a permission request from the AI assistant.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "permission",
-          description: "Experimental HttpApi permission 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/project-copy.ts

@@ -1,32 +0,0 @@
-import { ProjectV2 } from "@soraacode/core/project"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { Authorization } from "../middleware/authorization"
-import { InstanceContextMiddleware } from "../middleware/instance-context"
-import { WorkspaceRoutingMiddleware, WorkspaceRoutingQuery } from "../middleware/workspace-routing"
-
-export const GenerateNamePayload = Schema.Struct({
-  context: Schema.optional(Schema.String),
-})
-
-export const ProjectCopyApi = HttpApi.make("projectCopyName").add(
-  HttpApiGroup.make("projectCopyName")
-    .add(
-      HttpApiEndpoint.post("generateName", "/experimental/project/:projectID/copy/generate-name", {
-        params: { projectID: ProjectV2.ID },
-        query: WorkspaceRoutingQuery,
-        payload: GenerateNamePayload,
-        success: Schema.Struct({ name: Schema.String }),
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "experimental.projectCopy.generateName",
-          summary: "Generate project copy name",
-          description: "Generate a short name for a project copy from task context.",
-        }),
-      ),
-    )
-    .annotateMerge(OpenApi.annotations({ title: "projectCopy", description: "Project copy naming routes." }))
-    .middleware(InstanceContextMiddleware)
-    .middleware(WorkspaceRoutingMiddleware)
-    .middleware(Authorization),
-)