@opencode-ai/protocol 0.0.0-next-14854 → 0.0.0-reserved.0

package/dist/groups/project-copy.d.ts

@@ -1,49 +0,0 @@
-import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
-declare const ProjectCopyError_base: Schema.Class<ProjectCopyError, Schema.Struct<{
-    readonly name: Schema.Literal<"ProjectCopyError">;
-    readonly data: Schema.Struct<{
-        readonly message: Schema.String;
-        readonly forceRequired: Schema.optional<Schema.Boolean>;
-    }>;
-}>, import("effect/Cause").YieldableError>;
-export declare class ProjectCopyError extends ProjectCopyError_base {
-}
-export declare const ProjectCopyGroup: HttpApiGroup.HttpApiGroup<"server.projectCopy", HttpApiEndpoint.HttpApiEndpoint<"projectCopy.create", "POST", "/experimental/project/:projectID/copy", HttpApiEndpoint.StringTree<Schema.Struct<{
-    projectID: Schema.brand<Schema.String, "Project.ID"> & {
-        global: string & import("effect/Brand").Brand<"Project.ID">;
-    };
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, HttpApiEndpoint.Json<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 strategy: Schema.brand<Schema.Trim, "ProjectCopy.StrategyID">;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
-    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-}>>, HttpApiEndpoint.Json<typeof ProjectCopyError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"projectCopy.remove", "DELETE", "/experimental/project/:projectID/copy", HttpApiEndpoint.StringTree<Schema.Struct<{
-    projectID: Schema.brand<Schema.String, "Project.ID"> & {
-        global: string & import("effect/Brand").Brand<"Project.ID">;
-    };
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, HttpApiEndpoint.Json<Schema.Struct<{
-    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-    readonly force: Schema.Boolean;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof ProjectCopyError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"projectCopy.refresh", "POST", "/experimental/project/:projectID/copy/refresh", HttpApiEndpoint.StringTree<Schema.Struct<{
-    projectID: Schema.brand<Schema.String, "Project.ID"> & {
-        global: string & import("effect/Brand").Brand<"Project.ID">;
-    };
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof ProjectCopyError>, never, never>, false>;
-export {};

package/dist/groups/project-copy.js

@@ -1,44 +0,0 @@
-import { ProjectCopy } from "@opencode-ai/schema/project-copy";
-import { Project } from "@opencode-ai/schema/project";
-import { Schema, Struct } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
-import { LocationQuery, locationQueryOpenApi } from "./location.js";
-const root = "/experimental/project/:projectID/copy";
-export class ProjectCopyError extends Schema.ErrorClass("ProjectCopyError")({
-    name: Schema.Literal("ProjectCopyError"),
-    data: Schema.Struct({
-        message: Schema.String,
-        forceRequired: Schema.optional(Schema.Boolean),
-    }),
-}, { httpApiStatus: 400 }) {
-}
-const CreatePayload = Schema.Struct(Struct.omit(ProjectCopy.CreateInput.fields, ["projectID", "sourceDirectory"]));
-const RemovePayload = Schema.Struct(Struct.omit(ProjectCopy.RemoveInput.fields, ["projectID"]));
-export const ProjectCopyGroup = HttpApiGroup.make("server.projectCopy")
-    .add(HttpApiEndpoint.post("projectCopy.create", root, {
-    params: { projectID: Project.ID },
-    query: LocationQuery,
-    payload: CreatePayload,
-    success: ProjectCopy.Copy,
-    error: ProjectCopyError,
-})
-    .annotateMerge(locationQueryOpenApi)
-    .annotateMerge(OpenApi.annotations({ identifier: "v2.projectCopy.create" })))
-    .add(HttpApiEndpoint.delete("projectCopy.remove", root, {
-    params: { projectID: Project.ID },
-    query: LocationQuery,
-    payload: RemovePayload,
-    success: HttpApiSchema.NoContent,
-    error: ProjectCopyError,
-})
-    .annotateMerge(locationQueryOpenApi)
-    .annotateMerge(OpenApi.annotations({ identifier: "v2.projectCopy.remove" })))
-    .add(HttpApiEndpoint.post("projectCopy.refresh", `${root}/refresh`, {
-    params: { projectID: Project.ID },
-    query: LocationQuery,
-    success: HttpApiSchema.NoContent,
-    error: ProjectCopyError,
-})
-    .annotateMerge(locationQueryOpenApi)
-    .annotateMerge(OpenApi.annotations({ identifier: "v2.projectCopy.refresh" })))
-    .annotateMerge(OpenApi.annotations({ title: "projectCopy", description: "Project copy management routes." }));

package/dist/groups/project.d.ts

@@ -1,24 +0,0 @@
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
-export declare const ProjectGroup: HttpApiGroup.HttpApiGroup<"server.project", HttpApiEndpoint.HttpApiEndpoint<"project.current", "GET", "/api/project/current", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<import("effect/Schema").Struct<{
-    readonly location: import("effect/Schema").optional<import("effect/Schema").Struct<{
-        readonly directory: import("effect/Schema").optional<import("effect/Schema").String>;
-        readonly workspace: import("effect/Schema").optional<import("effect/Schema").String>;
-    }>>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<import("effect/Schema").Struct<{
-    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-        global: string & import("effect/Brand").Brand<"Project.ID">;
-    };
-    readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-}>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"project.directories", "GET", "/api/project/:projectID/directories", HttpApiEndpoint.StringTree<import("effect/Schema").Struct<{
-    projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-        global: string & import("effect/Brand").Brand<"Project.ID">;
-    };
-}>>, HttpApiEndpoint.StringTree<import("effect/Schema").Struct<{
-    readonly location: import("effect/Schema").optional<import("effect/Schema").Struct<{
-        readonly directory: import("effect/Schema").optional<import("effect/Schema").String>;
-        readonly workspace: import("effect/Schema").optional<import("effect/Schema").String>;
-    }>>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<import("effect/Schema").$Array<import("effect/Schema").Struct<{
-    readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-    readonly strategy: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
-}>>>, HttpApiEndpoint.Json<never>, never, never>, false>;

package/dist/groups/project.js

@@ -1,30 +0,0 @@
-import { Project } from "@opencode-ai/schema/project";
-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.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.",
-})))
-    .add(HttpApiEndpoint.get("project.directories", `${root}/:projectID/directories`, {
-    params: { projectID: Project.ID },
-    query: LocationQuery,
-    success: Project.Directories,
-})
-    .annotateMerge(locationQueryOpenApi)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.project.directories",
-    summary: "List project directories",
-    description: "List known local absolute directories for a project.",
-})))
-    .annotateMerge(OpenApi.annotations({
-    title: "projects",
-    description: "Location-scoped project routes.",
-}));

package/dist/groups/provider.d.ts

@@ -1,164 +0,0 @@
-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", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
-    readonly location: typeof Location.Info;
-    readonly data: Schema.$Array<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "ProviderV2.ID"> & {
-            opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            gitlab: string & import("effect/Brand").Brand<"ProviderV2.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 disabled: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        readonly api: Schema.Union<readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"aisdk">;
-            readonly package: Schema.String;
-            readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"native">;
-            readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly settings: Schema.$Record<Schema.String, Schema.Unknown>;
-        }>]>;
-        readonly request: Schema.Struct<{
-            readonly settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Unknown>>;
-            readonly headers: Schema.$Record<Schema.String, Schema.String>;
-            readonly body: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-        }>;
-    }> & {
-        empty: (id: Provider.ID) => {
-            readonly id: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            readonly name: string;
-            readonly api: {
-                readonly type: "aisdk";
-                readonly package: string;
-                readonly url?: string | undefined;
-                readonly settings?: {
-                    readonly [x: string]: unknown;
-                } | undefined;
-            } | {
-                readonly type: "native";
-                readonly settings: {
-                    readonly [x: string]: unknown;
-                };
-                readonly url?: string | undefined;
-            };
-            readonly request: {
-                readonly settings: {
-                    readonly [x: string]: unknown;
-                };
-                readonly headers: {
-                    readonly [x: string]: string;
-                };
-                readonly body: {
-                    readonly [x: string]: Schema.Json;
-                };
-            };
-            readonly integrationID?: (string & import("effect/Brand").Brand<"Integration.ID">) | undefined;
-            readonly disabled?: boolean | undefined;
-        };
-    }>;
-}>>, HttpApiEndpoint.Json<typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"provider.get", "GET", "/api/provider/:providerID", HttpApiEndpoint.StringTree<Schema.Struct<{
-    providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
-        opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-        anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-        openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-        google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-        googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-        githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-        amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-        azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-        openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-        mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-        gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-    };
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
-    readonly location: typeof Location.Info;
-    readonly data: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "ProviderV2.ID"> & {
-            opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            gitlab: string & import("effect/Brand").Brand<"ProviderV2.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 disabled: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        readonly api: Schema.Union<readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"aisdk">;
-            readonly package: Schema.String;
-            readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"native">;
-            readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly settings: Schema.$Record<Schema.String, Schema.Unknown>;
-        }>]>;
-        readonly request: Schema.Struct<{
-            readonly settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Unknown>>;
-            readonly headers: Schema.$Record<Schema.String, Schema.String>;
-            readonly body: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-        }>;
-    }> & {
-        empty: (id: Provider.ID) => {
-            readonly id: string & import("effect/Brand").Brand<"ProviderV2.ID">;
-            readonly name: string;
-            readonly api: {
-                readonly type: "aisdk";
-                readonly package: string;
-                readonly url?: string | undefined;
-                readonly settings?: {
-                    readonly [x: string]: unknown;
-                } | undefined;
-            } | {
-                readonly type: "native";
-                readonly settings: {
-                    readonly [x: string]: unknown;
-                };
-                readonly url?: string | undefined;
-            };
-            readonly request: {
-                readonly settings: {
-                    readonly [x: string]: unknown;
-                };
-                readonly headers: {
-                    readonly [x: string]: string;
-                };
-                readonly body: {
-                    readonly [x: string]: Schema.Json;
-                };
-            };
-            readonly integrationID?: (string & import("effect/Brand").Brand<"Integration.ID">) | undefined;
-            readonly disabled?: boolean | undefined;
-        };
-    };
-}>>, HttpApiEndpoint.Json<typeof ServiceUnavailableError | typeof ProviderNotFoundError>, never, never>, false>;

package/dist/groups/provider.js

@@ -1,34 +0,0 @@
-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: "providers",
-    description: "Experimental provider routes.",
-}));

package/dist/groups/pty.d.ts

@@ -1,145 +0,0 @@
-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", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<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>;
-    }>>;
-}>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.create", "POST", "/api/pty", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, HttpApiEndpoint.Json<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>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<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>;
-    }>;
-}>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.get", "GET", "/api/pty/:ptyID", HttpApiEndpoint.StringTree<Schema.Struct<{
-    ptyID: Schema.brand<Schema.String, "PtyID"> & {
-        create: () => string & import("effect/Brand").Brand<"PtyID">;
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
-    };
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<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>;
-    }>;
-}>>, HttpApiEndpoint.Json<typeof PtyNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.update", "PUT", "/api/pty/:ptyID", HttpApiEndpoint.StringTree<Schema.Struct<{
-    ptyID: Schema.brand<Schema.String, "PtyID"> & {
-        create: () => string & import("effect/Brand").Brand<"PtyID">;
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
-    };
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, HttpApiEndpoint.Json<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>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<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>;
-    }>;
-}>>, HttpApiEndpoint.Json<typeof PtyNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.remove", "DELETE", "/api/pty/:ptyID", HttpApiEndpoint.StringTree<Schema.Struct<{
-    ptyID: Schema.brand<Schema.String, "PtyID"> & {
-        create: () => string & import("effect/Brand").Brand<"PtyID">;
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
-    };
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof PtyNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.connectToken", "POST", "/api/pty/:ptyID/connect-token", HttpApiEndpoint.StringTree<Schema.Struct<{
-    ptyID: Schema.brand<Schema.String, "PtyID"> & {
-        create: () => string & import("effect/Brand").Brand<"PtyID">;
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
-    };
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
-    readonly location: typeof Location.Info;
-    readonly data: Schema.Struct<{
-        readonly ticket: Schema.String;
-        readonly expires_in: Schema.Int;
-    }>;
-}>>, HttpApiEndpoint.Json<typeof ForbiddenError | typeof PtyNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pty.connect", "GET", "/api/pty/:ptyID/connect", HttpApiEndpoint.StringTree<Schema.Struct<{
-    ptyID: Schema.brand<Schema.String, "PtyID"> & {
-        create: () => string & import("effect/Brand").Brand<"PtyID">;
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
-    };
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Boolean>, HttpApiEndpoint.Json<typeof ForbiddenError | typeof PtyNotFoundError>, never, never>, false>;

package/dist/groups/pty.js

@@ -1,111 +0,0 @@
-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.connectToken",
-    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,
-        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." }));