@opencode-ai/protocol 0.0.0-dev-17471

package/dist/groups/integration.js

@@ -0,0 +1,149 @@
+import { Integration } from "@opencode-ai/schema/integration";
+import { Location } from "@opencode-ai/schema/location";
+import { Form } from "@opencode-ai/schema/form";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { InvalidRequestError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const IntegrationGroup = HttpApiGroup.make("server.integration")
+    .add(HttpApiEndpoint.get("integration.list", "/api/integration", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Integration.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.list",
+    summary: "List integrations",
+    description: "Retrieve available integrations and their authentication methods.",
+})))
+    .add(HttpApiEndpoint.get("integration.get", "/api/integration/:integrationID", {
+    params: { integrationID: Integration.ID },
+    query: LocationQuery,
+    success: Location.response(Schema.UndefinedOr(Integration.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.get",
+    summary: "Get integration",
+    description: "Retrieve one integration and its authentication methods.",
+})))
+    .add(HttpApiEndpoint.post("integration.wellknown.add", "/api/experimental/integration/wellknown", {
+    query: LocationQuery,
+    payload: Schema.Struct({ url: Schema.String }),
+    success: HttpApiSchema.NoContent,
+    error: InvalidRequestError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.experimental.integration.wellknown.add",
+    summary: "Add wellknown integration",
+    description: "Discover and persist an experimental wellknown integration source.",
+})))
+    .add(HttpApiEndpoint.post("integration.connect.key", "/api/integration/:integrationID/connect/key", {
+    params: { integrationID: Integration.ID },
+    query: LocationQuery,
+    payload: Schema.Struct({
+        key: Schema.String,
+        answer: Schema.optional(Form.Answer),
+        label: Schema.optional(Schema.String),
+    }),
+    success: HttpApiSchema.NoContent,
+    error: InvalidRequestError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.connect.key",
+    summary: "Connect with key",
+    description: "Run a key authentication method and store the resulting credential.",
+})))
+    .add(HttpApiEndpoint.post("integration.oauth.connect", "/api/integration/:integrationID/connect/oauth", {
+    params: { integrationID: Integration.ID },
+    query: LocationQuery,
+    payload: Schema.Struct({
+        methodID: Integration.MethodID,
+        answer: Schema.optional(Form.Answer),
+        label: Schema.optional(Schema.String),
+    }),
+    success: Location.response(Integration.Attempt),
+    error: InvalidRequestError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.oauth.connect",
+    summary: "Begin OAuth connection",
+    description: "Start an OAuth attempt and return the authorization details.",
+})))
+    .add(HttpApiEndpoint.get("integration.oauth.status", "/api/integration/:integrationID/connect/oauth/:attemptID", {
+    params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
+    query: LocationQuery,
+    success: Location.response(Integration.AttemptStatus),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.oauth.status",
+    summary: "Get OAuth attempt status",
+    description: "Poll the current status of an OAuth attempt.",
+})))
+    .add(HttpApiEndpoint.post("integration.oauth.complete", "/api/integration/:integrationID/connect/oauth/:attemptID/complete", {
+    params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
+    query: LocationQuery,
+    payload: Schema.Struct({ code: Schema.optional(Schema.String) }),
+    success: HttpApiSchema.NoContent,
+    error: InvalidRequestError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.oauth.complete",
+    summary: "Complete OAuth connection",
+    description: "Complete a code-based OAuth attempt and store the resulting credential.",
+})))
+    .add(HttpApiEndpoint.delete("integration.oauth.cancel", "/api/integration/:integrationID/connect/oauth/:attemptID", {
+    params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.oauth.cancel",
+    summary: "Cancel OAuth connection",
+    description: "Cancel an OAuth attempt and release its resources.",
+})))
+    .add(HttpApiEndpoint.post("integration.command.connect", "/api/integration/:integrationID/connect/command", {
+    params: { integrationID: Integration.ID },
+    query: LocationQuery,
+    payload: Schema.Struct({
+        methodID: Integration.MethodID,
+        label: Schema.optional(Schema.String),
+    }),
+    success: Location.response(Integration.CommandAttempt),
+    error: InvalidRequestError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.command.connect",
+    summary: "Begin command connection",
+    description: "Start a command authentication attempt.",
+})))
+    .add(HttpApiEndpoint.get("integration.command.status", "/api/integration/:integrationID/connect/command/:attemptID", {
+    params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
+    query: LocationQuery,
+    success: Location.response(Integration.CommandAttemptStatus),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.command.status",
+    summary: "Get command attempt status",
+    description: "Poll the current status and output of a command authentication attempt.",
+})))
+    .add(HttpApiEndpoint.delete("integration.command.cancel", "/api/integration/:integrationID/connect/command/:attemptID", {
+    params: { integrationID: Integration.ID, attemptID: Integration.AttemptID },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.integration.command.cancel",
+    summary: "Cancel command connection",
+    description: "Cancel a command authentication attempt and terminate its process.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "integration", description: "Integration discovery and authentication routes." }));

package/dist/groups/location.d.ts

@@ -0,0 +1,16 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const LocationQuery: Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>;
+export declare const locationQueryOpenApi: import("effect/Context").Context<never>;
+export declare const LocationGroup: HttpApiGroup.HttpApiGroup<"server.location", HttpApiEndpoint.HttpApiEndpoint<"location.get", "GET", "/api/location", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<typeof Location.Info>, never, never, never>, false>;

package/dist/groups/location.js

@@ -0,0 +1,34 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+export const LocationQuery = Schema.Struct({
+    location: Schema.optional(Schema.Struct({
+        directory: Schema.optional(Schema.String),
+        workspace: Schema.optional(Schema.String),
+    })),
+}).annotate({ identifier: "LocationQuery" });
+export const locationQueryOpenApi = OpenApi.annotations({
+    transform: (operation) => {
+        const parameters = operation.parameters;
+        if (!Array.isArray(parameters))
+            return operation;
+        return {
+            ...operation,
+            parameters: parameters.map((parameter) => parameter?.name === "location" && parameter?.in === "query"
+                ? { ...parameter, style: "deepObject", explode: true }
+                : parameter),
+        };
+    },
+});
+export const LocationGroup = HttpApiGroup.make("server.location")
+    .add(HttpApiEndpoint.get("location.get", "/api/location", {
+    query: LocationQuery,
+    success: Location.Info,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.location.get",
+    summary: "Get location",
+    description: "Resolve the requested location or the server default location.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "location" }));

package/dist/groups/mcp.d.ts

@@ -0,0 +1,82 @@
+import { Mcp } from "@opencode-ai/schema/mcp";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { McpServerNotFoundError } from "../errors.js";
+export declare const McpGroup: HttpApiGroup.HttpApiGroup<"server.mcp", HttpApiEndpoint.HttpApiEndpoint<"mcp.list", "GET", "/api/mcp", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly status: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
+            readonly status: Schema.Literal<"connected">;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"pending">;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"disabled">;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"failed">;
+            readonly error: Schema.String;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"needs_auth">;
+        }>]>;
+        readonly integrationID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Integration.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Integration.ID">>, never, never>;
+    }>>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.add", "PUT", "/api/mcp/:server", Schema.toCodecStringTree<Schema.Struct<{
+    server: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+    readonly config: Schema.toTaggedUnion<"type", readonly [typeof Mcp.LocalConfig, typeof Mcp.RemoteConfig]>;
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.remove", "DELETE", "/api/mcp/:server", Schema.toCodecStringTree<Schema.Struct<{
+    server: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.connect", "POST", "/api/mcp/:server/connect", Schema.toCodecStringTree<Schema.Struct<{
+    server: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.disconnect", "POST", "/api/mcp/:server/disconnect", Schema.toCodecStringTree<Schema.Struct<{
+    server: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof McpServerNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"mcp.resource.catalog", "GET", "/api/mcp/resource", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly workspace: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.Struct<{
+        readonly resources: Schema.$Array<Schema.Struct<{
+            readonly server: Schema.String;
+            readonly name: Schema.String;
+            readonly uri: Schema.String;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>;
+        readonly templates: Schema.$Array<Schema.Struct<{
+            readonly server: Schema.String;
+            readonly name: Schema.String;
+            readonly uriTemplate: Schema.String;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>;
+    }>;
+}>>, never, never, never>, false>;

package/dist/groups/mcp.js

@@ -0,0 +1,78 @@
+import { Mcp } from "@opencode-ai/schema/mcp";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { McpServerNotFoundError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const McpGroup = HttpApiGroup.make("server.mcp")
+    .add(HttpApiEndpoint.get("mcp.list", "/api/mcp", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Mcp.Server)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.mcp.list",
+    summary: "List MCP servers",
+    description: "Retrieve configured MCP servers and their connection status.",
+})))
+    .add(HttpApiEndpoint.put("mcp.add", "/api/mcp/:server", {
+    params: { server: Schema.String },
+    query: LocationQuery,
+    // Wrapped in a struct because the client codegen flattens payload fields and cannot
+    // represent a top-level union payload.
+    payload: Schema.Struct({ config: Mcp.ServerConfig }),
+    success: HttpApiSchema.NoContent,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.mcp.add",
+    summary: "Add MCP server",
+    description: "Add an MCP server at runtime or replace an existing one, connecting it immediately.",
+})))
+    .add(HttpApiEndpoint.delete("mcp.remove", "/api/mcp/:server", {
+    params: { server: Schema.String },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+    error: McpServerNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.mcp.remove",
+    summary: "Remove MCP server",
+    description: "Stop an MCP server and remove it from the runtime set until restart.",
+})))
+    .add(HttpApiEndpoint.post("mcp.connect", "/api/mcp/:server/connect", {
+    params: { server: Schema.String },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+    error: McpServerNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.mcp.connect",
+    summary: "Connect MCP server",
+    description: "Connect an MCP server at runtime, overriding a disabled configuration until restart.",
+})))
+    .add(HttpApiEndpoint.post("mcp.disconnect", "/api/mcp/:server/disconnect", {
+    params: { server: Schema.String },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+    error: McpServerNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.mcp.disconnect",
+    summary: "Disconnect MCP server",
+    description: "Disconnect an MCP server at runtime, removing its tools until reconnected.",
+})))
+    .add(HttpApiEndpoint.get("mcp.resource.catalog", "/api/mcp/resource", {
+    query: LocationQuery,
+    success: Location.response(Mcp.ResourceCatalog),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.mcp.resource.catalog",
+    summary: "List MCP resources",
+    description: "Retrieve resources and resource templates from connected MCP servers.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "mcp", description: "MCP server and resource routes." }));