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

package/dist/groups/session.js

@@ -1,423 +0,0 @@
-import { SessionMessage } from "@opencode-ai/schema/session-message";
-import { SessionInput } from "@opencode-ai/schema/session-input";
-import { PromptInput } from "@opencode-ai/schema/prompt-input";
-import { Session } from "@opencode-ai/schema/session";
-import { SessionContextEntry } from "@opencode-ai/schema/session-context-entry";
-import { Project } from "@opencode-ai/schema/project";
-import { AbsolutePath, PositiveInt, RelativePath, statics } from "@opencode-ai/schema/schema";
-import { Event } from "@opencode-ai/schema/event";
-import { Workspace } from "@opencode-ai/schema/workspace";
-import { Context, Effect, Encoding, Result, Schema, SchemaGetter, Struct } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
-import { ConflictError, CommandEvaluationError, CommandNotFoundError, InvalidCursorError, InvalidRequestError, MessageNotFoundError, ServiceUnavailableError, SessionBusyError, SessionNotFoundError, SkillNotFoundError, UnknownError, } from "../errors.js";
-import { Agent } from "@opencode-ai/schema/agent";
-import { Model } from "@opencode-ai/schema/model";
-import { Location } from "@opencode-ai/schema/location";
-import { Revert } from "@opencode-ai/schema/revert";
-import { SessionEvent } from "@opencode-ai/schema/session-event";
-import { EventLog } from "@opencode-ai/schema/event-log";
-const ParentIDFilter = Schema.Union([
-    Session.ID,
-    Schema.Null.pipe(Schema.encodeTo(Schema.Literal("null"), {
-        decode: SchemaGetter.transform(() => null),
-        encode: SchemaGetter.transform(() => "null"),
-    })),
-]).annotate({
-    description: "Filter by parent session. Use null to return only root sessions.",
-});
-const SessionsQueryFields = {
-    workspace: Workspace.ID.pipe(Schema.optional),
-    limit: Schema.NumberFromString.pipe(Schema.decodeTo(PositiveInt), Schema.optional).annotate({
-        description: "Maximum number of sessions to return. Defaults to the newest 50 sessions.",
-    }),
-    order: Schema.optional(Schema.Union([Schema.Literal("asc"), Schema.Literal("desc")])).annotate({
-        description: "Session order for the first page. Use desc for newest first or asc for oldest first.",
-    }),
-    search: Schema.optional(Schema.String),
-    parentID: ParentIDFilter.pipe(Schema.optional),
-};
-const SessionsDirectoryQuery = Schema.Struct({
-    ...SessionsQueryFields,
-    directory: AbsolutePath,
-});
-const SessionsProjectQuery = Schema.Struct({
-    ...SessionsQueryFields,
-    project: Project.ID,
-    subpath: RelativePath.pipe(Schema.optional),
-});
-const SessionsAllQuery = Schema.Struct(SessionsQueryFields);
-const withCursor = (schema) => schema.mapFields((fields) => ({
-    ...Struct.omit(fields, ["limit"]),
-    anchor: Session.ListAnchor,
-}));
-const SessionsCursorInput = Schema.Union([
-    withCursor(SessionsDirectoryQuery),
-    withCursor(SessionsProjectQuery),
-    withCursor(SessionsAllQuery),
-]);
-const SessionsCursorJson = Schema.fromJsonString(SessionsCursorInput);
-const encodeSessionsCursor = Schema.encodeSync(SessionsCursorJson);
-const decodeSessionsCursor = Schema.decodeUnknownEffect(SessionsCursorJson);
-const invalidCursor = "Invalid cursor";
-export const SessionsCursor = Schema.String.pipe(Schema.brand("SessionsCursor"), statics((schema) => {
-    const make = schema.make.bind(schema);
-    return {
-        make: (input) => make(Encoding.encodeBase64Url(encodeSessionsCursor(input))),
-        parse: (input) => Effect.suspend(() => {
-            const result = Encoding.decodeBase64UrlString(input);
-            return Result.isFailure(result)
-                ? Effect.fail(invalidCursor)
-                : decodeSessionsCursor(result.success).pipe(Effect.mapError(() => invalidCursor));
-        }),
-    };
-}));
-const SessionActive = Schema.Struct({
-    type: Schema.Literal("running"),
-}).annotate({ identifier: "SessionActive" });
-const SessionWatermarks = Schema.Record(Session.ID, Event.Seq).annotate({
-    identifier: "SessionWatermarks",
-    description: "Durable log seq each session's snapshot was computed at. Attach a live log read after the watermark to compose fetch and stream gap-free; apply a snapshot only where its watermark is at or beyond already-applied events. Sessions without durable events are absent.",
-});
-const BooleanFromString = Schema.Literals(["true", "false"]).pipe(Schema.decodeTo(Schema.Boolean, {
-    decode: SchemaGetter.transform((value) => value === "true"),
-    encode: SchemaGetter.transform((value) => (value ? "true" : "false")),
-}));
-const SessionsQueryCursor = SessionsCursor.annotate({
-    description: "Opaque pagination cursor returned as cursor.previous or cursor.next in the previous response.",
-});
-export const SessionsQuery = Schema.Struct({
-    ...SessionsQueryFields,
-    directory: AbsolutePath.pipe(Schema.optional),
-    project: Project.ID.pipe(Schema.optional),
-    subpath: RelativePath.pipe(Schema.optional),
-    cursor: SessionsQueryCursor.pipe(Schema.optional),
-}).annotate({ identifier: "SessionsQuery" });
-export const makeSessionGroup = (sessionLocationMiddleware) => HttpApiGroup.make("server.session")
-    .add(HttpApiEndpoint.get("session.list", "/api/session", {
-    query: SessionsQuery,
-    success: Schema.Struct({
-        data: Schema.Array(Session.Info),
-        watermarks: SessionWatermarks,
-        cursor: Schema.Struct({
-            previous: SessionsCursor.pipe(Schema.optional),
-            next: SessionsCursor.pipe(Schema.optional),
-        }),
-    }).annotate({ identifier: "SessionsResponse" }),
-    error: [InvalidCursorError, InvalidRequestError],
-}).annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.list",
-    summary: "List sessions",
-    description: "Retrieve sessions in the requested order. Items keep that order across pages; use cursor.next or cursor.previous to move through the ordered list.",
-})))
-    .add(HttpApiEndpoint.post("session.create", "/api/session", {
-    payload: Schema.Struct({
-        id: Session.ID.pipe(Schema.optional),
-        agent: Agent.ID.pipe(Schema.optional),
-        model: Model.Ref.pipe(Schema.optional),
-        location: Location.Ref.pipe(Schema.optional),
-    }),
-    success: Schema.Struct({ data: Session.Info }),
-}).annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.create",
-    summary: "Create session",
-    description: "Create a session at the requested location.",
-})))
-    .add(HttpApiEndpoint.get("session.active", "/api/session/active", {
-    success: Schema.Struct({ data: Schema.Record(Session.ID, SessionActive), watermarks: SessionWatermarks }),
-}).annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.active",
-    summary: "List active sessions",
-    description: "Retrieve foreground Session drains currently owned by this OpenCode process. Sessions absent from the result are inactive. Watermarks are the durable log positions read alongside the activity snapshot; activity itself is process state, so the pairing is advisory rather than transactional.",
-})))
-    .add(HttpApiEndpoint.get("session.get", "/api/session/:sessionID", {
-    params: { sessionID: Session.ID },
-    success: Schema.Struct({ data: Session.Info }),
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.get",
-    summary: "Get session",
-    description: "Retrieve a session by ID.",
-})))
-    .add(HttpApiEndpoint.post("session.fork", "/api/session/:sessionID/fork", {
-    params: { sessionID: Session.ID },
-    payload: Schema.Struct({ messageID: SessionMessage.ID.pipe(Schema.optional) }),
-    success: Schema.Struct({ data: Session.Info }),
-    error: [SessionNotFoundError, MessageNotFoundError],
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.fork",
-    summary: "Fork session",
-    description: "Create a child session by copying projected history from the parent. When messageID is supplied, copy messages before that boundary.",
-})))
-    .add(HttpApiEndpoint.post("session.switchAgent", "/api/session/:sessionID/agent", {
-    params: { sessionID: Session.ID },
-    payload: Schema.Struct({ agent: Agent.ID }),
-    success: HttpApiSchema.NoContent,
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.switchAgent",
-    summary: "Switch session agent",
-    description: "Switch the agent used by subsequent provider turns.",
-})))
-    .add(HttpApiEndpoint.post("session.switchModel", "/api/session/:sessionID/model", {
-    params: { sessionID: Session.ID },
-    payload: Schema.Struct({ model: Model.Ref }),
-    success: HttpApiSchema.NoContent,
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.switchModel",
-    summary: "Switch session model",
-    description: "Switch the model used by subsequent provider turns.",
-})))
-    .add(HttpApiEndpoint.post("session.rename", "/api/session/:sessionID/rename", {
-    params: { sessionID: Session.ID },
-    payload: Schema.Struct({ title: Schema.String }),
-    success: HttpApiSchema.NoContent,
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.rename",
-    summary: "Rename session",
-    description: "Update the session title.",
-})))
-    .add(HttpApiEndpoint.post("session.prompt", "/api/session/:sessionID/prompt", {
-    params: { sessionID: Session.ID },
-    payload: Schema.Struct({
-        id: SessionMessage.ID.pipe(Schema.optional),
-        prompt: PromptInput.Prompt,
-        delivery: SessionInput.Delivery.pipe(Schema.optional),
-        resume: Schema.Boolean.pipe(Schema.optional),
-    }),
-    success: Schema.Struct({ data: SessionInput.Admitted }),
-    error: [ConflictError, SessionNotFoundError],
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.prompt",
-    summary: "Send message",
-    description: "Durably admit one session input and schedule agent-loop execution unless resume is false.",
-})))
-    .add(HttpApiEndpoint.post("session.command", "/api/session/:sessionID/command", {
-    params: { sessionID: Session.ID },
-    payload: Schema.Struct({
-        id: SessionMessage.ID.pipe(Schema.optional),
-        command: Schema.String,
-        arguments: Schema.String.pipe(Schema.optional),
-        agent: Schema.String.pipe(Schema.optional),
-        model: Model.Ref.pipe(Schema.optional),
-        files: PromptInput.Prompt.fields.files,
-        agents: PromptInput.Prompt.fields.agents,
-        delivery: SessionInput.Delivery.pipe(Schema.optional),
-        resume: Schema.Boolean.pipe(Schema.optional),
-    }),
-    success: Schema.Struct({ data: SessionInput.Admitted }),
-    error: [ConflictError, SessionNotFoundError, CommandNotFoundError, CommandEvaluationError],
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.command",
-    summary: "Run command",
-    description: "Resolve a slash command into prompt input, admit it durably, and schedule execution unless resume is false.",
-})))
-    .add(HttpApiEndpoint.post("session.skill", "/api/session/:sessionID/skill", {
-    params: { sessionID: Session.ID },
-    payload: Schema.Struct({
-        id: SessionMessage.ID.pipe(Schema.optional),
-        skill: Schema.String,
-        resume: Schema.Boolean.pipe(Schema.optional),
-    }),
-    success: HttpApiSchema.NoContent,
-    error: [SessionNotFoundError, SkillNotFoundError],
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.skill",
-    summary: "Activate skill",
-    description: "Activate a skill for a session by appending a skill message and resuming execution.",
-})))
-    .add(HttpApiEndpoint.post("session.synthetic", "/api/session/:sessionID/synthetic", {
-    params: { sessionID: Session.ID },
-    payload: Schema.Struct({
-        text: Schema.String,
-        description: Schema.String.pipe(Schema.optional),
-        metadata: SessionMessage.Synthetic.fields.metadata,
-    }),
-    success: HttpApiSchema.NoContent,
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.synthetic",
-    summary: "Add synthetic message",
-    description: "Append a synthetic message to a session and resume execution.",
-})))
-    .add(HttpApiEndpoint.post("session.shell", "/api/session/:sessionID/shell", {
-    params: { sessionID: Session.ID },
-    payload: Schema.Struct({
-        id: Event.ID.pipe(Schema.optional),
-        command: Schema.String,
-    }),
-    success: HttpApiSchema.NoContent,
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.shell",
-    summary: "Run shell command",
-    description: "Execute one shell command in the session's working directory. Emits a shell.started event before execution and a shell.ended event with the merged output after.",
-})))
-    .add(HttpApiEndpoint.post("session.compact", "/api/session/:sessionID/compact", {
-    params: { sessionID: Session.ID },
-    success: HttpApiSchema.NoContent,
-    error: [SessionNotFoundError, SessionBusyError, ServiceUnavailableError, UnknownError],
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.compact",
-    summary: "Compact session",
-    description: "Compact a session conversation.",
-})))
-    .add(HttpApiEndpoint.post("session.wait", "/api/session/:sessionID/wait", {
-    params: { sessionID: Session.ID },
-    success: HttpApiSchema.NoContent,
-    error: [SessionNotFoundError, ServiceUnavailableError],
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.wait",
-    summary: "Wait for session",
-    description: "Wait for a session agent loop to become idle.",
-})))
-    .add(HttpApiEndpoint.post("session.revert.stage", "/api/session/:sessionID/revert/stage", {
-    params: { sessionID: Session.ID },
-    payload: Schema.Struct({ messageID: SessionMessage.ID, files: Schema.Boolean.pipe(Schema.optional) }),
-    success: Schema.Struct({ data: Revert.State }),
-    error: [MessageNotFoundError, SessionNotFoundError, SessionBusyError, UnknownError],
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.revert.stage",
-    summary: "Stage session revert",
-    description: "Stage or move a reversible session boundary and optionally apply its file changes.",
-})))
-    .add(HttpApiEndpoint.post("session.revert.clear", "/api/session/:sessionID/revert/clear", {
-    params: { sessionID: Session.ID },
-    success: HttpApiSchema.NoContent,
-    error: [SessionNotFoundError, SessionBusyError, UnknownError],
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({ identifier: "v2.session.revert.clear", summary: "Clear staged revert" })))
-    .add(HttpApiEndpoint.post("session.revert.commit", "/api/session/:sessionID/revert/commit", {
-    params: { sessionID: Session.ID },
-    success: HttpApiSchema.NoContent,
-    error: [SessionNotFoundError, SessionBusyError],
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({ identifier: "v2.session.revert.commit", summary: "Commit staged revert" })))
-    .add(HttpApiEndpoint.get("session.context", "/api/session/:sessionID/context", {
-    params: { sessionID: Session.ID },
-    success: Schema.Struct({ data: Schema.Array(SessionMessage.Message) }),
-    error: [SessionNotFoundError, UnknownError],
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.context",
-    summary: "Get session context",
-    description: "Retrieve the active context messages for a session (all messages after the last compaction).",
-})))
-    .add(HttpApiEndpoint.get("session.context.entry.list", "/api/session/:sessionID/context-entry", {
-    params: { sessionID: Session.ID },
-    success: Schema.Struct({ data: Schema.Array(SessionContextEntry.Info) }),
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.context.entry.list",
-    summary: "List context entries",
-    description: "List API-managed context entries attached to the session's system context.",
-})))
-    .add(HttpApiEndpoint.put("session.context.entry.put", "/api/session/:sessionID/context-entry/:key", {
-    params: { sessionID: Session.ID, key: SessionContextEntry.Key },
-    payload: Schema.Struct({ value: Schema.Json }),
-    success: HttpApiSchema.NoContent,
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.context.entry.put",
-    summary: "Put context entry",
-    description: "Attach or replace one durable context entry. The value is rendered into the session's system context; changes announce as updates at the next turn boundary.",
-})))
-    .add(HttpApiEndpoint.delete("session.context.entry.remove", "/api/session/:sessionID/context-entry/:key", {
-    params: { sessionID: Session.ID, key: SessionContextEntry.Key },
-    success: HttpApiSchema.NoContent,
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.context.entry.remove",
-    summary: "Remove context entry",
-    description: "Remove one context entry; the removal is announced to the model at the next turn boundary.",
-})))
-    .add(HttpApiEndpoint.get("session.log", "/api/session/:sessionID/log", {
-    params: { sessionID: Session.ID },
-    query: {
-        after: Schema.NumberFromString.pipe(Schema.decodeTo(Event.Seq), Schema.optional),
-        follow: BooleanFromString.pipe(Schema.optional),
-    },
-    success: HttpApiSchema.StreamSse({
-        data: Schema.Union([SessionEvent.Durable, EventLog.Synced]).annotate({ identifier: "SessionLogItem" }),
-    }),
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.log",
-    summary: "Read the session log",
-    description: "Durable, ordered, gap-free read of public session events after an exclusive aggregate sequence. Emits a synced marker once replay reaches the captured watermark, then completes; with follow=true it continues with live events instead. The only event API that promises reliability: attach after a snapshot watermark to compose fetch and stream without a race window.",
-})))
-    .add(HttpApiEndpoint.post("session.interrupt", "/api/session/:sessionID/interrupt", {
-    params: { sessionID: Session.ID },
-    success: HttpApiSchema.NoContent,
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.interrupt",
-    summary: "Interrupt session execution",
-    description: "Interrupt active execution owned by this OpenCode process. Idle interruption is a no-op.",
-})))
-    .add(HttpApiEndpoint.post("session.background", "/api/session/:sessionID/background", {
-    params: { sessionID: Session.ID },
-    success: HttpApiSchema.NoContent,
-    error: SessionNotFoundError,
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.background",
-    summary: "Background blocking session tools",
-    description: "Move active foreground backgroundable tools for this session into background observation. Idle requests are a no-op.",
-})))
-    .add(HttpApiEndpoint.get("session.message", "/api/session/:sessionID/message/:messageID", {
-    params: { sessionID: Session.ID, messageID: SessionMessage.ID },
-    success: Schema.Struct({ data: SessionMessage.Message }),
-    error: [SessionNotFoundError, MessageNotFoundError],
-})
-    .middleware(sessionLocationMiddleware)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.session.message",
-    summary: "Get session message",
-    description: "Retrieve one projected message owned by the Session.",
-})))
-    .annotateMerge(OpenApi.annotations({
-    title: "sessions",
-    description: "Experimental session routes.",
-}));

package/dist/groups/shell.d.ts

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

package/dist/groups/shell.js

@@ -1,65 +0,0 @@
-import { Shell } from "@opencode-ai/schema/shell";
-import { Location } from "@opencode-ai/schema/location";
-import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
-import { ShellNotFoundError } from "../errors.js";
-import { LocationQuery, locationQueryOpenApi } from "./location.js";
-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.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

@@ -1,19 +0,0 @@
-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", 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 name: Schema.String;
-        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;
-    }>>;
-}>>, HttpApiEndpoint.Json<never>, never, never>, false>;

package/dist/groups/skill.js

@@ -1,20 +0,0 @@
-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: "skills",
-    description: "Experimental skill routes.",
-}));