onlycode 1.18.0 → 1.19.0

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 "@opencode-ai/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 "@opencode-ai/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),
-)

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

@@ -1,93 +0,0 @@
-import { Project } from "@/project/project"
-import { ProjectV2 } from "@opencode-ai/core/project"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { ProjectNotFoundError } 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 = "/project"
-const UpdatePayload = Schema.Struct({
-  name: Schema.optional(Schema.String),
-  icon: Schema.optional(Project.Info.fields.icon),
-  commands: Schema.optional(Project.Info.fields.commands),
-})
-
-export const ProjectApi = HttpApi.make("project")
-  .add(
-    HttpApiGroup.make("project")
-      .add(
-        HttpApiEndpoint.get("list", root, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(Project.Info), "List of projects"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "project.list",
-            summary: "List all projects",
-            description: "Get a list of projects that have been opened with OnlyCode.",
-          }),
-        ),
-        HttpApiEndpoint.get("current", `${root}/current`, {
-          query: WorkspaceRoutingQuery,
-          success: described(Project.Info, "Current project information"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "project.current",
-            summary: "Get current project",
-            description: "Retrieve the currently active project that OnlyCode is working with.",
-          }),
-        ),
-        HttpApiEndpoint.post("initGit", `${root}/git/init`, {
-          query: WorkspaceRoutingQuery,
-          success: described(Project.Info, "Project information after git initialization"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "project.initGit",
-            summary: "Initialize git repository",
-            description: "Create a git repository for the current project and return the refreshed project info.",
-          }),
-        ),
-        HttpApiEndpoint.patch("update", `${root}/:projectID`, {
-          params: { projectID: ProjectV2.ID },
-          query: WorkspaceRoutingQuery,
-          payload: UpdatePayload,
-          success: described(Project.Info, "Updated project information"),
-          error: [HttpApiError.BadRequest, ProjectNotFoundError],
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "project.update",
-            summary: "Update project",
-            description: "Update project properties such as name, icon, and commands.",
-          }),
-        ),
-        HttpApiEndpoint.get("directories", `${root}/:projectID/directories`, {
-          params: { projectID: ProjectV2.ID },
-          query: WorkspaceRoutingQuery,
-          success: described(ProjectV2.Directories, "Project directories"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "project.directories",
-            summary: "List project directories",
-            description: "List known local absolute directories for a project.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "project",
-          description: "Experimental HttpApi project 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/provider.ts

@@ -1,101 +0,0 @@
-import { ProviderAuth } from "@/provider/auth"
-import { Provider } from "@/provider/provider"
-
-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"
-import { described } from "./metadata"
-import { ProviderV2 } from "@opencode-ai/core/provider"
-
-const root = "/provider"
-
-const ProviderAuthErrorName = Schema.Union([
-  Schema.Literal("BadRequest"),
-  Schema.Literal("ProviderAuthOauthMissing"),
-  Schema.Literal("ProviderAuthOauthCodeMissing"),
-  Schema.Literal("ProviderAuthOauthCallbackFailed"),
-  Schema.Literal("ProviderAuthValidationFailed"),
-])
-export class ProviderAuthApiError extends Schema.ErrorClass<ProviderAuthApiError>("ProviderAuthError")(
-  {
-    name: ProviderAuthErrorName,
-    data: Schema.Struct({
-      providerID: Schema.optional(ProviderV2.ID),
-      field: Schema.optional(Schema.String),
-      message: Schema.optional(Schema.String),
-      kind: Schema.optional(Schema.String),
-    }),
-  },
-  { httpApiStatus: 400 },
-) {}
-
-export const ProviderApi = HttpApi.make("provider")
-  .add(
-    HttpApiGroup.make("provider")
-      .add(
-        HttpApiEndpoint.get("list", root, {
-          query: WorkspaceRoutingQuery,
-          success: described(Provider.ListResult, "List of providers"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "provider.list",
-            summary: "List providers",
-            description: "Get a list of all available AI providers, including both available and connected ones.",
-          }),
-        ),
-        HttpApiEndpoint.get("auth", `${root}/auth`, {
-          query: WorkspaceRoutingQuery,
-          success: described(ProviderAuth.Methods, "Provider auth methods"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "provider.auth",
-            summary: "Get provider auth methods",
-            description: "Retrieve available authentication methods for all AI providers.",
-          }),
-        ),
-        HttpApiEndpoint.post("authorize", `${root}/:providerID/oauth/authorize`, {
-          params: { providerID: ProviderV2.ID },
-          query: WorkspaceRoutingQuery,
-          payload: ProviderAuth.AuthorizeInput,
-          success: described(Schema.UndefinedOr(ProviderAuth.Authorization), "Authorization URL and method"),
-          error: ProviderAuthApiError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "provider.oauth.authorize",
-            summary: "Start OAuth authorization",
-            description: "Start the OAuth authorization flow for a provider.",
-          }),
-        ),
-        HttpApiEndpoint.post("callback", `${root}/:providerID/oauth/callback`, {
-          params: { providerID: ProviderV2.ID },
-          query: WorkspaceRoutingQuery,
-          payload: ProviderAuth.CallbackInput,
-          success: described(Schema.Boolean, "OAuth callback processed successfully"),
-          error: ProviderAuthApiError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "provider.oauth.callback",
-            summary: "Handle OAuth callback",
-            description: "Handle the OAuth callback from a provider after user authorization.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "provider",
-          description: "Experimental HttpApi provider 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/pty.ts

@@ -1,172 +0,0 @@
-import { Pty } from "@opencode-ai/core/pty"
-import { PtyTicket } from "@opencode-ai/core/pty/ticket"
-import { PtyID } from "@opencode-ai/core/pty/schema"
-import { PTY_CONNECT_TICKET_QUERY } from "@/server/shared/pty-ticket"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { Authorization, PtyConnectAuthorization } from "../middleware/authorization"
-import { InstanceContextMiddleware } from "../middleware/instance-context"
-import {
-  WorkspaceRoutingMiddleware,
-  WorkspaceRoutingQuery,
-  WorkspaceRoutingQueryFields,
-} from "../middleware/workspace-routing"
-import { PtyForbiddenError, PtyNotFoundError } from "../errors"
-import { described } from "./metadata"
-
-const root = "/pty"
-export const Params = Schema.Struct({ ptyID: PtyID })
-export const CursorQuery = Schema.Struct({
-  ...WorkspaceRoutingQueryFields,
-  cursor: Schema.optional(Schema.String),
-})
-export const ShellItem = Schema.Struct({
-  path: Schema.String,
-  name: Schema.String,
-  acceptable: Schema.Boolean,
-})
-
-export const PtyPaths = {
-  shells: `${root}/shells`,
-  list: root,
-  create: root,
-  get: `${root}/:ptyID`,
-  update: `${root}/:ptyID`,
-  remove: `${root}/:ptyID`,
-  connectToken: `${root}/:ptyID/connect-token`,
-  connect: `${root}/:ptyID/connect`,
-} as const
-
-export const PtyApi = HttpApi.make("pty")
-  .add(
-    HttpApiGroup.make("pty")
-      .add(
-        HttpApiEndpoint.get("shells", PtyPaths.shells, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(ShellItem), "List of shells"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "pty.shells",
-            summary: "List available shells",
-            description: "Get a list of available shells on the system.",
-          }),
-        ),
-        HttpApiEndpoint.get("list", PtyPaths.list, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(Pty.Info), "List of sessions"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "pty.list",
-            summary: "List PTY sessions",
-            description: "Get a list of all active pseudo-terminal (PTY) sessions managed by OnlyCode.",
-          }),
-        ),
-        HttpApiEndpoint.post("create", PtyPaths.create, {
-          query: WorkspaceRoutingQuery,
-          payload: Pty.CreateInput,
-          success: described(Pty.Info, "Created session"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "pty.create",
-            summary: "Create PTY session",
-            description: "Create a new pseudo-terminal (PTY) session for running shell commands and processes.",
-          }),
-        ),
-        HttpApiEndpoint.get("get", PtyPaths.get, {
-          params: { ptyID: PtyID },
-          query: WorkspaceRoutingQuery,
-          success: described(Pty.Info, "Session info"),
-          error: PtyNotFoundError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "pty.get",
-            summary: "Get PTY session",
-            description: "Retrieve detailed information about a specific pseudo-terminal (PTY) session.",
-          }),
-        ),
-        HttpApiEndpoint.put("update", PtyPaths.update, {
-          params: { ptyID: PtyID },
-          query: WorkspaceRoutingQuery,
-          payload: Pty.UpdateInput,
-          success: described(Pty.Info, "Updated session"),
-          error: [PtyNotFoundError, HttpApiError.BadRequest],
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "pty.update",
-            summary: "Update PTY session",
-            description: "Update properties of an existing pseudo-terminal (PTY) session.",
-          }),
-        ),
-        HttpApiEndpoint.delete("remove", PtyPaths.remove, {
-          params: { ptyID: PtyID },
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Boolean, "Session removed"),
-          error: PtyNotFoundError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "pty.remove",
-            summary: "Remove PTY session",
-            description: "Remove and terminate a specific pseudo-terminal (PTY) session.",
-          }),
-        ),
-        HttpApiEndpoint.post("connectToken", PtyPaths.connectToken, {
-          params: { ptyID: PtyID },
-          query: WorkspaceRoutingQuery,
-          success: described(PtyTicket.ConnectToken, "WebSocket connect token"),
-          error: [PtyForbiddenError, PtyNotFoundError],
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "pty.connectToken",
-            summary: "Create PTY WebSocket token",
-            description: "Create a short-lived ticket for opening a PTY WebSocket connection.",
-          }),
-        ),
-      )
-      .annotateMerge(OpenApi.annotations({ title: "pty", description: "Experimental HttpApi PTY 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.",
-    }),
-  )
-
-export const PtyConnectApi = HttpApi.make("pty-connect").add(
-  HttpApiGroup.make("pty-connect")
-    .add(
-      // Decode PTY connection query fields in the raw handler after checking
-      // existence, preserving the established empty-404 response ordering.
-      HttpApiEndpoint.get("connect", PtyPaths.connect, {
-        params: Params,
-        success: described(Schema.Boolean, "Connected session"),
-        error: [HttpApiError.Forbidden, HttpApiError.NotFound],
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "pty.connect",
-          summary: "Connect to PTY session",
-          description:
-            "Establish a WebSocket connection to interact with a pseudo-terminal (PTY) session in real-time.",
-          transform: (operation) => ({
-            ...operation,
-            parameters: [
-              ...(operation.parameters ?? []),
-              ...["directory", "workspace", "cursor", PTY_CONNECT_TICKET_QUERY].map((name) => ({
-                in: "query",
-                name,
-                schema: { type: "string" },
-              })),
-            ],
-          }),
-        }),
-      ),
-    )
-    .annotateMerge(OpenApi.annotations({ title: "pty", description: "PTY websocket route." }))
-    .middleware(InstanceContextMiddleware)
-    .middleware(WorkspaceRoutingMiddleware)
-    .middleware(PtyConnectAuthorization),
-)

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

@@ -1,12 +0,0 @@
-import { Schema, SchemaGetter } from "effect"
-
-export const QueryBoolean = Schema.Literals(["true", "false"]).pipe(
-  Schema.decodeTo(Schema.Boolean, {
-    decode: SchemaGetter.transform((value) => value === "true"),
-    encode: SchemaGetter.transform((value) => (value ? "true" : "false")),
-  }),
-)
-
-export const QueryBooleanOpenApi = {
-  anyOf: [{ type: "boolean" }, { type: "string", enum: ["true", "false"] }],
-}

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

@@ -1,74 +0,0 @@
-import { Question } from "@/question"
-import { QuestionID } from "@/question/schema"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { QuestionNotFoundError } 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 = "/question"
-const ReplyPayload = Schema.Struct({
-  answers: Schema.Array(Question.Answer).annotate({
-    description: "User answers in order of questions (each answer is an array of selected labels)",
-  }),
-})
-
-export const QuestionApi = HttpApi.make("question")
-  .add(
-    HttpApiGroup.make("question")
-      .add(
-        HttpApiEndpoint.get("list", root, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(Question.Request), "List of pending questions"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "question.list",
-            summary: "List pending questions",
-            description: "Get all pending question requests across all sessions.",
-          }),
-        ),
-        HttpApiEndpoint.post("reply", `${root}/:requestID/reply`, {
-          params: { requestID: QuestionID },
-          query: WorkspaceRoutingQuery,
-          payload: ReplyPayload,
-          success: described(Schema.Boolean, "Question answered successfully"),
-          error: [HttpApiError.BadRequest, QuestionNotFoundError],
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "question.reply",
-            summary: "Reply to question request",
-            description: "Provide answers to a question request from the AI assistant.",
-          }),
-        ),
-        HttpApiEndpoint.post("reject", `${root}/:requestID/reject`, {
-          params: { requestID: QuestionID },
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Boolean, "Question rejected successfully"),
-          error: [HttpApiError.BadRequest, QuestionNotFoundError],
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "question.reject",
-            summary: "Reject question request",
-            description: "Reject a question request from the AI assistant.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "question",
-          description: "Question routes.",
-        }),
-      )
-      .middleware(InstanceContextMiddleware)
-      .middleware(WorkspaceRoutingMiddleware)
-      .middleware(Authorization),
-  )
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "opencode HttpApi",
-      version: "0.0.1",
-      description: "Effect HttpApi surface for instance routes.",
-    }),
-  )