@kilocode/protocol 0.0.0-stage → 0.0.0-v2-9

package/dist/groups/pty.d.ts

@@ -0,0 +1,151 @@
+import { Context, Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/http-api";
+import { ForbiddenError, LocationNotFoundError, 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 const PTY_CONNECT_PATH = "/api/pty/:ptyID/connect";
+export declare function hasPtyConnectTicketURL(url: URL): boolean;
+export declare const makePtyGroup: <LocationId extends HttpApiMiddleware.AnyId, LocationService>(locationMiddleware: Context.Key<LocationId, LocationService>) => HttpApiGroup.HttpApiGroup<"server.pty", HttpApiEndpoint.HttpApiEndpoint<"pty.create", "POST", "/api/pty", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: 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: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    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, LocationId, HttpApiMiddleware.Requires<LocationId>> | HttpApiEndpoint.HttpApiEndpoint<"pty.list", "GET", "/api/pty", never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    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, LocationId, HttpApiMiddleware.Requires<LocationId>> | 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>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    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>, LocationId, HttpApiMiddleware.Requires<LocationId>> | 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>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof PtyNotFoundError>, LocationId, HttpApiMiddleware.Requires<LocationId>> | 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>;
+    }>>;
+}>>, 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: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    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>, LocationId, HttpApiMiddleware.Requires<LocationId>> | 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>;
+    }>>;
+}>>, never, Schema.toCodecStringTree<Schema.Struct<{
+    readonly "x-opencode-ticket": Schema.optional<Schema.String>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    readonly data: Schema.Struct<{
+        readonly ticket: Schema.String;
+        readonly expires_in: Schema.Int;
+    }>;
+}>>, Schema.toCodecJson<typeof ForbiddenError | typeof PtyNotFoundError>, LocationId, HttpApiMiddleware.Requires<LocationId>> | 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 LocationNotFoundError | typeof ForbiddenError | typeof PtyNotFoundError>, never, never>, false>;

package/dist/groups/pty.js

@@ -0,0 +1,112 @@
+import { Pty } from "@opencode/schema/pty";
+import { PtyTicket } from "@opencode/schema/pty-ticket";
+import { Location } from "@opencode/schema/location";
+import { Context, Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/http-api";
+import { ForbiddenError, LocationNotFoundError, 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";
+export const PTY_CONNECT_PATH = "/api/pty/:ptyID/connect";
+const PTY_CONNECT_URL = /^\/api\/pty\/[^/]+\/connect$/;
+export function hasPtyConnectTicketURL(url) {
+    return PTY_CONNECT_URL.test(url.pathname) && !!url.searchParams.get(PTY_CONNECT_TICKET_QUERY);
+}
+export const makePtyGroup = (locationMiddleware) => 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: "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: "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: "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: "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: "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,
+    headers: Schema.Struct({ [PTY_CONNECT_TOKEN_HEADER]: Schema.optional(Schema.String) }),
+    success: Location.response(PtyTicket.ConnectToken),
+    error: [ForbiddenError, PtyNotFoundError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "pty.connect.token",
+    summary: "Create PTY WebSocket token",
+    description: "Create a short-lived single-use ticket for opening a PTY WebSocket connection.",
+})))
+    .middleware(locationMiddleware)
+    .add(
+// Query fields are decoded in the raw handler before upgrade work.
+HttpApiEndpoint.get("pty.connect", PTY_CONNECT_PATH, {
+    params: { ptyID: Pty.ID },
+    success: Schema.Boolean,
+    error: [ForbiddenError, PtyNotFoundError, LocationNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "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]", "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,25 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+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>;
+    }>>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
+    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">;
+        }>, 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>;
+        }>]>;
+    }>>;
+}>>, never, never, never>, false>;

package/dist/groups/reference.js

@@ -0,0 +1,33 @@
+import { Location } from "@opencode/schema/location";
+import { Reference } from "@opencode/schema/reference";
+import { Schema, Struct } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+const PublicLocalSource = Schema.Struct(Struct.omit(Reference.LocalSource.fields, ["description", "hidden"])).annotate({
+    identifier: "Reference.LocalSource",
+});
+const PublicGitSource = Schema.Struct(Struct.omit(Reference.GitSource.fields, ["description", "hidden"])).annotate({
+    identifier: "Reference.GitSource",
+});
+const PublicSource = Schema.Union([PublicLocalSource, PublicGitSource])
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "Reference.Source" });
+const PublicInfo = Schema.Struct({
+    ...Struct.omit(Reference.Info.fields, ["source"]),
+    source: PublicSource,
+}).annotate({ identifier: "Reference.Info" });
+export const ReferenceGroup = HttpApiGroup.make("server.reference")
+    .add(HttpApiEndpoint.get("reference.list", "/api/reference", {
+    query: LocationQuery,
+    success: Location.response(Schema.Array(PublicInfo)),
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "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/rpc.d.ts

@@ -0,0 +1,21 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+import { RpcError, RpcInternalError } from "../errors.js";
+export declare const RpcInput: Schema.Struct<{
+    readonly input: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;
+}>;
+export declare const RpcOutput: Schema.Struct<{
+    readonly output: Schema.optionalKey<Schema.Unknown>;
+}>;
+export declare const RpcGroup: HttpApiGroup.HttpApiGroup<"server.rpc", HttpApiEndpoint.HttpApiEndpoint<"rpc.call", "POST", "/api/rpc/:rpcID/:method", Schema.toCodecStringTree<Schema.Struct<{
+    rpcID: Schema.String;
+    method: Schema.String;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+    }>>;
+}>>, Schema.toCodecJson<Schema.Struct<{
+    readonly input: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+    readonly output: Schema.optionalKey<Schema.Unknown>;
+}>>, Schema.toCodecJson<typeof RpcError | typeof RpcInternalError>, never, never>, false>;

package/dist/groups/rpc.js

@@ -0,0 +1,24 @@
+import { optional } from "@opencode/schema/schema";
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
+import { RpcError, RpcInternalError } from "../errors.js";
+import { LocationQuery, locationQueryOpenApi } from "./location.js";
+export const RpcInput = Schema.Struct({ input: optional(Schema.Unknown) }).annotate({ identifier: "Rpc.Input" });
+export const RpcOutput = Schema.Struct({ output: Schema.optionalKey(Schema.Unknown) }).annotate({
+    identifier: "Rpc.Output",
+});
+export const RpcGroup = HttpApiGroup.make("server.rpc")
+    .add(HttpApiEndpoint.post("rpc.call", "/api/rpc/:rpcID/:method", {
+    params: { rpcID: Schema.String, method: Schema.String },
+    query: LocationQuery,
+    payload: RpcInput,
+    success: RpcOutput,
+    error: [RpcError, RpcInternalError],
+})
+    .annotateMerge(locationQueryOpenApi)
+    .annotateMerge(OpenApi.annotations({
+    identifier: "rpc.call",
+    summary: "Call a plugin RPC",
+    description: "Dispatch a method to the currently registered RPC at the requested location.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "rpc", description: "Plugin RPC routes." }));

package/dist/groups/server.d.ts

@@ -0,0 +1,44 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+import { UnauthorizedError } from "../errors.js";
+export declare const ServerInfo: Schema.Struct<{
+    readonly version: Schema.String;
+    readonly pid: Schema.Int;
+    readonly urls: Schema.$Array<Schema.String>;
+    readonly paths: Schema.Struct<{
+        readonly tmp: Schema.String;
+    }>;
+    readonly capabilities: Schema.optional<Schema.Struct<{
+        readonly persistentPty: Schema.optional<Schema.Boolean>;
+    }>>;
+}>;
+export type ServerInfo = typeof ServerInfo.Type;
+export declare const PairingCode: Schema.Struct<{
+    readonly code: Schema.String;
+    readonly expires_in: Schema.Int;
+}>;
+export type PairingCode = typeof PairingCode.Type;
+export declare const PairingSession: Schema.Struct<{
+    readonly token: Schema.String;
+}>;
+export type PairingSession = typeof PairingSession.Type;
+export declare const PAIRING_CONNECT_PATH = "/auth/connect/:code";
+export declare function isPairingConnectURL(url: URL): boolean;
+export declare const ServerGroup: HttpApiGroup.HttpApiGroup<"server.server", HttpApiEndpoint.HttpApiEndpoint<"server.connect", "GET", "/auth/connect/:code", Schema.toCodecStringTree<Schema.Struct<{
+    code: Schema.String;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly token: Schema.String;
+}>>, Schema.toCodecJson<typeof UnauthorizedError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"server.info", "GET", "/api/info", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly version: Schema.String;
+    readonly pid: Schema.Int;
+    readonly urls: Schema.$Array<Schema.String>;
+    readonly paths: Schema.Struct<{
+        readonly tmp: Schema.String;
+    }>;
+    readonly capabilities: Schema.optional<Schema.Struct<{
+        readonly persistentPty: Schema.optional<Schema.Boolean>;
+    }>>;
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"server.pair", "POST", "/api/pair", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly code: Schema.String;
+    readonly expires_in: Schema.Int;
+}>>, never, never, never>, false>;

package/dist/groups/server.js

@@ -0,0 +1,53 @@
+import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
+import { UnauthorizedError } from "../errors.js";
+export const ServerInfo = Schema.Struct({
+    version: Schema.String,
+    // 0 means the runtime has no OS process identity (e.g. workerd).
+    pid: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    urls: Schema.Array(Schema.String),
+    paths: Schema.Struct({
+        tmp: Schema.String,
+    }),
+    // Optional at every level so clients still decode servers that predate a capability.
+    capabilities: Schema.optional(Schema.Struct({
+        persistentPty: Schema.optional(Schema.Boolean),
+    })),
+}).annotate({ identifier: "ServerInfo" });
+export const PairingCode = Schema.Struct({
+    code: Schema.String,
+    expires_in: Schema.Int,
+}).annotate({ identifier: "PairingCode" });
+export const PairingSession = Schema.Struct({
+    token: Schema.String,
+}).annotate({ identifier: "PairingSession" });
+export const PAIRING_CONNECT_PATH = "/auth/connect/:code";
+const PAIRING_CONNECT_URL = /^\/auth\/connect\/[^/]+$/;
+export function isPairingConnectURL(url) {
+    return PAIRING_CONNECT_URL.test(url.pathname);
+}
+export const ServerGroup = HttpApiGroup.make("server.server")
+    .add(HttpApiEndpoint.get("server.info", "/api/info", {
+    success: ServerInfo,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "server.info",
+    summary: "Get server info",
+    description: "Return the server identity, connection URLs, paths, and readiness status.",
+})))
+    .add(HttpApiEndpoint.post("server.pair", "/api/pair", {
+    success: PairingCode,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "server.pair",
+    summary: "Create pairing code",
+    description: "Create a short-lived, single-use code for a /auth/connect/:code pairing link.",
+})))
+    .add(HttpApiEndpoint.get("server.connect", PAIRING_CONNECT_PATH, {
+    params: { code: Schema.String },
+    success: PairingSession,
+    error: UnauthorizedError,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "server.connect",
+    summary: "Redeem pairing code",
+    description: "Redeem a pairing code. Browsers receive a session cookie and a redirect to the web app; requests that accept JSON receive a session token to use as the password.",
+})))
+    .annotateMerge(OpenApi.annotations({ title: "server" }));