@opencode-ai/protocol 0.0.0-dev-17471

package/dist/groups/project.d.ts

@@ -0,0 +1,41 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const ProjectGroup: HttpApiGroup.HttpApiGroup<"server.project", HttpApiEndpoint.HttpApiEndpoint<"project.list", "GET", "/api/project", never, never, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly canonical: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly vcs: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["git", "hg"]>>>, Schema.optionalKey<Schema.Literals<readonly ["git", "hg"]>>, never, never>;
+    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly icon: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly override: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly override: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+    readonly commands: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly start: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+    readonly time: Schema.Struct<{
+        readonly created: Schema.Int;
+        readonly updated: Schema.Int;
+        readonly initialized: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>;
+    readonly sandboxes: Schema.$Array<Schema.String>;
+}>>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"project.current", "GET", "/api/project/current", 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 id: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly canonical: Schema.brand<Schema.String, "AbsolutePath">;
+}>>, never, never, never>, false>;

package/dist/groups/project.js

@@ -0,0 +1,27 @@
+import { Project } from "@opencode-ai/schema/project";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+const root = "/api/project";
+export const ProjectGroup = HttpApiGroup.make("server.project")
+    .add(HttpApiEndpoint.get("project.list", root, {
+    success: Schema.Array(Project.Info),
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.project.list",
+    summary: "List projects",
+    description: "List known projects.",
+})))
+    .add(HttpApiEndpoint.get("project.current", `${root}/current`, {
+    query: LocationQuery,
+    success: Project.Current,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.project.current",
+    summary: "Get current project",
+    description: "Resolve the project for the requested location.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "project",
+    description: "Project routes.",
+}));

package/dist/groups/provider.d.ts

@@ -0,0 +1,82 @@
+import { Provider } from "@opencode-ai/schema/provider";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { ProviderNotFoundError, ServiceUnavailableError } from "../errors.js";
+export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider", HttpApiEndpoint.HttpApiEndpoint<"provider.list", "GET", "/api/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 settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+        readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+        readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+        readonly id: Schema.brand<Schema.String, "Provider.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+            anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+            openai: string & import("effect/Brand").Brand<"Provider.ID">;
+            google: string & import("effect/Brand").Brand<"Provider.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+            azure: string & import("effect/Brand").Brand<"Provider.ID">;
+            openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+            mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+            gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+        };
+        readonly integrationID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Integration.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Integration.ID">>, never, never>;
+        readonly name: Schema.String;
+        readonly activation: Schema.Literals<readonly ["auto", "enabled", "disabled"]>;
+        readonly package: Schema.String;
+    }> & {
+        empty: (id: Provider.ID) => Provider.Info;
+    }>;
+}>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"provider.get", "GET", "/api/provider/:providerID", Schema.toCodecStringTree<Schema.Struct<{
+    providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.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 settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+        readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+        readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+        readonly id: Schema.brand<Schema.String, "Provider.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+            anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+            openai: string & import("effect/Brand").Brand<"Provider.ID">;
+            google: string & import("effect/Brand").Brand<"Provider.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+            azure: string & import("effect/Brand").Brand<"Provider.ID">;
+            openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+            mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+            gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+        };
+        readonly integrationID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Integration.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Integration.ID">>, never, never>;
+        readonly name: Schema.String;
+        readonly activation: Schema.Literals<readonly ["auto", "enabled", "disabled"]>;
+        readonly package: Schema.String;
+    }> & {
+        empty: (id: Provider.ID) => Provider.Info;
+    };
+}>>, Schema.toCodecJson<typeof ServiceUnavailableError | typeof ProviderNotFoundError>, never, never>, false>;

package/dist/groups/provider.js

@@ -0,0 +1,34 @@
+import { Provider } from "@opencode-ai/schema/provider";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { ProviderNotFoundError, ServiceUnavailableError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const ProviderGroup = HttpApiGroup.make("server.provider")
+    .add(HttpApiEndpoint.get("provider.list", "/api/provider", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Provider.Info)),
+    error: ServiceUnavailableError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.provider.list",
+    summary: "List providers",
+    description: "Retrieve active AI providers so clients can show provider availability and configuration.",
+})))
+    .add(HttpApiEndpoint.get("provider.get", "/api/provider/:providerID", {
+    params: { providerID: Provider.ID },
+    query: LocationQuery,
+    success: Location.response(Provider.Info),
+    error: [ProviderNotFoundError, ServiceUnavailableError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.provider.get",
+    summary: "Get provider",
+    description: "Retrieve a single AI provider so clients can inspect its availability and endpoint settings.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "provider",
+    description: "Experimental provider routes.",
+}));

package/dist/groups/pty.d.ts

@@ -0,0 +1,145 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { ForbiddenError, PtyNotFoundError } from "../errors.js";
+export declare const PTY_CONNECT_TICKET_QUERY = "ticket";
+export declare const PTY_CONNECT_TOKEN_HEADER = "x-opencode-ticket";
+export declare const PTY_CONNECT_TOKEN_HEADER_VALUE = "1";
+export declare function hasPtyConnectTicketURL(url: URL): boolean;
+export declare const PtyGroup: HttpApiGroup.HttpApiGroup<"server.pty", HttpApiEndpoint.HttpApiEndpoint<"pty.list", "GET", "/api/pty", 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, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+        readonly title: Schema.String;
+        readonly command: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "exited"]>;
+        readonly pid: Schema.Int;
+        readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.create", "POST", "/api/pty", 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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly args: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly cwd: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly env: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+        readonly title: Schema.String;
+        readonly command: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "exited"]>;
+        readonly pid: Schema.Int;
+        readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.get", "GET", "/api/pty/:ptyID", Schema.toCodecStringTree<Schema.Struct<{
+    ptyID: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+}>>, 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, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+        readonly title: Schema.String;
+        readonly command: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "exited"]>;
+        readonly pid: Schema.Int;
+        readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>;
+}>>, Schema.toCodecJson<typeof PtyNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.update", "PUT", "/api/pty/:ptyID", Schema.toCodecStringTree<Schema.Struct<{
+    ptyID: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+}>>, 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 title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly size: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly rows: Schema.Int;
+        readonly cols: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly rows: Schema.Int;
+        readonly cols: Schema.Int;
+    }>>, never, never>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: typeof Location.Info;
+    readonly data: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "PtyID"> & {
+            create: () => string & import("effect/Brand").Brand<"PtyID">;
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+        };
+        readonly title: Schema.String;
+        readonly command: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly cwd: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "exited"]>;
+        readonly pid: Schema.Int;
+        readonly exitCode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    }>;
+}>>, Schema.toCodecJson<typeof PtyNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.remove", "DELETE", "/api/pty/:ptyID", Schema.toCodecStringTree<Schema.Struct<{
+    ptyID: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+}>>, 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 PtyNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.connectToken", "POST", "/api/pty/:ptyID/connect-token", Schema.toCodecStringTree<Schema.Struct<{
+    ptyID: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+}>>, 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 ticket: Schema.String;
+        readonly expires_in: Schema.Int;
+    }>;
+}>>, Schema.toCodecJson<typeof ForbiddenError | typeof PtyNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.connect", "GET", "/api/pty/:ptyID/connect", Schema.toCodecStringTree<Schema.Struct<{
+    ptyID: Schema.brand<Schema.String, "PtyID"> & {
+        create: () => string & import("effect/Brand").Brand<"PtyID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+    };
+}>>, never, never, never, Schema.toCodecJson<Schema.Boolean>, Schema.toCodecJson<typeof ForbiddenError | typeof PtyNotFoundError>, never, never>, false>;

package/dist/groups/pty.js

@@ -0,0 +1,112 @@
+import { Pty } from "@opencode-ai/schema/pty";
+import { PtyTicket } from "@opencode-ai/schema/pty-ticket";
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { ForbiddenError, PtyNotFoundError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const PTY_CONNECT_TICKET_QUERY = "ticket";
+export const PTY_CONNECT_TOKEN_HEADER = "x-opencode-ticket";
+export const PTY_CONNECT_TOKEN_HEADER_VALUE = "1";
+const PTY_CONNECT_PATH = /^\/api\/pty\/[^/]+\/connect$/;
+// Authorization middleware skips credential checks when this matches; the PTY connect handler
+// is then responsible for consuming and validating the ticket.
+export function hasPtyConnectTicketURL(url) {
+    return PTY_CONNECT_PATH.test(url.pathname) && !!url.searchParams.get(PTY_CONNECT_TICKET_QUERY);
+}
+export const PtyGroup = HttpApiGroup.make("server.pty")
+    .add(HttpApiEndpoint.get("pty.list", "/api/pty", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Pty.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.list",
+    summary: "List PTY sessions",
+    description: "List PTY sessions for a location, including exited sessions retained until removal.",
+})))
+    .add(HttpApiEndpoint.post("pty.create", "/api/pty", {
+    query: LocationQuery,
+    payload: Pty.CreateInput,
+    success: Location.response(Pty.Info),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.create",
+    summary: "Create PTY session",
+    description: "Create a pseudo-terminal session for a location.",
+})))
+    .add(HttpApiEndpoint.get("pty.get", "/api/pty/:ptyID", {
+    params: { ptyID: Pty.ID },
+    query: LocationQuery,
+    success: Location.response(Pty.Info),
+    error: PtyNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.get",
+    summary: "Get PTY session",
+    description: "Get one PTY session, including its exit code once exited.",
+})))
+    .add(HttpApiEndpoint.put("pty.update", "/api/pty/:ptyID", {
+    params: { ptyID: Pty.ID },
+    query: LocationQuery,
+    payload: Pty.UpdateInput,
+    success: Location.response(Pty.Info),
+    error: PtyNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.update",
+    summary: "Update PTY session",
+    description: "Update the title or viewport size of one PTY session.",
+})))
+    .add(HttpApiEndpoint.delete("pty.remove", "/api/pty/:ptyID", {
+    params: { ptyID: Pty.ID },
+    query: LocationQuery,
+    success: HttpApiSchema.NoContent,
+    error: PtyNotFoundError,
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.remove",
+    summary: "Remove PTY session",
+    description: "Terminate and remove one PTY session.",
+})))
+    .add(HttpApiEndpoint.post("pty.connectToken", "/api/pty/:ptyID/connect-token", {
+    params: { ptyID: Pty.ID },
+    query: LocationQuery,
+    success: Location.response(PtyTicket.ConnectToken),
+    error: [ForbiddenError, PtyNotFoundError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.connect.token",
+    summary: "Create PTY WebSocket token",
+    description: "Create a short-lived single-use ticket for opening a PTY WebSocket connection.",
+})))
+    .add(
+// Query fields are decoded in the raw handler after the existence check so a missing
+// session responds with an empty 404 before any upgrade work.
+HttpApiEndpoint.get("pty.connect", "/api/pty/:ptyID/connect", {
+    params: { ptyID: Pty.ID },
+    success: Schema.Boolean,
+    error: [ForbiddenError, PtyNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.pty.connect",
+    summary: "Connect to PTY session",
+    description: "Establish a WebSocket connection streaming PTY output and accepting terminal input.",
+    transform: (operation) => ({
+        ...operation,
+        "x-websocket": true,
+        parameters: [
+            ...(operation.parameters ?? []),
+            ...["location[directory]", "location[workspace]", "cursor", PTY_CONNECT_TICKET_QUERY].map((name) => ({
+                in: "query",
+                name,
+                schema: { type: "string" },
+            })),
+        ],
+    }),
+})))
+    .annotateMerge(OpenApi.annotations({ title: "pty", description: "Experimental location-scoped PTY routes." }));

package/dist/groups/reference.d.ts

@@ -0,0 +1,29 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const ReferenceGroup: HttpApiGroup.HttpApiGroup<"server.reference", HttpApiEndpoint.HttpApiEndpoint<"reference.list", "GET", "/api/reference", 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 path: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly source: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"local">;
+            readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"git">;
+            readonly repository: Schema.String;
+            readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        }>]>;
+    }>>;
+}>>, never, never, never>, false>;

package/dist/groups/reference.js

@@ -0,0 +1,20 @@
+import { Location } from "@opencode-ai/schema/location";
+import { Reference } from "@opencode-ai/schema/reference";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const ReferenceGroup = HttpApiGroup.make("server.reference")
+    .add(HttpApiEndpoint.get("reference.list", "/api/reference", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(Reference.Info)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "v2.reference.list",
+    summary: "List references",
+    description: "List references available in the requested location.",
+})))
+    .annotateMerge(OpenApi.annotations({
+    title: "reference",
+    description: "Location-scoped project references.",
+}));

package/dist/groups/server.d.ts

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+export declare const ServerGroup: HttpApiGroup.HttpApiGroup<"server.server", HttpApiEndpoint.HttpApiEndpoint<"server.get", "GET", "/api/server", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly urls: Schema.$Array<Schema.String>;
+}>>, never, never, never>, false>;

package/dist/groups/server.js

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+export const ServerGroup = HttpApiGroup.make("server.server")
+    .add(HttpApiEndpoint.get("server.get", "/api/server", {
+    success: Schema.Struct({ urls: Schema.Array(Schema.String) }),
+}).annotateMerge(OpenApi.annotations({
+    identifier: "v2.server.get",
+    summary: "Get server information",
+    description: "Return the URLs that can be used to connect to this server.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "server" }));