@opencode-ai/protocol 0.0.0-dev-17471

package/dist/groups/shell.js

@@ -0,0 +1,82 @@
+import { Shell } from "@opencode-ai/schema/shell";
+import { Location } from "@opencode-ai/schema/location";
+import { NonNegativeInt } from "@opencode-ai/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-ai/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-ai/schema/skill";
+import { Location } from "@opencode-ai/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,46 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+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.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.diff", "GET", "/api/vcs/diff", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly mode: Schema.Literals<readonly ["working", "branch"]>;
+    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"]>;
+    }>>;
+}>>, never, never, never>, false>;

package/dist/groups/vcs.js

@@ -0,0 +1,47 @@
+import { FileDiff } from "@opencode-ai/schema/file-diff";
+import { Location } from "@opencode-ai/schema/location";
+import { NonNegativeInt } from "@opencode-ai/schema/schema";
+import { Vcs } from "@opencode-ai/schema/vcs";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+const DiffQuery = Schema.Struct({
+    ...LocationQuery.fields,
+    mode: Vcs.Mode,
+    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.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.diff", "/api/vcs/diff", {
+    query: DiffQuery,
+    success: Location.response(Schema.Array(FileDiff.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.vcs.diff",
+    summary: "VCS diff",
+    description: "Diff the working copy against HEAD (mode git) or the default-branch merge base (mode branch) for the requested location.",
+})))
+    .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-ai/schema/location";
+import { WebSearch } from "@opencode-ai/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-ai/schema/location";
+import { WebSearch } from "@opencode-ai/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/worktree.d.ts

@@ -0,0 +1,42 @@
+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/:projectID", Schema.toCodecStringTree<Schema.Struct<{
+    projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+}>>, never, 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>;
+}>>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.create", "POST", "/api/worktree/:projectID", Schema.toCodecStringTree<Schema.Struct<{
+    projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, 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 strategy: Schema.brand<Schema.Trim, "Worktree.StrategyID">;
+}>>, 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/:projectID", Schema.toCodecStringTree<Schema.Struct<{
+    projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+}>>, never, 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/:projectID/refresh", Schema.toCodecStringTree<Schema.Struct<{
+    projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+}>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof WorktreeError>, never, never>, false>;
+export {};

package/dist/groups/worktree.js

@@ -0,0 +1,54 @@
+import { Project } from "@opencode-ai/schema/project";
+import { Worktree } from "@opencode-ai/schema/worktree";
+import { Schema, Struct } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+const root = "/api/worktree/:projectID";
+export class WorktreeError extends Schema.ErrorClass("WorktreeError")({
+    name: Schema.Literal("WorktreeError"),
+    data: Schema.Struct({
+        message: Schema.String,
+        forceRequired: Schema.optional(Schema.Boolean),
+    }),
+}, { httpApiStatus: 400 }) {
+}
+const CreatePayload = Schema.Struct(Struct.omit(Worktree.CreateInput.fields, ["projectID"]));
+const RemovePayload = Schema.Struct(Struct.omit(Worktree.RemoveInput.fields, ["projectID"]));
+export const WorktreeGroup = HttpApiGroup.make("server.worktree")
+    .add(HttpApiEndpoint.get("worktree.list", root, {
+    params: { projectID: Project.ID },
+    success: Worktree.List,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.worktree.list",
+    summary: "List worktrees",
+    description: "List known local worktrees for a project.",
+})))
+    .add(HttpApiEndpoint.post("worktree.create", root, {
+    params: { projectID: Project.ID },
+    payload: CreatePayload,
+    success: Worktree.Info,
+    error: WorktreeError,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.worktree.create",
+    summary: "Create worktree",
+    description: "Create a worktree for a project.",
+})))
+    .add(HttpApiEndpoint.delete("worktree.remove", root, {
+    params: { projectID: Project.ID },
+    payload: RemovePayload,
+    success: HttpApiSchema.NoContent,
+    error: WorktreeError,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.worktree.remove",
+    summary: "Remove worktree",
+    description: "Remove a managed worktree from a project.",
+})))
+    .add(HttpApiEndpoint.post("worktree.refresh", `${root}/refresh`, {
+    params: { projectID: Project.ID },
+    success: HttpApiSchema.NoContent,
+    error: WorktreeError,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.worktree.refresh",
+    summary: "Refresh worktrees",
+    description: "Reconcile stored worktrees with the project repositories.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "worktree", description: "Project worktree management routes." }));

package/dist/middleware/authorization.d.ts

@@ -0,0 +1,13 @@
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { UnauthorizedError } from "../errors.js";
+declare const Authorization_base: HttpApiMiddleware.ServiceClass<Authorization, "@opencode/HttpApiAuthorization", {
+    requires: never;
+    provides: never;
+    error: typeof UnauthorizedError;
+    clientError: never;
+    requiredForClient: false;
+    security: never;
+}, HttpApiMiddleware.HttpApiMiddleware<never, typeof UnauthorizedError, never>>;
+export declare class Authorization extends Authorization_base {
+}
+export {};

package/dist/middleware/authorization.js

@@ -0,0 +1,6 @@
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { UnauthorizedError } from "../errors.js";
+export class Authorization extends HttpApiMiddleware.Service()("@opencode/HttpApiAuthorization", {
+    error: UnauthorizedError,
+}) {
+}

package/dist/middleware/schema-error.d.ts

@@ -0,0 +1,13 @@
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { InvalidRequestError } from "../errors.js";
+declare const SchemaErrorMiddleware_base: HttpApiMiddleware.ServiceClass<SchemaErrorMiddleware, "@opencode/HttpApiSchemaError", {
+    requires: never;
+    provides: never;
+    error: typeof InvalidRequestError;
+    clientError: never;
+    requiredForClient: false;
+    security: never;
+}, HttpApiMiddleware.HttpApiMiddleware<never, typeof InvalidRequestError, never>>;
+export declare class SchemaErrorMiddleware extends SchemaErrorMiddleware_base {
+}
+export {};

package/dist/middleware/schema-error.js

@@ -0,0 +1,4 @@
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { InvalidRequestError } from "../errors.js";
+export class SchemaErrorMiddleware extends HttpApiMiddleware.Service()("@opencode/HttpApiSchemaError", { error: InvalidRequestError }) {
+}