import * as Schema from "effect/Schema";
import { TrimmedNonEmptyString } from "./baseSchemas.ts";
import { ProviderInstanceId } from "./providerInstance.ts";
export const DEFAULT_TERMINAL_ID = "term-1";
export const DEFAULT_MAX_TERMINAL_BUFFER_BYTES = 512 * 1024;
const TrimmedNonEmptyStringSchema = TrimmedNonEmptyString;
const TerminalColsSchema = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).check(
Schema.isLessThanOrEqualTo(1000),
);
const TerminalRowsSchema = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).check(
Schema.isLessThanOrEqualTo(500),
);
const TerminalIdSchema = TrimmedNonEmptyStringSchema.check(Schema.isMaxLength(128));
const TerminalEnvKeySchema = Schema.String.check(
Schema.isPattern(/^[A-Za-z_][A-Za-z0-9_]*$/),
).check(Schema.isMaxLength(128));
const TerminalEnvValueSchema = Schema.String.check(Schema.isMaxLength(8_192));
const TerminalEnvSchema = Schema.Record(TerminalEnvKeySchema, TerminalEnvValueSchema).check(
Schema.isMaxProperties(128),
);
export const TerminalThreadInput = Schema.Struct({
threadId: TrimmedNonEmptyStringSchema,
});
export type TerminalThreadInput = typeof TerminalThreadInput.Type;
// Terminal ids are client-chosen; the server never allocates them.
const TerminalSessionInput = Schema.Struct({
...TerminalThreadInput.fields,
terminalId: TerminalIdSchema,
});
export type TerminalSessionInput = Schema.Codec.Encoded<typeof TerminalSessionInput>;
export const TerminalOpenInput = Schema.Struct({
...TerminalSessionInput.fields,
cwd: TrimmedNonEmptyStringSchema,
worktreePath: Schema.optional(Schema.NullOr(TrimmedNonEmptyStringSchema)),
cols: Schema.optional(TerminalColsSchema),
rows: Schema.optional(TerminalRowsSchema),
env: Schema.optional(TerminalEnvSchema),
providerInstanceId: Schema.optional(ProviderInstanceId),
stopOnSettle: Schema.optional(Schema.Boolean),
});
export type TerminalOpenInput = typeof TerminalOpenInput.Type;
export const TerminalAttachInput = Schema.Struct({
...TerminalSessionInput.fields,
cwd: Schema.optional(TrimmedNonEmptyStringSchema),
worktreePath: Schema.optional(Schema.NullOr(TrimmedNonEmptyStringSchema)),
cols: Schema.optional(TerminalColsSchema),
rows: Schema.optional(TerminalRowsSchema),
env: Schema.optional(TerminalEnvSchema),
providerInstanceId: Schema.optional(ProviderInstanceId),
stopOnSettle: Schema.optional(Schema.Boolean),
restartIfNotRunning: Schema.optional(Schema.Boolean),
// Resubscriptions preserve stopped terminals; unknown IDs recover after a server restart.
resume: Schema.optional(Schema.Boolean),
});
export type TerminalAttachInput = typeof TerminalAttachInput.Type;
export const TerminalObserveInput = TerminalSessionInput;
export type TerminalObserveInput = Schema.Codec.Encoded<typeof TerminalObserveInput>;
export const TerminalWriteInput = Schema.Struct({
...TerminalSessionInput.fields,
data: Schema.String.check(Schema.isNonEmpty()).check(Schema.isMaxLength(65_536)),
});
export type TerminalWriteInput = Schema.Codec.Encoded<typeof TerminalWriteInput>;
export const TerminalResizeInput = Schema.Struct({
...TerminalSessionInput.fields,
cols: TerminalColsSchema,
rows: TerminalRowsSchema,
});
export type TerminalResizeInput = Schema.Codec.Encoded<typeof TerminalResizeInput>;
export const TerminalClearInput = TerminalSessionInput;
export type TerminalClearInput = Schema.Codec.Encoded<typeof TerminalClearInput>;
export const TerminalCloseInput = Schema.Struct({
...TerminalThreadInput.fields,
terminalId: Schema.optional(TerminalIdSchema),
deleteHistory: Schema.optional(Schema.Boolean),
});
export type TerminalCloseInput = typeof TerminalCloseInput.Type;
export const TerminalSessionStatus = Schema.Literals(["starting", "running", "exited", "error"]);
export type TerminalSessionStatus = typeof TerminalSessionStatus.Type;
export const TerminalSessionSnapshot = Schema.Struct({
threadId: Schema.String.check(Schema.isNonEmpty()),
terminalId: Schema.String.check(Schema.isNonEmpty()),
cwd: Schema.String.check(Schema.isNonEmpty()),
worktreePath: Schema.NullOr(TrimmedNonEmptyStringSchema),
status: TerminalSessionStatus,
pid: Schema.NullOr(Schema.Int.check(Schema.isGreaterThan(0))),
history: Schema.String,
exitCode: Schema.NullOr(Schema.Int),
exitSignal: Schema.NullOr(Schema.Int),
label: Schema.String.check(Schema.isMaxLength(128)),
updatedAt: Schema.String,
sequence: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
// The PTY grid every renderer of this terminal should draw; absent from older servers.
cols: Schema.optional(TerminalColsSchema),
rows: Schema.optional(TerminalRowsSchema),
});
export type TerminalSessionSnapshot = typeof TerminalSessionSnapshot.Type;
export const TerminalSummary = Schema.Struct({
threadId: Schema.String.check(Schema.isNonEmpty()),
terminalId: Schema.String.check(Schema.isNonEmpty()),
cwd: Schema.String.check(Schema.isNonEmpty()),
worktreePath: Schema.NullOr(TrimmedNonEmptyStringSchema),
status: TerminalSessionStatus,
pid: Schema.NullOr(Schema.Int.check(Schema.isGreaterThan(0))),
exitCode: Schema.NullOr(Schema.Int),
exitSignal: Schema.NullOr(Schema.Int),
hasRunningSubprocess: Schema.Boolean,
label: Schema.String.check(Schema.isMaxLength(128)),
updatedAt: Schema.String,
});
export type TerminalSummary = typeof TerminalSummary.Type;
const TerminalMetadataSnapshotEvent = Schema.Struct({
type: Schema.Literal("snapshot"),
terminals: Schema.Array(TerminalSummary),
});
const TerminalMetadataUpsertEvent = Schema.Struct({
type: Schema.Literal("upsert"),
terminal: TerminalSummary,
});
const TerminalMetadataRemoveEvent = Schema.Struct({
type: Schema.Literal("remove"),
threadId: Schema.String.check(Schema.isNonEmpty()),
terminalId: Schema.String.check(Schema.isNonEmpty()),
});
export const TerminalMetadataStreamEvent = Schema.Union([
TerminalMetadataSnapshotEvent,
TerminalMetadataUpsertEvent,
TerminalMetadataRemoveEvent,
]);
export type TerminalMetadataStreamEvent = typeof TerminalMetadataStreamEvent.Type;
const TerminalEventBaseSchema = Schema.Struct({
threadId: Schema.String.check(Schema.isNonEmpty()),
terminalId: Schema.String.check(Schema.isNonEmpty()),
sequence: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
});
const TerminalStartedEvent = Schema.Struct({
...TerminalEventBaseSchema.fields,
type: Schema.Literal("started"),
snapshot: TerminalSessionSnapshot,
});
const TerminalOutputEvent = Schema.Struct({
...TerminalEventBaseSchema.fields,
type: Schema.Literal("output"),
data: Schema.String,
});
const TerminalExitedEvent = Schema.Struct({
...TerminalEventBaseSchema.fields,
type: Schema.Literal("exited"),
exitCode: Schema.NullOr(Schema.Int),
exitSignal: Schema.NullOr(Schema.Int),
});
const TerminalClosedEvent = Schema.Struct({
...TerminalEventBaseSchema.fields,
type: Schema.Literal("closed"),
});
const TerminalErrorEvent = Schema.Struct({
...TerminalEventBaseSchema.fields,
type: Schema.Literal("error"),
message: Schema.String.check(Schema.isNonEmpty()),
});
const TerminalClearedEvent = Schema.Struct({
...TerminalEventBaseSchema.fields,
type: Schema.Literal("cleared"),
});
const TerminalRestartedEvent = Schema.Struct({
...TerminalEventBaseSchema.fields,
type: Schema.Literal("restarted"),
snapshot: TerminalSessionSnapshot,
});
const TerminalActivityEvent = Schema.Struct({
...TerminalEventBaseSchema.fields,
type: Schema.Literal("activity"),
hasRunningSubprocess: Schema.Boolean,
label: Schema.String.check(Schema.isMaxLength(128)),
// Shared PTY grid changes ride on activity because older clients reject unknown event types.
cols: Schema.optional(TerminalColsSchema),
rows: Schema.optional(TerminalRowsSchema),
});
export const TerminalEvent = Schema.Union([
TerminalStartedEvent,
TerminalOutputEvent,
TerminalExitedEvent,
TerminalClosedEvent,
TerminalErrorEvent,
TerminalClearedEvent,
TerminalRestartedEvent,
TerminalActivityEvent,
]);
export type TerminalEvent = typeof TerminalEvent.Type;
const TerminalAttachSnapshotEvent = Schema.Struct({
type: Schema.Literal("snapshot"),
snapshot: TerminalSessionSnapshot,
});
export const TerminalAttachStreamEvent = Schema.Union([
TerminalAttachSnapshotEvent,
TerminalOutputEvent,
TerminalExitedEvent,
TerminalClosedEvent,
TerminalErrorEvent,
TerminalClearedEvent,
TerminalRestartedEvent,
TerminalActivityEvent,
]);
export type TerminalAttachStreamEvent = typeof TerminalAttachStreamEvent.Type;
export class TerminalCwdNotFoundError extends Schema.TaggedError<TerminalCwdNotFoundError>()(
"TerminalCwdNotFoundError",
{
cwd: Schema.String,
},
) {
override get message() {
return `Terminal cwd does not exist: ${this.cwd}`;
}
}
export class TerminalCwdNotDirectoryError extends Schema.TaggedError<TerminalCwdNotDirectoryError>()(
"TerminalCwdNotDirectoryError",
{
cwd: Schema.String,
},
) {
override get message() {
return `Terminal cwd is not a directory: ${this.cwd}`;
}
}
export class TerminalCwdStatError extends Schema.TaggedError<TerminalCwdStatError>()(
"TerminalCwdStatError",
{
cwd: Schema.String,
cause: Schema.Defect(),
},
) {
override get message() {
return `Failed to access terminal cwd: ${this.cwd}`;
}
}
export const TerminalCwdError = Schema.Union([
TerminalCwdNotFoundError,
TerminalCwdNotDirectoryError,
TerminalCwdStatError,
]);
export type TerminalCwdError = typeof TerminalCwdError.Type;
export class TerminalHistoryError extends Schema.TaggedError<TerminalHistoryError>()(
"TerminalHistoryError",
{
operation: Schema.Literals(["read", "truncate", "migrate"]),
threadId: Schema.String,
terminalId: Schema.String,
cause: Schema.optional(Schema.Defect()),
},
) {
override get message() {
return `Failed to ${this.operation} terminal history for thread: ${this.threadId}, terminal: ${this.terminalId}`;
}
}
export class TerminalSessionLookupError extends Schema.TaggedError<TerminalSessionLookupError>()(
"TerminalSessionLookupError",
{
threadId: Schema.String,
terminalId: Schema.String,
},
) {
override get message() {
return `Unknown terminal thread: ${this.threadId}, terminal: ${this.terminalId}`;
}
}
export class TerminalProviderInstanceNotFoundError extends Schema.TaggedError<TerminalProviderInstanceNotFoundError>()(
"TerminalProviderInstanceNotFoundError",
{
providerInstanceId: ProviderInstanceId,
},
) {
override get message() {
return `Provider instance is not available: ${this.providerInstanceId}`;
}
}
export class TerminalProviderEnvironmentError extends Schema.TaggedError<TerminalProviderEnvironmentError>()(
"TerminalProviderEnvironmentError",
{
providerInstanceId: ProviderInstanceId,
cause: Schema.Defect(),
},
) {
override get message() {
return `Could not prepare the terminal environment for provider instance: ${this.providerInstanceId}`;
}
}
export class TerminalNotRunningError extends Schema.TaggedError<TerminalNotRunningError>()(
"TerminalNotRunningError",
{
threadId: Schema.String,
terminalId: Schema.String,
},
) {
override get message() {
return `Terminal is not running for thread: ${this.threadId}, terminal: ${this.terminalId}`;
}
}
export class TerminalWriteError extends Schema.TaggedError<TerminalWriteError>()(
"TerminalWriteError",
{
threadId: Schema.String,
terminalId: Schema.String,
terminalPid: Schema.Number,
cause: Schema.Defect(),
},
) {
override get message() {
return `Failed to write to terminal for thread: ${this.threadId}, terminal: ${this.terminalId}, PID: ${this.terminalPid}`;
}
}
export class TerminalResizeError extends Schema.TaggedError<TerminalResizeError>()(
"TerminalResizeError",
{
threadId: Schema.String,
terminalId: Schema.String,
terminalPid: Schema.Number,
cols: TerminalColsSchema,
rows: TerminalRowsSchema,
cause: Schema.Defect(),
},
) {
override get message() {
return `Failed to resize terminal for thread: ${this.threadId}, terminal: ${this.terminalId}, PID: ${this.terminalPid} to ${this.cols}x${this.rows}`;
}
}
export const TerminalError = Schema.Union([
TerminalCwdError,
TerminalHistoryError,
TerminalSessionLookupError,
TerminalProviderInstanceNotFoundError,
TerminalProviderEnvironmentError,
TerminalNotRunningError,
TerminalWriteError,
TerminalResizeError,
]);
export type TerminalError = typeof TerminalError.Type;