@opencode/protocol 0.0.0-beta-19275

package/dist/groups/shell.d.ts

@@ -0,0 +1,152 @@
+import { Location } from "@opencode/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { ShellNotFoundError } from "../errors.js";
+export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpApiEndpoint.HttpApiEndpoint<"shell.list", "GET", "/api/shell", 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 id: Schema.brand<Schema.String, "Shell.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
+        };
+        readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
+        readonly command: Schema.String;
+        readonly cwd: Schema.String;
+        readonly shell: Schema.String;
+        readonly file: Schema.String;
+        readonly pid: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly time: Schema.Struct<{
+            readonly started: Schema.Finite;
+            readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        }>;
+    }>>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.create", "POST", "/api/shell", never, 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 command: Schema.String;
+    readonly cwd: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly timeout: Schema.Int;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
+        };
+        readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
+        readonly command: Schema.String;
+        readonly cwd: Schema.String;
+        readonly shell: Schema.String;
+        readonly file: Schema.String;
+        readonly pid: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly time: Schema.Struct<{
+            readonly started: Schema.Finite;
+            readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        }>;
+    }>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.get", "GET", "/api/shell/:id", Schema.toCodecStringTree<Schema.Struct<{
+    id: Schema.brand<Schema.String, "Shell.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
+    };
+}>>, 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 id: Schema.brand<Schema.String, "Shell.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
+        };
+        readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
+        readonly command: Schema.String;
+        readonly cwd: Schema.String;
+        readonly shell: Schema.String;
+        readonly file: Schema.String;
+        readonly pid: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly time: Schema.Struct<{
+            readonly started: Schema.Finite;
+            readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        }>;
+    }>;
+}>>, Schema.toCodecJson<typeof ShellNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.timeout", "PATCH", "/api/shell/:id/timeout", Schema.toCodecStringTree<Schema.Struct<{
+    id: Schema.brand<Schema.String, "Shell.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
+    };
+}>>, 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 timeout: Schema.Int;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
+        };
+        readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
+        readonly command: Schema.String;
+        readonly cwd: Schema.String;
+        readonly shell: Schema.String;
+        readonly file: Schema.String;
+        readonly pid: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly time: Schema.Struct<{
+            readonly started: Schema.Finite;
+            readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
+        }>;
+    }>;
+}>>, Schema.toCodecJson<typeof ShellNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.output", "GET", "/api/shell/:id/output", Schema.toCodecStringTree<Schema.Struct<{
+    id: Schema.brand<Schema.String, "Shell.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
+    };
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    readonly cursor: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly limit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    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 output: Schema.String;
+        readonly cursor: Schema.Int;
+        readonly size: Schema.Int;
+        readonly truncated: Schema.Boolean;
+    }>;
+}>>, Schema.toCodecJson<typeof ShellNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.remove", "DELETE", "/api/shell/:id", Schema.toCodecStringTree<Schema.Struct<{
+    id: Schema.brand<Schema.String, "Shell.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
+    };
+}>>, 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 ShellNotFoundError>, never, never>, false>;

package/dist/groups/shell.js

@@ -0,0 +1,82 @@
+import { Shell } from "@opencode/schema/shell";
+import { Location } from "@opencode/schema/location";
+import { NonNegativeInt } from "@opencode/schema/schema";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { ShellNotFoundError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+const TimeoutInput = Schema.Struct({
+    timeout: NonNegativeInt,
+});
+export const ShellGroup = HttpApiGroup.make("server.shell")
+    .add(HttpApiEndpoint.get("shell.list", "/api/shell", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Shell.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.shell.list",
+    summary: "List running shell commands",
+    description: "List currently running shell commands for a location. Exited commands are not included.",
+})))
+    .add(HttpApiEndpoint.post("shell.create", "/api/shell", {
+    query: LocationQuery,
+    payload: Shell.CreateInput,
+    success: Location.response(Shell.Info),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.shell.create",
+    summary: "Run shell command",
+    description: "Spawn one non-interactive shell command for a location. Combined stdout/stderr is captured to a file pageable via output.",
+})))
+    .add(HttpApiEndpoint.get("shell.get", "/api/shell/:id", {
+    params: { id: Shell.ID },
+    query: LocationQuery,
+    success: Location.response(Shell.Info),
+    error: ShellNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.shell.get",
+    summary: "Get shell command",
+    description: "Get one shell command, including its status and exit code once exited.",
+})))
+    .add(HttpApiEndpoint.patch("shell.timeout", "/api/shell/:id/timeout", {
+    params: { id: Shell.ID },
+    query: LocationQuery,
+    payload: TimeoutInput,
+    success: Location.response(Shell.Info),
+    error: ShellNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.shell.timeout",
+    summary: "Update shell timeout",
+    description: "Replace a running shell command's timeout from now, or clear it with zero.",
+})))
+    .add(HttpApiEndpoint.get("shell.output", "/api/shell/:id/output", {
+    params: { id: Shell.ID },
+    query: Schema.Struct({ ...LocationQuery.fields, ...Shell.OutputInput.fields }),
+    success: Location.response(Shell.Output),
+    error: ShellNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.shell.output",
+    summary: "Read shell output",
+    description: "Page through captured combined output by absolute byte cursor.",
+})))
+    .add(HttpApiEndpoint.delete("shell.remove", "/api/shell/:id", {
+    params: { id: Shell.ID },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+    error: ShellNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.shell.remove",
+    summary: "Remove shell command",
+    description: "Terminate and remove one shell command and its retained output.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "shell", description: "Experimental location-scoped shell command routes." }));

package/dist/groups/skill.d.ts

@@ -0,0 +1,20 @@
+import { Location } from "@opencode/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const SkillGroup: HttpApiGroup.HttpApiGroup<"server.skill", HttpApiEndpoint.HttpApiEndpoint<"skill.list", "GET", "/api/skill", 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 id: Schema.brand<Schema.String, "Skill.ID">;
+        readonly name: Schema.brand<Schema.String, "Skill.Name">;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly slash: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly autoinvoke: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly location: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly content: Schema.String;
+    }>>;
+}>>, never, never, never>, false>;

package/dist/groups/skill.js

@@ -0,0 +1,20 @@
+import { Skill } from "@opencode/schema/skill";
+import { Location } from "@opencode/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const SkillGroup = HttpApiGroup.make("server.skill")
+    .add(HttpApiEndpoint.get("skill.list", "/api/skill", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Skill.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.skill.list",
+    summary: "List skills",
+    description: "Retrieve currently registered skills.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "skill",
+    description: "Experimental skill routes.",
+}));

package/dist/groups/vcs.d.ts

@@ -0,0 +1,70 @@
+import { Location } from "@opencode/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { ServiceUnavailableError } from "../errors.js";
+export declare const VcsGroup: HttpApiGroup.HttpApiGroup<"server.vcs", HttpApiEndpoint.HttpApiEndpoint<"vcs.get", "GET", "/api/vcs", 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 branch: Schema.Struct<{
+            readonly current: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>;
+    }>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.base", "GET", "/api/vcs/base", 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.NullOr<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly ref: Schema.String;
+        readonly source: Schema.Literals<readonly ["reflog", "default"]>;
+    }>>;
+}>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.status", "GET", "/api/vcs/status", 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 file: Schema.String;
+        readonly additions: Schema.Int;
+        readonly deletions: Schema.Int;
+        readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
+    }>>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.branches", "GET", "/api/vcs/branches", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly search: Schema.optional<Schema.String>;
+    readonly limit: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;
+    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.String>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.diff", "GET", "/api/vcs/diff", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly mode: Schema.Literals<readonly ["working", "branch", "committed"]>;
+    readonly base: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly context: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;
+    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 file: Schema.String;
+        readonly patch: Schema.String;
+        readonly additions: Schema.Int;
+        readonly deletions: Schema.Int;
+        readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
+    }>>;
+}>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never>, false>;

package/dist/groups/vcs.js

@@ -0,0 +1,76 @@
+import { FileDiff } from "@opencode/schema/file-diff";
+import { Location } from "@opencode/schema/location";
+import { NonNegativeInt, PositiveInt, optional } from "@opencode/schema/schema";
+import { Vcs } from "@opencode/schema/vcs";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+import { ServiceUnavailableError } from "../errors.js";
+const BranchesQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    search: Schema.optional(Schema.String),
+    limit: Schema.NumberFromString.pipe(Schema.decodeTo(PositiveInt), Schema.optional),
+});
+const DiffQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    mode: Vcs.Mode,
+    base: optional(Schema.String),
+    context: Schema.NumberFromString.pipe(Schema.decodeTo(NonNegativeInt), Schema.optional),
+});
+export const VcsGroup = HttpApiGroup.make("server.vcs")
+    .add(HttpApiEndpoint.get("vcs.get", "/api/vcs", {
+    query: LocationQuery,
+    success: Location.response(Vcs.Info),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.vcs.get",
+    summary: "VCS info",
+    description: "Get current and default branch information for the requested location.",
+})))
+    .add(HttpApiEndpoint.get("vcs.base", "/api/vcs/base", {
+    query: LocationQuery,
+    success: Location.response(Schema.NullOr(Vcs.Base)),
+    error: ServiceUnavailableError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.vcs.base",
+    summary: "VCS review base",
+    description: "Infer a local review base from named branch creation history, or the repository default only when currently on that branch. Returns null before the first commit or when the provider lacks base metadata; ambiguous Git history requires an explicit base on diff requests.",
+})))
+    .add(HttpApiEndpoint.get("vcs.status", "/api/vcs/status", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Vcs.FileStatus)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.vcs.status",
+    summary: "VCS status",
+    description: "List uncommitted working-copy changes relative to the requested location.",
+})))
+    .add(HttpApiEndpoint.get("vcs.branches", "/api/vcs/branches", {
+    query: BranchesQuery,
+    success: Location.response(Vcs.BranchList),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.vcs.branches",
+    summary: "VCS branches",
+    description: "List local and remote branches available at the requested location.",
+})))
+    .add(HttpApiEndpoint.get("vcs.diff", "/api/vcs/diff", {
+    query: DiffQuery,
+    success: Location.response(Schema.Array(FileDiff.Info)),
+    error: ServiceUnavailableError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.vcs.diff",
+    summary: "VCS diff",
+    description: "Diff HEAD to the working copy (working), the base merge-base to the working copy (branch), or the base merge-base to HEAD (committed). Omitting base preserves repository-default comparison; supplying it overrides the comparison without saving it.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "vcs",
+    description: "Location-scoped version control routes.",
+}));

package/dist/groups/websearch.d.ts

@@ -0,0 +1,28 @@
+import { Location } from "@opencode/schema/location";
+import { WebSearch } from "@opencode/schema/websearch";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+export declare const WebSearchGroup: HttpApiGroup.HttpApiGroup<"server.websearch", HttpApiEndpoint.HttpApiEndpoint<"websearch.providers", "GET", "/api/websearch/provider", 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 id: Schema.brand<Schema.String, "WebSearch.ID">;
+        readonly name: Schema.String;
+    }>>;
+}>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"websearch.query", "POST", "/api/websearch", never, 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 query: Schema.String;
+    readonly providerID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WebSearch.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "WebSearch.ID">>, never, never>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: typeof WebSearch.Response;
+}>>, Schema.toCodecJson<typeof InvalidRequestError | typeof ServiceUnavailableError>, never, never>, false>;

package/dist/groups/websearch.js

@@ -0,0 +1,34 @@
+import { Location } from "@opencode/schema/location";
+import { WebSearch } from "@opencode/schema/websearch";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const WebSearchGroup = HttpApiGroup.make("server.websearch")
+    .add(HttpApiEndpoint.get("websearch.providers", "/api/websearch/provider", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(WebSearch.Provider)),
+    error: ServiceUnavailableError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.websearch.providers",
+    summary: "List web search providers",
+    description: "Return the registered web search providers.",
+})))
+    .add(HttpApiEndpoint.post("websearch.query", "/api/websearch", {
+    query: LocationQuery,
+    payload: Schema.Struct(WebSearch.Input.fields),
+    success: Location.response(WebSearch.Response),
+    error: [InvalidRequestError, ServiceUnavailableError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.websearch.query",
+    summary: "Search the web",
+    description: "Run one web search through the selected provider. Specify a provider to override the configured default.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "websearch",
+    description: "Location-scoped web search routes.",
+}));

package/dist/groups/workspace.d.ts

@@ -0,0 +1,22 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { ConflictError, ProviderNotFoundError, UnknownError } from "../errors.js";
+export declare const WorkspaceGroup: HttpApiGroup.HttpApiGroup<"server.workspace", HttpApiEndpoint.HttpApiEndpoint<"workspace.create", "POST", "/api/workspace", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly id: Schema.optional<Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    }>;
+    readonly provider: Schema.String;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly data: Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    };
+}>>, Schema.toCodecJson<typeof ConflictError | typeof ProviderNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"workspace.destroy", "DELETE", "/api/workspace/:workspaceID", Schema.toCodecStringTree<Schema.Struct<{
+    workspaceID: Schema.brand<Schema.String, "Workspace.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+    };
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly destroyed: Schema.Boolean;
+}>>, Schema.toCodecJson<typeof UnknownError>, never, never>, false>;

package/dist/groups/workspace.js

@@ -0,0 +1,27 @@
+import { Workspace } from "@opencode/schema/workspace";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { ConflictError, ProviderNotFoundError, UnknownError } from "../errors.js";
+export const WorkspaceGroup = HttpApiGroup.make("server.workspace")
+    .add(HttpApiEndpoint.post("workspace.create", "/api/workspace", {
+    payload: Schema.Struct({
+        id: Workspace.ID.pipe(Schema.optional),
+        provider: Schema.String,
+    }),
+    success: Schema.Struct({ data: Workspace.ID }),
+    error: [ConflictError, ProviderNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.workspace.create",
+    summary: "Create workspace",
+    description: "Create a logical workspace. A caller-supplied ID is idempotent when retried with the same provider; reusing it with another provider returns a conflict.",
+})))
+    .add(HttpApiEndpoint.delete("workspace.destroy", "/api/workspace/:workspaceID", {
+    params: { workspaceID: Workspace.ID },
+    success: Workspace.DestroyResult,
+    error: UnknownError,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.workspace.destroy",
+    summary: "Destroy workspace",
+    description: "Make a workspace not exist. This operation is idempotent: an already-missing workspace succeeds with `destroyed: false`, while a workspace removed by this request returns `destroyed: true`.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "workspace", description: "Workspace lifecycle routes." }));

package/dist/groups/worktree.d.ts

@@ -0,0 +1,47 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+declare const WorktreeError_base: Schema.Class<WorktreeError, Schema.Struct<{
+    readonly name: Schema.Literal<"WorktreeError">;
+    readonly data: Schema.Struct<{
+        readonly message: Schema.String;
+        readonly forceRequired: Schema.optional<Schema.Boolean>;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorktreeError extends WorktreeError_base {
+}
+export declare const WorktreeGroup: HttpApiGroup.HttpApiGroup<"server.worktree", HttpApiEndpoint.HttpApiEndpoint<"worktree.list", "GET", "/api/worktree", 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.$Array<Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly strategy: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>>>, Schema.toCodecJson<typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.create", "POST", "/api/worktree", never, 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 strategy: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Trim, "Worktree.StrategyID">>>, Schema.optionalKey<Schema.brand<Schema.Trim, "Worktree.StrategyID">>, never, never>;
+    readonly from: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
+    readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Trim>>, Schema.optionalKey<Schema.Trim>, never, never>;
+    readonly directory: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
+    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>>, Schema.toCodecJson<typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.remove", "DELETE", "/api/worktree", never, 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 directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly force: Schema.Boolean;
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.refresh", "POST", "/api/worktree/refresh", 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<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof WorktreeError>, never, never>, false>;
+export {};