mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-16 05:01:03 +03:00
feat(core): speak opencode-pty protocol v8 (#62976)
This commit is contained in:
committed by
GitHub
Unverified
parent
a11e578235
commit
d22bc1d1b6
@@ -119,7 +119,7 @@
|
||||
"@effect/platform-node": "catalog:",
|
||||
"@opencode/client": "workspace:*",
|
||||
"@opencode/plugin": "workspace:*",
|
||||
"@opencode/pty": "0.4.0",
|
||||
"@opencode/pty": "0.5.0",
|
||||
"@opencode/schema": "workspace:*",
|
||||
"@opencode/server": "workspace:*",
|
||||
"@opencode/tui": "workspace:*",
|
||||
@@ -228,7 +228,7 @@
|
||||
"@opencode/codemode": "workspace:*",
|
||||
"@opencode/plugin": "workspace:*",
|
||||
"@opencode/plugin-browser": "workspace:*",
|
||||
"@opencode/pty": "0.4.0",
|
||||
"@opencode/pty": "0.5.0",
|
||||
"@opencode/schema": "workspace:*",
|
||||
"@opencode/util": "workspace:*",
|
||||
"@parcel/watcher": "2.5.1",
|
||||
@@ -623,7 +623,7 @@
|
||||
"devDependencies": {
|
||||
"@opencode/client": "workspace:*",
|
||||
"@opencode/plugin": "workspace:*",
|
||||
"@opencode/pty": "0.4.0",
|
||||
"@opencode/pty": "0.5.0",
|
||||
"@tsconfig/bun": "catalog:",
|
||||
"@types/bun": "catalog:",
|
||||
"@typescript/native": "catalog:",
|
||||
@@ -1833,23 +1833,23 @@
|
||||
|
||||
"@opencode/protocol": ["@opencode/protocol@workspace:packages/protocol"],
|
||||
|
||||
"@opencode/pty": ["@opencode/pty@0.4.0", "", { "optionalDependencies": { "@opencode/pty-darwin-arm64": "0.4.0", "@opencode/pty-darwin-x64": "0.4.0", "@opencode/pty-linux-arm64-gnu": "0.4.0", "@opencode/pty-linux-arm64-musl": "0.4.0", "@opencode/pty-linux-x64-gnu": "0.4.0", "@opencode/pty-linux-x64-musl": "0.4.0", "@opencode/pty-win32-arm64": "0.4.0", "@opencode/pty-win32-x64": "0.4.0" }, "bin": { "opencode-pty": "bin/opencode-pty.js" } }, "sha512-v7cLT71yfoNM5FlyPGwMjeqIJbr0DneGq4NpoOY5iAKpsevzOIcsI2E0fiDWajuk5xAFRxwyv4CpGqow7cu79Q=="],
|
||||
"@opencode/pty": ["@opencode/pty@0.5.0", "", { "optionalDependencies": { "@opencode/pty-darwin-arm64": "0.5.0", "@opencode/pty-darwin-x64": "0.5.0", "@opencode/pty-linux-arm64-gnu": "0.5.0", "@opencode/pty-linux-arm64-musl": "0.5.0", "@opencode/pty-linux-x64-gnu": "0.5.0", "@opencode/pty-linux-x64-musl": "0.5.0", "@opencode/pty-win32-arm64": "0.5.0", "@opencode/pty-win32-x64": "0.5.0" }, "bin": { "opencode-pty": "bin/opencode-pty.js" } }, "sha512-2U0RfT5U1lp1BcegXLoSBYfBx9sBNw3uJ/pao4UWdNV6UDfmDNGzdc8m4K1Q4ByBkXhbh8hexa0JS7HZ0vSsgg=="],
|
||||
|
||||
"@opencode/pty-darwin-arm64": ["@opencode/pty-darwin-arm64@0.4.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-XzZZJcQeR42IRpxHbbPEo4AK7jdp9SpgPx234DZ6uLnl6yclXcixH70G2U88EhKtGAMyCPIXdBfvQf4OQTDvbQ=="],
|
||||
"@opencode/pty-darwin-arm64": ["@opencode/pty-darwin-arm64@0.5.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-D+L/TnNUc35airWTBlLussnuDbZpKPQ2/uBHVkcycw6KrLYDb4hVoUJn8N5PXmLTnhmU64B4MUsdH9JoOZIi8w=="],
|
||||
|
||||
"@opencode/pty-darwin-x64": ["@opencode/pty-darwin-x64@0.4.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-NvQfygGcsGmDCIUJ/VHLcS6SduC93Y/qP2hrHjtBpiL2sSQyeCDcifNhLvqY/wxGFNNZ4GeZwwZqe7rMEuBJbQ=="],
|
||||
"@opencode/pty-darwin-x64": ["@opencode/pty-darwin-x64@0.5.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-/JMtOIAY9WWszsauWnCwjl2Qr8PBihS94tLsxa8prZBVhbbpOzcFslQsqR8JnJ1gAVlYINxEVS79+QQPQ4NC9g=="],
|
||||
|
||||
"@opencode/pty-linux-arm64-gnu": ["@opencode/pty-linux-arm64-gnu@0.4.0", "", { "os": "linux", "cpu": "arm64", "libc": "glibc" }, "sha512-VZXkYD+CT+zdodmTnKn9/VlmswksLPBLJryeBsG4IXUFXTsATr7+PVygJk96FxCh5nq68H3a/UJgyiIUMl1XCQ=="],
|
||||
"@opencode/pty-linux-arm64-gnu": ["@opencode/pty-linux-arm64-gnu@0.5.0", "", { "os": "linux", "cpu": "arm64", "libc": "glibc" }, "sha512-vNiHKopfKrX6vj8OmDXYxZ+5JEZwf5djDzt3LOqeYuwStQRX2rxcl2/zjrvd5i8rAJw30RpJ+PTdS1t08vqtLA=="],
|
||||
|
||||
"@opencode/pty-linux-arm64-musl": ["@opencode/pty-linux-arm64-musl@0.4.0", "", { "os": "linux", "cpu": "arm64", "libc": "musl" }, "sha512-hCx25Hn9sALdnkx2Y4aPGVw3glTbX61XRiJs+XETPPIO9QTaav4OS4k2JR2uHC6/u161xKdN82iJ+OYfwcGUSg=="],
|
||||
"@opencode/pty-linux-arm64-musl": ["@opencode/pty-linux-arm64-musl@0.5.0", "", { "os": "linux", "cpu": "arm64", "libc": "musl" }, "sha512-aW3lNGjit3FNAfpEskJgvTrtE2Lfnukpn8KmUVPUBN/EbRhT56h/N3ghzHYc5jIExETy06Xpy9i2xZxZQy0McQ=="],
|
||||
|
||||
"@opencode/pty-linux-x64-gnu": ["@opencode/pty-linux-x64-gnu@0.4.0", "", { "os": "linux", "cpu": "x64", "libc": "glibc" }, "sha512-Xal/d0+xp6XE4iCGUAw4JTQ4uf5l8V0EIbeKq+e03cHJewOMKZk4fooQjxpZvQIToBHRtnCJAmd+EEhVxXiDDw=="],
|
||||
"@opencode/pty-linux-x64-gnu": ["@opencode/pty-linux-x64-gnu@0.5.0", "", { "os": "linux", "cpu": "x64", "libc": "glibc" }, "sha512-XaMnBSh1QvJmcYKSOtx1fVvldZ+x212zAHaq8ovyafufqp6/Xl3AuqPCXwPFnycW2PfbUDwfZ7dBCXThQtOt3Q=="],
|
||||
|
||||
"@opencode/pty-linux-x64-musl": ["@opencode/pty-linux-x64-musl@0.4.0", "", { "os": "linux", "cpu": "x64", "libc": "musl" }, "sha512-dBVtKZoVKAN6/E+65GrJksgRKzPkPHUjWZBzf3mRANXt2adpdbV+/M1AMfPCZSju2mN1j9rNu8MCrxwr+ugEig=="],
|
||||
"@opencode/pty-linux-x64-musl": ["@opencode/pty-linux-x64-musl@0.5.0", "", { "os": "linux", "cpu": "x64", "libc": "musl" }, "sha512-30LVc91GrJP8YD6chLic4+5nMsLz3hCYu2cxPQczSKyRWMyBjuwvCf040UzlRAQiGllp8KBb7nYa8SCtq2/49Q=="],
|
||||
|
||||
"@opencode/pty-win32-arm64": ["@opencode/pty-win32-arm64@0.4.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-IKJMUnS2aluWqRj13enMWomYtwbXq8rStcf/mUbxBoAGTDMtWR/ZrRmKb2ptR7KUqDjdSEa+8C8rczS7uGFl9g=="],
|
||||
"@opencode/pty-win32-arm64": ["@opencode/pty-win32-arm64@0.5.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-BYVSytysZvXmIQcP9VbbXbOV417RLW/BATiAK8MMbHBF6fzqQlpAMTi4cQmWJKOlHgrREKeMBw786qZ8BES3Vg=="],
|
||||
|
||||
"@opencode/pty-win32-x64": ["@opencode/pty-win32-x64@0.4.0", "", { "os": "win32", "cpu": "x64" }, "sha512-P1QJLUX918/y8he8VEBSYoiN5bYhUnJtEaEpiE5fxoYsDP9nqAHXqIrGxTNNnda5jOBcCalxxy0WhL8qgeKOqQ=="],
|
||||
"@opencode/pty-win32-x64": ["@opencode/pty-win32-x64@0.5.0", "", { "os": "win32", "cpu": "x64" }, "sha512-42OEc6vvlL/gXAairdWf4DLX6juPrpOycES9sp3iE3UfQ5KsRsuQ6F3HFFmSBkiZ/yUhJtKoJdJbquBTNEL+Ow=="],
|
||||
|
||||
"@opencode/schema": ["@opencode/schema@workspace:packages/schema"],
|
||||
|
||||
|
||||
@@ -32,7 +32,7 @@
|
||||
"@effect/platform-node": "catalog:",
|
||||
"@opencode/client": "workspace:*",
|
||||
"@opencode/plugin": "workspace:*",
|
||||
"@opencode/pty": "0.4.0",
|
||||
"@opencode/pty": "0.5.0",
|
||||
"@opencode/schema": "workspace:*",
|
||||
"@opencode/server": "workspace:*",
|
||||
"@opencode/tui": "workspace:*",
|
||||
|
||||
@@ -104,7 +104,7 @@
|
||||
"@modelcontextprotocol/client": "2.4.0",
|
||||
"@modelcontextprotocol/core": "2.4.0",
|
||||
"@modelcontextprotocol/server": "2.4.0",
|
||||
"@opencode/pty": "0.4.0",
|
||||
"@opencode/pty": "0.5.0",
|
||||
"@opencode/ai": "workspace:*",
|
||||
"@opencode/codemode": "workspace:*",
|
||||
"@opencode/plugin": "workspace:*",
|
||||
|
||||
@@ -1,36 +1,59 @@
|
||||
import { spawn } from "node:child_process"
|
||||
import { mkdir, readFile, rename } from "node:fs/promises"
|
||||
import { readFile } from "node:fs/promises"
|
||||
import net from "node:net"
|
||||
import path from "node:path"
|
||||
import { Cause, Data, Duration, Effect, Schema, Semaphore } from "effect"
|
||||
import type { Handoff } from "@opencode/schema/persistent-pty"
|
||||
import { Session } from "@opencode/schema/session"
|
||||
|
||||
const ProtocolVersion = 7
|
||||
const ProtocolVersion = 8
|
||||
const MaxFrameBytes = 8 * 1024 * 1024
|
||||
|
||||
const Lifecycle = Schema.Union([
|
||||
Schema.Struct({ status: Schema.Literal("running") }),
|
||||
Schema.Struct({ status: Schema.Literal("exited"), exit_code: Schema.NullOr(Schema.Number) }),
|
||||
Schema.Struct({
|
||||
status: Schema.Literal("exited"),
|
||||
exit_code: Schema.NullOr(Schema.Number),
|
||||
signal: Schema.optional(Schema.NullOr(Schema.String)),
|
||||
}),
|
||||
Schema.Struct({ status: Schema.Literal("failed"), message: Schema.String }),
|
||||
])
|
||||
|
||||
export const WireTerminal = Schema.Struct({
|
||||
id: Schema.Number,
|
||||
pid: Schema.NullOr(Schema.Number),
|
||||
const PtyInfo = Schema.Struct({
|
||||
title: Schema.String,
|
||||
user_title: Schema.optional(Schema.NullOr(Schema.String)),
|
||||
user_title: Schema.NullOr(Schema.String),
|
||||
foreground_process: Schema.NullOr(Schema.String),
|
||||
group_id: Session.ID,
|
||||
command: Schema.Array(Schema.String),
|
||||
cwd: Schema.String,
|
||||
cols: Schema.Number,
|
||||
rows: Schema.Number,
|
||||
})
|
||||
|
||||
export const Metadata = Schema.Record(Schema.String, Schema.Unknown)
|
||||
export type Metadata = typeof Metadata.Type
|
||||
|
||||
const PipeInfo = Schema.Struct({
|
||||
output_path: Schema.String,
|
||||
output_lines: Schema.Number,
|
||||
output_error: Schema.optional(Schema.NullOr(Schema.String)),
|
||||
metadata: Metadata,
|
||||
})
|
||||
|
||||
export const ProcessInfo = Schema.Struct({
|
||||
id: Schema.Number,
|
||||
mode: Schema.Literals(["pty", "pipe"]),
|
||||
pid: Schema.NullOr(Schema.Number),
|
||||
command: Schema.Array(Schema.String),
|
||||
cwd: Schema.String,
|
||||
group_id: Schema.String,
|
||||
lifecycle: Lifecycle,
|
||||
output_head: Schema.Number,
|
||||
output_tail: Schema.Number,
|
||||
started_at: Schema.Number,
|
||||
exited_at: Schema.optional(Schema.NullOr(Schema.Number)),
|
||||
pty: Schema.optional(Schema.NullOr(PtyInfo)),
|
||||
pipe: Schema.optional(Schema.NullOr(PipeInfo)),
|
||||
})
|
||||
export type WireTerminal = typeof WireTerminal.Type
|
||||
export type ProcessInfo = typeof ProcessInfo.Type
|
||||
|
||||
export type Signal = "SIGTERM" | "SIGINT" | "SIGKILL"
|
||||
|
||||
const Registration = Schema.Struct({
|
||||
instance_id: Schema.String,
|
||||
@@ -38,7 +61,7 @@ const Registration = Schema.Struct({
|
||||
protocol: Schema.Number,
|
||||
socket: Schema.String,
|
||||
token: Schema.String,
|
||||
features: Schema.optional(Schema.Array(Schema.String)),
|
||||
features: Schema.Array(Schema.String),
|
||||
})
|
||||
type Registration = typeof Registration.Type
|
||||
|
||||
@@ -48,16 +71,17 @@ export const WireResponse = Schema.Union([
|
||||
instance_id: Schema.String,
|
||||
pid: Schema.Number,
|
||||
protocol: Schema.Number,
|
||||
features: Schema.optional(Schema.Array(Schema.String)),
|
||||
features: Schema.Array(Schema.String),
|
||||
}),
|
||||
Schema.Struct({ type: Schema.Literal("created"), terminal: WireTerminal }),
|
||||
Schema.Struct({ type: Schema.Literal("terminals"), terminals: Schema.Array(WireTerminal) }),
|
||||
Schema.Struct({ type: Schema.Literal("created"), process: ProcessInfo }),
|
||||
Schema.Struct({ type: Schema.Literal("processes"), processes: Schema.Array(ProcessInfo) }),
|
||||
Schema.Struct({ type: Schema.Literal("process"), process: ProcessInfo }),
|
||||
Schema.Struct({ type: Schema.Literal("ok") }),
|
||||
Schema.Struct({ type: Schema.Literal("owned") }),
|
||||
Schema.Struct({ type: Schema.Literal("handoff"), ticket: Schema.String, expires_at: Schema.Number }),
|
||||
Schema.Struct({
|
||||
type: Schema.Literal("snapshot"),
|
||||
terminal: WireTerminal,
|
||||
process: ProcessInfo,
|
||||
text: Schema.String,
|
||||
checkpoint_base64: Schema.String,
|
||||
cursor_x: Schema.Number,
|
||||
@@ -65,14 +89,14 @@ export const WireResponse = Schema.Union([
|
||||
}),
|
||||
Schema.Struct({
|
||||
type: Schema.Literal("rows"),
|
||||
terminal: WireTerminal,
|
||||
process: ProcessInfo,
|
||||
lines: Schema.Array(Schema.String),
|
||||
cursor_x: Schema.Number,
|
||||
cursor_y: Schema.Number,
|
||||
}),
|
||||
Schema.Struct({
|
||||
type: Schema.Literal("attached"),
|
||||
terminal: WireTerminal,
|
||||
process: ProcessInfo,
|
||||
role: Schema.Literals(["controller", "observer"]),
|
||||
generation: Schema.Number,
|
||||
requested_offset: Schema.Number,
|
||||
@@ -91,7 +115,12 @@ export const WireResponse = Schema.Union([
|
||||
Schema.Struct({
|
||||
type: Schema.Literal("exited"),
|
||||
exit_code: Schema.NullOr(Schema.Number),
|
||||
signal: Schema.optional(Schema.NullOr(Schema.String)),
|
||||
final_offset: Schema.Number,
|
||||
// Pipe processes only.
|
||||
output_lines: Schema.optional(Schema.Number),
|
||||
output_error: Schema.optional(Schema.NullOr(Schema.String)),
|
||||
exited_at: Schema.Number,
|
||||
}),
|
||||
Schema.Struct({
|
||||
type: Schema.Literal("controller_changed"),
|
||||
@@ -103,6 +132,7 @@ export const WireResponse = Schema.Union([
|
||||
Schema.Struct({ type: Schema.Literal("error"), message: Schema.String }),
|
||||
])
|
||||
export type WireResponse = typeof WireResponse.Type
|
||||
export type Exited = Extract<WireResponse, { type: "exited" }>
|
||||
|
||||
export type Role = "controller" | "observer"
|
||||
|
||||
@@ -130,7 +160,7 @@ export type SubscribeInput = {
|
||||
}
|
||||
|
||||
export type DaemonAttachment = {
|
||||
readonly terminal: WireTerminal
|
||||
readonly terminal: ProcessInfo
|
||||
readonly role: Role
|
||||
readonly generation: number
|
||||
readonly replay: {
|
||||
@@ -144,8 +174,13 @@ export type DaemonAttachment = {
|
||||
readonly detach: () => void
|
||||
}
|
||||
|
||||
/**
|
||||
* `connect`, `spawn`, `registration` and `protocol` mean the daemon could not be reached or started and the
|
||||
* request never ran. `response` means the request was sent but its reply was lost. `request` is the daemon's
|
||||
* own `error` reply.
|
||||
*/
|
||||
export class DaemonError extends Data.TaggedError("PersistentPty.DaemonError")<{
|
||||
readonly kind: "connect" | "response" | "registration" | "protocol" | "spawn"
|
||||
readonly kind: "connect" | "response" | "registration" | "protocol" | "spawn" | "request"
|
||||
readonly message: string
|
||||
readonly pid?: number
|
||||
}> {}
|
||||
@@ -153,13 +188,11 @@ export class DaemonError extends Data.TaggedError("PersistentPty.DaemonError")<{
|
||||
export interface DaemonTransport {
|
||||
readonly request: (value: object, start?: boolean) => Effect.Effect<WireResponse, DaemonError>
|
||||
readonly requestIfRunning: (value: object) => Effect.Effect<WireResponse | undefined, DaemonError>
|
||||
readonly supports: (feature: string) => Effect.Effect<boolean, DaemonError>
|
||||
/** Waits on its own connection, with no timeout, until the pipe process exits. Never starts the daemon. */
|
||||
readonly wait: (id: number) => Effect.Effect<Exited, DaemonError>
|
||||
readonly shutdown: Effect.Effect<WireResponse | undefined, DaemonError>
|
||||
readonly handoff: Effect.Effect<Handoff | null, DaemonError>
|
||||
readonly subscribe: (
|
||||
id: number,
|
||||
input: SubscribeInput,
|
||||
) => Effect.Effect<DaemonAttachment, DaemonError>
|
||||
readonly subscribe: (id: number, input: SubscribeInput) => Effect.Effect<DaemonAttachment, DaemonError>
|
||||
}
|
||||
|
||||
export const makeDaemonTransport = Effect.fn("PersistentPty.makeDaemonTransport")(function* (
|
||||
@@ -174,6 +207,8 @@ export const makeDaemonTransport = Effect.fn("PersistentPty.makeDaemonTransport"
|
||||
let registration: Registration | undefined
|
||||
let owner: Awaited<ReturnType<typeof openOwner>> | undefined
|
||||
let closed = false
|
||||
// Set once a daemon we spawned turned out to speak another protocol.
|
||||
let incompatible: DaemonError | undefined
|
||||
yield* Effect.addFinalizer(() =>
|
||||
Effect.sync(() => {
|
||||
closed = true
|
||||
@@ -229,8 +264,7 @@ export const makeDaemonTransport = Effect.fn("PersistentPty.makeDaemonTransport"
|
||||
response.protocol !== ProtocolVersion
|
||||
)
|
||||
return yield* Effect.fail(new DaemonError({ kind: "protocol", message: "opencode-pty registration mismatch" }))
|
||||
// Daemons older than the features list omit it; trust the live daemon's answer over the file.
|
||||
return { ...decoded, features: response.features ?? [] }
|
||||
return decoded
|
||||
})
|
||||
|
||||
const spawnDaemon = Effect.fn("PersistentPty.daemon.spawn")(function* () {
|
||||
@@ -238,11 +272,11 @@ export const makeDaemonTransport = Effect.fn("PersistentPty.makeDaemonTransport"
|
||||
const child = yield* Effect.tryPromise({
|
||||
try: () =>
|
||||
new Promise<ReturnType<typeof spawn>>((resolve, reject) => {
|
||||
const child = spawn(
|
||||
executable,
|
||||
["daemon", "--runtime-dir", root, "--name", id],
|
||||
{ detached: true, windowsHide: true, stdio: "ignore" },
|
||||
)
|
||||
const child = spawn(executable, ["daemon", "--runtime-dir", root, "--name", id], {
|
||||
detached: true,
|
||||
windowsHide: true,
|
||||
stdio: "ignore",
|
||||
})
|
||||
child.once("spawn", () => {
|
||||
child.unref()
|
||||
resolve(child)
|
||||
@@ -258,6 +292,11 @@ export const makeDaemonTransport = Effect.fn("PersistentPty.makeDaemonTransport"
|
||||
const found = yield* discover().pipe(
|
||||
Effect.map((value) => ({ value })),
|
||||
Effect.catch((error) => {
|
||||
// The binary we just started speaks another protocol: waiting longer cannot help.
|
||||
if (error.kind === "protocol" && error.pid !== undefined && error.pid === child.pid) {
|
||||
incompatible = error
|
||||
return Effect.fail(error)
|
||||
}
|
||||
last = error
|
||||
return Effect.succeed(undefined)
|
||||
}),
|
||||
@@ -280,11 +319,13 @@ export const makeDaemonTransport = Effect.fn("PersistentPty.makeDaemonTransport"
|
||||
)
|
||||
})
|
||||
|
||||
// An unreachable daemon can still hold this directory's lock, so retry once in a fresh directory.
|
||||
// An unreachable daemon, or one left by another release, can still hold this directory's lock, so retry once in a
|
||||
// fresh directory. A binary that cannot be spawned, or that speaks another protocol, fails the same way again.
|
||||
const start = () =>
|
||||
spawnDaemon().pipe(
|
||||
Effect.catch((error) =>
|
||||
Effect.gen(function* () {
|
||||
if (error.kind === "spawn" || error === incompatible) return yield* Effect.fail(error)
|
||||
yield* Effect.logWarning("Starting opencode-pty in a fresh runtime directory", { cause: error.message })
|
||||
abandon()
|
||||
return yield* spawnDaemon()
|
||||
@@ -307,7 +348,8 @@ export const makeDaemonTransport = Effect.fn("PersistentPty.makeDaemonTransport"
|
||||
if (registration) return registration
|
||||
const found = yield* discover().pipe(
|
||||
Effect.catch((error) => {
|
||||
if (shouldStart && error.kind === "connect") return start()
|
||||
// Starting the same incompatible binary again would only fail again.
|
||||
if (shouldStart && error.kind === "connect") return incompatible ? Effect.fail(incompatible) : start()
|
||||
return Effect.fail(error)
|
||||
}),
|
||||
)
|
||||
@@ -351,9 +393,14 @@ export const makeDaemonTransport = Effect.fn("PersistentPty.makeDaemonTransport"
|
||||
Effect.catch((error) => (error.kind === "connect" ? Effect.succeed(undefined) : Effect.fail(error))),
|
||||
)
|
||||
|
||||
const supports = Effect.fn("PersistentPty.daemon.supports")(function* (feature: string) {
|
||||
const current = yield* connect(false)
|
||||
return current.features?.includes(feature) ?? false
|
||||
const wait = Effect.fn("PersistentPty.daemon.wait")(function* (processID: number) {
|
||||
const attempt = withRegistration(false, (current) =>
|
||||
Effect.tryPromise({
|
||||
try: (signal) => waitPromise(current, processID, signal),
|
||||
catch: (cause) => (cause instanceof DaemonError ? cause : failure("connect", cause)),
|
||||
}),
|
||||
)
|
||||
return yield* attempt.pipe(Effect.catch((error) => (error.kind === "registration" ? attempt : Effect.fail(error))))
|
||||
})
|
||||
|
||||
const shutdown = Effect.gen(function* () {
|
||||
@@ -398,10 +445,7 @@ export const makeDaemonTransport = Effect.fn("PersistentPty.makeDaemonTransport"
|
||||
}),
|
||||
)
|
||||
|
||||
const subscribe = Effect.fn("PersistentPty.daemon.subscribe")(function* (
|
||||
terminalID: number,
|
||||
input: SubscribeInput,
|
||||
) {
|
||||
const subscribe = Effect.fn("PersistentPty.daemon.subscribe")(function* (terminalID: number, input: SubscribeInput) {
|
||||
const attempt = withRegistration(false, (current) =>
|
||||
Effect.tryPromise({
|
||||
try: () => subscribePromise(current, terminalID, input),
|
||||
@@ -418,13 +462,10 @@ export const makeDaemonTransport = Effect.fn("PersistentPty.makeDaemonTransport"
|
||||
yield* Effect.gen(function* () {
|
||||
if (inherited.expiresAt <= Date.now())
|
||||
return yield* Effect.fail(new DaemonError({ kind: "registration", message: "PTY restart handoff expired" }))
|
||||
// Older releases put the daemon directory outside the root; its directory name is still the ID.
|
||||
id = path.basename(inherited.directory)
|
||||
found = yield* discover(inherited.directory)
|
||||
if (found.instance_id !== inherited.instanceID)
|
||||
return yield* Effect.fail(new DaemonError({ kind: "registration", message: "PTY restart daemon changed" }))
|
||||
if (path.resolve(inherited.directory) !== path.resolve(root, id))
|
||||
yield* migrate(inherited.directory, path.join(root, id))
|
||||
yield* claim(found, inherited.ticket)
|
||||
}).pipe(
|
||||
Effect.catchCause((cause) =>
|
||||
@@ -440,20 +481,7 @@ export const makeDaemonTransport = Effect.fn("PersistentPty.makeDaemonTransport"
|
||||
)
|
||||
}
|
||||
|
||||
return { request, requestIfRunning, supports, shutdown, handoff, subscribe } satisfies DaemonTransport
|
||||
})
|
||||
|
||||
// Older releases kept registrations in purgeable temp directories. Renaming keeps the lock file's
|
||||
// inode, so the still-running daemon keeps holding its lock in the new location.
|
||||
const migrate = Effect.fn("PersistentPty.daemon.migrate")(function* (directory: string, target: string) {
|
||||
yield* Effect.tryPromise({
|
||||
try: async () => {
|
||||
await mkdir(target, { recursive: true, mode: 0o700 })
|
||||
await rename(path.join(directory, "service.lock"), path.join(target, "service.lock"))
|
||||
await rename(path.join(directory, "service.json"), path.join(target, "service.json"))
|
||||
},
|
||||
catch: (cause) => failure("registration", cause),
|
||||
})
|
||||
return { request, requestIfRunning, wait, shutdown, handoff, subscribe } satisfies DaemonTransport
|
||||
})
|
||||
|
||||
async function openOwner(registration: Registration, ticket: string | undefined, signal: AbortSignal) {
|
||||
@@ -535,7 +563,7 @@ const oneShot = Effect.fn("PersistentPty.daemon.oneShot")(function* (registratio
|
||||
})
|
||||
const response = yield* Effect.try({
|
||||
try: () => decode(first),
|
||||
catch: (cause) => failure("protocol", cause),
|
||||
catch: (cause) => failure("response", cause),
|
||||
})
|
||||
if (response.type === "error") return yield* Effect.fail(responseError(response.message))
|
||||
return response
|
||||
@@ -632,7 +660,7 @@ async function subscribePromise(
|
||||
}
|
||||
let activated = false
|
||||
return {
|
||||
terminal: response.terminal,
|
||||
terminal: response.process,
|
||||
role: response.role,
|
||||
generation: response.generation,
|
||||
replay: {
|
||||
@@ -659,6 +687,29 @@ async function subscribePromise(
|
||||
}
|
||||
}
|
||||
|
||||
async function waitPromise(registration: Registration, id: number, signal: AbortSignal): Promise<Exited> {
|
||||
const socket = net.createConnection({ path: registration.socket })
|
||||
const abort = () => socket.destroy()
|
||||
signal.addEventListener("abort", abort, { once: true })
|
||||
try {
|
||||
await new Promise<void>((resolve, reject) => {
|
||||
socket.once("connect", resolve)
|
||||
socket.once("error", reject)
|
||||
})
|
||||
socket.write(encode({ token: registration.token, request: { op: "wait", id } }))
|
||||
const frame = await decoder(socket).next()
|
||||
// The connection was open, so a missing reply means the daemon went away while the process ran.
|
||||
if (frame.done) throw failure("connect", "opencode-pty closed before the process exited")
|
||||
const response = decode(frame.value)
|
||||
if (response.type === "error") throw responseError(response.message)
|
||||
if (response.type !== "exited") throw failure("response", `unexpected opencode-pty response: ${response.type}`)
|
||||
return response
|
||||
} finally {
|
||||
signal.removeEventListener("abort", abort)
|
||||
socket.destroy()
|
||||
}
|
||||
}
|
||||
|
||||
function encode(value: unknown) {
|
||||
const payload = Buffer.from(JSON.stringify(value))
|
||||
if (payload.length > MaxFrameBytes) throw new Error("opencode-pty frame too large")
|
||||
@@ -691,7 +742,7 @@ function decode(payload: Uint8Array) {
|
||||
}
|
||||
|
||||
function responseError(message: string) {
|
||||
return new DaemonError({ kind: message === "authentication failed" ? "registration" : "protocol", message })
|
||||
return new DaemonError({ kind: message === "authentication failed" ? "registration" : "request", message })
|
||||
}
|
||||
|
||||
function failure(kind: DaemonError["kind"], cause: unknown) {
|
||||
|
||||
@@ -22,15 +22,19 @@ import { ShellSelect } from "../shell/select.js"
|
||||
import {
|
||||
makeDaemonTransport,
|
||||
type DaemonAttachment,
|
||||
type DaemonError,
|
||||
type DaemonTransport,
|
||||
type Exited,
|
||||
type Metadata,
|
||||
type ProcessInfo,
|
||||
type Role,
|
||||
type Signal,
|
||||
type SubscribeInput,
|
||||
type WireResponse,
|
||||
type WireTerminal,
|
||||
} from "./daemon.js"
|
||||
import { resolveBinary } from "#persistent-pty-binary"
|
||||
|
||||
export type { Role, StreamEvent } from "./daemon.js"
|
||||
export type { Metadata, Role, Signal, StreamEvent } from "./daemon.js"
|
||||
export { Handoff } from "@opencode/schema/persistent-pty"
|
||||
export { available } from "#persistent-pty-binary"
|
||||
|
||||
@@ -54,22 +58,73 @@ export type Attachment = {
|
||||
readonly detach: () => void
|
||||
}
|
||||
|
||||
/** The daemon could not be reached or started; the request never ran. */
|
||||
export class UnavailableError extends Schema.TaggedError<UnavailableError>()("PersistentPty.UnavailableError", {
|
||||
message: Schema.String,
|
||||
}) {}
|
||||
|
||||
/** The daemon rejected the request, or its reply was lost after it was sent, so it may have run. */
|
||||
export class RequestError extends Schema.TaggedError<RequestError>()("PersistentPty.RequestError", {
|
||||
message: Schema.String,
|
||||
}) {}
|
||||
|
||||
export class NotFoundError extends Schema.TaggedError<NotFoundError>()("PersistentPty.NotFoundError", {
|
||||
ptyID: Pty.ID,
|
||||
}) {}
|
||||
|
||||
export class ProcessNotFoundError extends Schema.TaggedError<ProcessNotFoundError>()(
|
||||
"PersistentPty.ProcessNotFoundError",
|
||||
{ processID: Schema.Number },
|
||||
) {}
|
||||
|
||||
export class InvalidCwdError extends Schema.TaggedError<InvalidCwdError>()("PersistentPty.InvalidCwdError", {
|
||||
cwd: Schema.String,
|
||||
message: Schema.String,
|
||||
}) {}
|
||||
|
||||
export class UnsupportedError extends Schema.TaggedError<UnsupportedError>()("PersistentPty.UnsupportedError", {
|
||||
feature: Schema.String,
|
||||
}) {}
|
||||
/** A non-PTY process run by the daemon, its output written to `outputPath`. */
|
||||
export type PipeInfo = {
|
||||
readonly id: number
|
||||
readonly pid: number | undefined
|
||||
readonly command: readonly string[]
|
||||
readonly cwd: string
|
||||
readonly groupID: string
|
||||
readonly lifecycle:
|
||||
| { readonly status: "running" }
|
||||
| { readonly status: "exited"; readonly exitCode: number | undefined; readonly signal: string | undefined }
|
||||
| { readonly status: "failed"; readonly message: string }
|
||||
/** Bytes counted so far; the file can hold a little more. Pair only bytes up to here with `outputLines`. */
|
||||
readonly outputTail: number
|
||||
readonly outputLines: number
|
||||
readonly outputPath: string
|
||||
readonly outputError: string | undefined
|
||||
readonly metadata: Metadata
|
||||
readonly startedAt: number
|
||||
readonly exitedAt: number | undefined
|
||||
}
|
||||
|
||||
export type PipeExit = {
|
||||
readonly exitCode: number | undefined
|
||||
readonly signal: string | undefined
|
||||
/** Runs past the file's size when `outputError` is set; use the file's real size instead. */
|
||||
readonly finalOffset: number
|
||||
readonly outputLines: number
|
||||
readonly outputError: string | undefined
|
||||
readonly exitedAt: number
|
||||
}
|
||||
|
||||
export type CreatePipeInput = {
|
||||
readonly program: string
|
||||
readonly args: readonly string[]
|
||||
/** Absolute. */
|
||||
readonly cwd: string
|
||||
/** The child's whole environment; the daemon's own is not inherited. */
|
||||
readonly env: Readonly<Record<string, string>>
|
||||
readonly groupID: string
|
||||
/** Absolute; truncated on open, symlinks refused. */
|
||||
readonly outputPath: string
|
||||
readonly metadata: Metadata
|
||||
}
|
||||
|
||||
export interface Interface {
|
||||
readonly list: (sessionID?: Session.ID) => Effect.Effect<Info[], UnavailableError>
|
||||
@@ -110,19 +165,27 @@ export interface Interface {
|
||||
rows: number,
|
||||
data: Uint8Array,
|
||||
) => Effect.Effect<void, NotFoundError | UnavailableError>
|
||||
readonly rename: (
|
||||
id: Pty.ID,
|
||||
title: string | null,
|
||||
) => Effect.Effect<Info, NotFoundError | UnsupportedError | UnavailableError>
|
||||
readonly rename: (id: Pty.ID, title: string | null) => Effect.Effect<Info, NotFoundError | UnavailableError>
|
||||
readonly snapshot: (id: Pty.ID) => Effect.Effect<Snapshot, NotFoundError | UnavailableError>
|
||||
readonly read: (sessionID: Session.ID, lines?: number) => Effect.Effect<ReadResult | null, UnavailableError>
|
||||
readonly remove: (id: Pty.ID) => Effect.Effect<void, NotFoundError | UnavailableError>
|
||||
readonly shutdown: () => Effect.Effect<void, UnavailableError>
|
||||
readonly handoff: () => Effect.Effect<Handoff | null, UnavailableError>
|
||||
readonly attach: (
|
||||
id: Pty.ID,
|
||||
input: SubscribeInput,
|
||||
) => Effect.Effect<Attachment, NotFoundError | UnavailableError>
|
||||
readonly attach: (id: Pty.ID, input: SubscribeInput) => Effect.Effect<Attachment, NotFoundError | UnavailableError>
|
||||
/** Starts the daemon if needed. Fall back to another spawner only on `UnavailableError`. */
|
||||
readonly createPipe: (input: CreatePipeInput) => Effect.Effect<PipeInfo, UnavailableError | RequestError>
|
||||
/** Resolves when the process exits, on its own connection with no timeout; interrupting closes it. */
|
||||
readonly waitPipe: (id: number) => Effect.Effect<PipeExit, UnavailableError | RequestError>
|
||||
/** `ProcessNotFoundError` for an unknown id, a PTY, or when no daemon is running. */
|
||||
readonly getPipe: (id: number) => Effect.Effect<PipeInfo, ProcessNotFoundError | UnavailableError>
|
||||
/** Signals the process group without forgetting the process; `waitPipe` then reports the signal. */
|
||||
readonly signalPipe: (id: number, signal: Signal) => Effect.Effect<void, UnavailableError | RequestError>
|
||||
/** Replaces the stored metadata. */
|
||||
readonly setPipeMetadata: (id: number, metadata: Metadata) => Effect.Effect<void, UnavailableError | RequestError>
|
||||
/** Kills the process if it still runs and forgets it; the output file is left alone. */
|
||||
readonly terminatePipe: (id: number) => Effect.Effect<void, UnavailableError | RequestError>
|
||||
/** Never starts the daemon; empty when none is running. */
|
||||
readonly listPipes: () => Effect.Effect<PipeInfo[], UnavailableError | RequestError>
|
||||
}
|
||||
|
||||
export class Service extends Context.Service<Service, Interface>()("@opencode/PersistentPty") {}
|
||||
@@ -151,18 +214,21 @@ const makeLayer = (options: Options = {}) =>
|
||||
const current = new Map<Session.ID, Pty.ID>()
|
||||
|
||||
const list = Effect.fn("PersistentPty.list")(function* (sessionID?: Session.ID) {
|
||||
const response = yield* optionalRequest(daemon, { op: "list" })
|
||||
const response = yield* optionalRequest(daemon, { op: "list", mode: "pty" })
|
||||
if (!response) return []
|
||||
if (response.type !== "terminals") return yield* unexpected(response)
|
||||
return response.terminals
|
||||
if (response.type !== "processes") return yield* unexpected(response)
|
||||
return response.processes
|
||||
.map(toInfo)
|
||||
.filter((terminal) => sessionID === undefined || terminal.sessionID === sessionID)
|
||||
})
|
||||
|
||||
const get = Effect.fn("PersistentPty.get")(function* (id: Pty.ID) {
|
||||
const found = (yield* list()).find((terminal) => terminal.id === id)
|
||||
if (!found) return yield* new NotFoundError({ ptyID: id })
|
||||
return found
|
||||
// Any ID that is not one of ours names no terminal; every other method looks the terminal up here first.
|
||||
const parsed = parseID(id)
|
||||
const found =
|
||||
parsed === undefined ? undefined : yield* lookup(daemon, parsed).pipe(Effect.mapError(unavailable))
|
||||
if (found?.mode !== "pty") return yield* new NotFoundError({ ptyID: id })
|
||||
return toInfo(found)
|
||||
})
|
||||
|
||||
const create = Effect.fn("PersistentPty.create")(function* (
|
||||
@@ -181,7 +247,7 @@ const makeLayer = (options: Options = {}) =>
|
||||
const response = yield* request(
|
||||
daemon,
|
||||
{
|
||||
op: "create",
|
||||
op: "create_pty",
|
||||
program: input.command ?? ShellSelect.environment(global.bin),
|
||||
args: input.args,
|
||||
cwd,
|
||||
@@ -194,7 +260,7 @@ const makeLayer = (options: Options = {}) =>
|
||||
true,
|
||||
)
|
||||
if (response.type !== "created") return yield* unexpected(response)
|
||||
const terminal = toInfo(response.terminal)
|
||||
const terminal = toInfo(response.process)
|
||||
yield* bus.publish(Added, { sessionID, terminal })
|
||||
return terminal
|
||||
})
|
||||
@@ -217,8 +283,9 @@ const makeLayer = (options: Options = {}) =>
|
||||
),
|
||||
)
|
||||
|
||||
const resize = Effect.fn("PersistentPty.resize")((id: Pty.ID, cols: number, rows: number, attachmentID?: string) =>
|
||||
command(id, "resize", { attachment_id: attachmentID ?? null, cols, rows }, true),
|
||||
const resize = Effect.fn("PersistentPty.resize")(
|
||||
(id: Pty.ID, cols: number, rows: number, attachmentID?: string) =>
|
||||
command(id, "resize", { attachment_id: attachmentID ?? null, cols, rows }, true),
|
||||
)
|
||||
|
||||
const control = Effect.fn("PersistentPty.control")(
|
||||
@@ -238,9 +305,6 @@ const makeLayer = (options: Options = {}) =>
|
||||
|
||||
const rename = Effect.fn("PersistentPty.rename")(function* (id: Pty.ID, title: string | null) {
|
||||
const terminal = yield* get(id)
|
||||
// Daemons without the feature drop the connection on unknown requests.
|
||||
if (!(yield* daemon.supports("rename").pipe(Effect.mapError(unavailable))))
|
||||
return yield* new UnsupportedError({ feature: "rename" })
|
||||
const response = yield* request(daemon, { op: "rename", id: fromID(id), title })
|
||||
if (response.type !== "ok") return yield* unexpected(response)
|
||||
const renamed = yield* get(id)
|
||||
@@ -253,7 +317,7 @@ const makeLayer = (options: Options = {}) =>
|
||||
const response = yield* request(daemon, { op: "snapshot", id: fromID(id) })
|
||||
if (response.type !== "snapshot") return yield* unexpected(response)
|
||||
return {
|
||||
info: toInfo(response.terminal),
|
||||
info: toInfo(response.process),
|
||||
text: response.text,
|
||||
checkpoint: Buffer.from(response.checkpoint_base64, "base64"),
|
||||
cursor: { x: response.cursor_x, y: response.cursor_y },
|
||||
@@ -273,7 +337,7 @@ const makeLayer = (options: Options = {}) =>
|
||||
// Let the daemon choose the live height in the same snapshot when lines is omitted.
|
||||
const response = yield* request(daemon, { op: "read_rows", id: fromID(id), rows: lines })
|
||||
if (response.type !== "rows") return yield* unexpected(response)
|
||||
const info = toInfo(response.terminal)
|
||||
const info = toInfo(response.process)
|
||||
return {
|
||||
ptyID: info.id,
|
||||
title: info.title,
|
||||
@@ -367,9 +431,10 @@ const makeLayer = (options: Options = {}) =>
|
||||
},
|
||||
})
|
||||
.pipe(Effect.mapError(unavailable))
|
||||
if (attachment.role === "controller") current.set(attachment.terminal.group_id, id)
|
||||
const info = toInfo(attachment.terminal)
|
||||
if (attachment.role === "controller") current.set(info.sessionID, id)
|
||||
return {
|
||||
info: toInfo(attachment.terminal),
|
||||
info,
|
||||
role: attachment.role,
|
||||
generation: attachment.generation,
|
||||
replay: attachment.replay,
|
||||
@@ -378,6 +443,61 @@ const makeLayer = (options: Options = {}) =>
|
||||
}
|
||||
})
|
||||
|
||||
const createPipe = Effect.fn("PersistentPty.createPipe")(function* (input: CreatePipeInput) {
|
||||
const response = yield* daemon
|
||||
.request(
|
||||
{
|
||||
op: "create_pipe",
|
||||
program: input.program,
|
||||
args: input.args,
|
||||
cwd: input.cwd,
|
||||
env: input.env,
|
||||
group_id: input.groupID,
|
||||
output_path: input.outputPath,
|
||||
metadata: input.metadata,
|
||||
},
|
||||
true,
|
||||
)
|
||||
.pipe(Effect.mapError(pipeError))
|
||||
if (response.type !== "created") return yield* unexpectedPipe(response)
|
||||
return toPipeInfo(response.process)
|
||||
})
|
||||
|
||||
const waitPipe = Effect.fn("PersistentPty.waitPipe")(function* (id: number) {
|
||||
return toPipeExit(yield* daemon.wait(id).pipe(Effect.mapError(pipeError)))
|
||||
})
|
||||
|
||||
const getPipe = Effect.fn("PersistentPty.getPipe")(function* (id: number) {
|
||||
const found = yield* lookup(daemon, id).pipe(Effect.mapError(unavailable))
|
||||
if (found?.mode !== "pipe") return yield* new ProcessNotFoundError({ processID: id })
|
||||
return toPipeInfo(found)
|
||||
})
|
||||
|
||||
const pipeCommand = (value: object) =>
|
||||
Effect.gen(function* () {
|
||||
const response = yield* daemon.request(value).pipe(Effect.mapError(pipeError))
|
||||
if (response.type !== "ok") return yield* unexpectedPipe(response)
|
||||
})
|
||||
|
||||
const signalPipe = Effect.fn("PersistentPty.signalPipe")((id: number, signal: Signal) =>
|
||||
pipeCommand({ op: "signal", id, signal }),
|
||||
)
|
||||
|
||||
const setPipeMetadata = Effect.fn("PersistentPty.setPipeMetadata")((id: number, metadata: Metadata) =>
|
||||
pipeCommand({ op: "set_metadata", id, metadata }),
|
||||
)
|
||||
|
||||
const terminatePipe = Effect.fn("PersistentPty.terminatePipe")((id: number) =>
|
||||
pipeCommand({ op: "terminate", id }),
|
||||
)
|
||||
|
||||
const listPipes = Effect.fn("PersistentPty.listPipes")(function* () {
|
||||
const response = yield* daemon.requestIfRunning({ op: "list", mode: "pipe" }).pipe(Effect.mapError(pipeError))
|
||||
if (!response) return []
|
||||
if (response.type !== "processes") return yield* unexpectedPipe(response)
|
||||
return response.processes.map(toPipeInfo)
|
||||
})
|
||||
|
||||
return Service.of({
|
||||
list,
|
||||
get,
|
||||
@@ -393,11 +513,19 @@ const makeLayer = (options: Options = {}) =>
|
||||
shutdown,
|
||||
handoff,
|
||||
attach,
|
||||
createPipe,
|
||||
waitPipe,
|
||||
getPipe,
|
||||
signalPipe,
|
||||
setPipeMetadata,
|
||||
terminatePipe,
|
||||
listPipes,
|
||||
})
|
||||
}),
|
||||
)
|
||||
|
||||
export const layer = makeLayer()
|
||||
export const layerWith = (options: Options) => makeLayer(options)
|
||||
export const configured = (options?: Options) =>
|
||||
makeGlobalNode({
|
||||
service: Service,
|
||||
@@ -412,40 +540,108 @@ const request = (daemon: DaemonTransport, value: object, start = false) =>
|
||||
const optionalRequest = (daemon: DaemonTransport, value: object) =>
|
||||
daemon.requestIfRunning(value).pipe(Effect.mapError(unavailable))
|
||||
|
||||
// `get` fails only for an unknown id, and no running daemon has no processes.
|
||||
const lookup = (daemon: DaemonTransport, id: number) =>
|
||||
daemon.requestIfRunning({ op: "get", id }).pipe(
|
||||
Effect.catchIf(
|
||||
(error) => error.kind === "request",
|
||||
() => Effect.succeed(undefined),
|
||||
),
|
||||
Effect.flatMap((response) => {
|
||||
if (!response) return Effect.succeed(undefined)
|
||||
if (response.type !== "process")
|
||||
return Effect.fail(new Error(`unexpected opencode-pty response: ${response.type}`))
|
||||
return Effect.succeed(response.process)
|
||||
}),
|
||||
)
|
||||
|
||||
const unexpected = (response: WireResponse) =>
|
||||
Effect.fail(new UnavailableError({ message: `unexpected opencode-pty response: ${response.type}` }))
|
||||
|
||||
const unavailable = (error: unknown) =>
|
||||
new UnavailableError({ message: error instanceof Error ? error.message : String(error) })
|
||||
|
||||
function toInfo(value: WireTerminal): Info {
|
||||
// Only a failure before the request was sent is safe to retry somewhere else.
|
||||
const pipeError = (error: DaemonError) =>
|
||||
error.kind === "request" || error.kind === "response"
|
||||
? new RequestError({ message: error.message })
|
||||
: new UnavailableError({ message: error.message })
|
||||
|
||||
const unexpectedPipe = (response: WireResponse) =>
|
||||
Effect.fail(new RequestError({ message: `unexpected opencode-pty response: ${response.type}` }))
|
||||
|
||||
function toInfo(value: ProcessInfo): Info {
|
||||
if (!value.pty) throw new Error(`opencode-pty process ${value.id} is not a terminal`)
|
||||
const status = value.lifecycle.status
|
||||
return {
|
||||
...Pty.Info.make({
|
||||
id: toID(value.id),
|
||||
title: value.title,
|
||||
title: value.pty.title,
|
||||
command: value.command[0] || "",
|
||||
args: value.command.slice(1),
|
||||
cwd: value.cwd,
|
||||
status: status === "running" ? "running" : "exited",
|
||||
pid: value.pid ?? 0,
|
||||
...(status === "exited" ? { exitCode: value.lifecycle.exit_code ?? undefined } : {}),
|
||||
...(value.lifecycle.status === "exited" ? { exitCode: value.lifecycle.exit_code ?? undefined } : {}),
|
||||
}),
|
||||
sessionID: value.group_id,
|
||||
userTitle: value.user_title ?? null,
|
||||
foregroundProcess: value.foreground_process,
|
||||
size: { cols: value.cols, rows: value.rows },
|
||||
// Terminals are always created with a session ID as their group.
|
||||
sessionID: Session.ID.make(value.group_id),
|
||||
userTitle: value.pty.user_title,
|
||||
foregroundProcess: value.pty.foreground_process,
|
||||
size: { cols: value.pty.cols, rows: value.pty.rows },
|
||||
output: { head: value.output_head, tail: value.output_tail },
|
||||
}
|
||||
}
|
||||
|
||||
function toPipeInfo(value: ProcessInfo): PipeInfo {
|
||||
if (!value.pipe) throw new Error(`opencode-pty process ${value.id} is not a pipe process`)
|
||||
return {
|
||||
id: value.id,
|
||||
pid: value.pid ?? undefined,
|
||||
command: value.command,
|
||||
cwd: value.cwd,
|
||||
groupID: value.group_id,
|
||||
lifecycle:
|
||||
value.lifecycle.status === "exited"
|
||||
? {
|
||||
status: "exited",
|
||||
exitCode: value.lifecycle.exit_code ?? undefined,
|
||||
signal: value.lifecycle.signal ?? undefined,
|
||||
}
|
||||
: value.lifecycle,
|
||||
outputTail: value.output_tail,
|
||||
outputLines: value.pipe.output_lines,
|
||||
outputPath: value.pipe.output_path,
|
||||
outputError: value.pipe.output_error ?? undefined,
|
||||
metadata: value.pipe.metadata,
|
||||
startedAt: value.started_at,
|
||||
exitedAt: value.exited_at ?? undefined,
|
||||
}
|
||||
}
|
||||
|
||||
function toPipeExit(value: Exited): PipeExit {
|
||||
return {
|
||||
exitCode: value.exit_code ?? undefined,
|
||||
signal: value.signal ?? undefined,
|
||||
finalOffset: value.final_offset,
|
||||
outputLines: value.output_lines ?? 0,
|
||||
outputError: value.output_error ?? undefined,
|
||||
exitedAt: value.exited_at,
|
||||
}
|
||||
}
|
||||
|
||||
function toID(value: number) {
|
||||
return Pty.ID.make(`pty_persistent_${value}`)
|
||||
}
|
||||
|
||||
function fromID(value: Pty.ID) {
|
||||
if (!value.startsWith("pty_persistent_")) throw new Error(`invalid persistent PTY ID: ${value}`)
|
||||
function parseID(value: Pty.ID) {
|
||||
if (!value.startsWith("pty_persistent_")) return undefined
|
||||
const parsed = Number(value.slice("pty_persistent_".length))
|
||||
if (!Number.isSafeInteger(parsed) || parsed < 1) throw new Error(`invalid persistent PTY ID: ${value}`)
|
||||
return Number.isSafeInteger(parsed) && parsed >= 1 ? parsed : undefined
|
||||
}
|
||||
|
||||
function fromID(value: Pty.ID) {
|
||||
const parsed = parseID(value)
|
||||
if (parsed === undefined) throw new Error(`invalid persistent PTY ID: ${value}`)
|
||||
return parsed
|
||||
}
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
import { appendFileSync, writeFileSync } from "node:fs"
|
||||
import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises"
|
||||
import net from "node:net"
|
||||
import os from "node:os"
|
||||
import path from "node:path"
|
||||
import { Effect } from "effect"
|
||||
|
||||
export const pong = { type: "pong", instance_id: "test", pid: process.pid, protocol: 7 }
|
||||
export const pong = { type: "pong", instance_id: "test", pid: process.pid, protocol: 8, features: [] }
|
||||
|
||||
export function temporaryDirectory() {
|
||||
return Effect.acquireRelease(
|
||||
@@ -22,14 +23,20 @@ export function listen(
|
||||
const sockets = new Set<net.Socket>()
|
||||
const server = net.createServer((socket) => {
|
||||
sockets.add(socket)
|
||||
// A client may close its end (an interrupted wait) just before a reply is written.
|
||||
socket.on("error", () => {})
|
||||
socket.once("close", () => sockets.delete(socket))
|
||||
void readRequest(socket)
|
||||
.then((envelope) => {
|
||||
const response =
|
||||
envelope.request.op === "own" ? { type: "owned" } : handle(socket, envelope.request, envelope.token)
|
||||
// The ownership connection stays open for later requests, such as handoff preparation, like the real daemon's.
|
||||
let owner = false
|
||||
const serve = (): Promise<void> =>
|
||||
readRequest(socket).then((envelope) => {
|
||||
const owning = envelope.request.op === "own"
|
||||
if (owning) owner = true
|
||||
const response = owning ? { type: "owned" } : handle(socket, envelope.request, envelope.token)
|
||||
if (response) socket.write(frame(response))
|
||||
if (owner) return serve()
|
||||
})
|
||||
.catch(() => socket.destroy())
|
||||
void serve().catch(() => socket.destroy())
|
||||
})
|
||||
await new Promise<void>((resolve, reject) => {
|
||||
server.once("error", reject)
|
||||
@@ -81,7 +88,7 @@ function readRequest(socket: net.Socket) {
|
||||
})
|
||||
}
|
||||
|
||||
function frame(value: object) {
|
||||
export function frame(value: object) {
|
||||
const payload = Buffer.from(JSON.stringify(value))
|
||||
const output = Buffer.allocUnsafe(payload.length + 4)
|
||||
output.writeUInt32BE(payload.length)
|
||||
@@ -89,70 +96,164 @@ function frame(value: object) {
|
||||
return output
|
||||
}
|
||||
|
||||
export function writeRegistration(
|
||||
directory: string,
|
||||
socket: string,
|
||||
instance = "test",
|
||||
token = "test",
|
||||
features?: string[],
|
||||
) {
|
||||
export function writeRegistration(directory: string, socket: string, instance = "test", token = "test") {
|
||||
return writeFile(
|
||||
path.join(directory, "service.json"),
|
||||
JSON.stringify({ instance_id: instance, pid: process.pid, protocol: 7, socket, token, features }),
|
||||
JSON.stringify({ instance_id: instance, pid: process.pid, protocol: 8, socket, token, features: [] }),
|
||||
)
|
||||
}
|
||||
|
||||
// An in-process opencode-pty that a server adopts through a handoff, so no daemon is spawned. Without
|
||||
// features it answers like a daemon that predates the features list.
|
||||
export const fakeDaemon = Effect.fn(function* (features?: string[]) {
|
||||
type Process = {
|
||||
id: number
|
||||
mode: "pty" | "pipe"
|
||||
pid: number | null
|
||||
command: string[]
|
||||
cwd: string
|
||||
group_id: string
|
||||
lifecycle: { status: "running" | "exited"; exit_code?: number | null; signal?: string }
|
||||
output_head: number
|
||||
output_tail: number
|
||||
started_at: number
|
||||
exited_at: number | null
|
||||
pty?: { title: string; user_title: string | null; foreground_process: string | null; cols: number; rows: number }
|
||||
pipe?: { output_path: string; output_lines: number; output_error?: string; metadata: Record<string, unknown> }
|
||||
}
|
||||
|
||||
// An in-process opencode-pty that a server adopts through a handoff, so no daemon is spawned. Pipe processes
|
||||
// run nothing: they stay running until `exit` or a signal ends them (SIGTERM spares those in `trap`), and
|
||||
// write only what `output` gives them.
|
||||
export const fakeDaemon = Effect.fn(function* () {
|
||||
const base = yield* temporaryDirectory()
|
||||
const root = path.join(base, "root")
|
||||
const directory = path.join(root, "inherited")
|
||||
const socket = path.join(base, "daemon.sock")
|
||||
const terminals: Array<ReturnType<typeof terminal> & { user_title?: string | null }> = []
|
||||
const processes: Process[] = []
|
||||
const waiters = new Map<number, net.Socket[]>()
|
||||
const failTerminate = new Set<string>()
|
||||
const trap = new Set<number>()
|
||||
const failCreate = { message: undefined as string | undefined }
|
||||
const ops: string[] = []
|
||||
const requests: Record<string, unknown>[] = []
|
||||
let nextID = 1
|
||||
|
||||
const find = (id: unknown) => processes.find((item) => item.id === id)
|
||||
const exit = (id: number, exitCode: number | null, signal?: string) => {
|
||||
const found = find(id)
|
||||
if (!found || found.lifecycle.status !== "running") return
|
||||
found.lifecycle = { status: "exited", exit_code: exitCode, signal }
|
||||
found.exited_at = Date.now()
|
||||
const reply = exited(found)
|
||||
waiters.get(id)?.forEach((connection) => connection.end(frame(reply)))
|
||||
waiters.delete(id)
|
||||
}
|
||||
|
||||
// Appends to the output file and counts it, as the daemon's reader does; after `fail`, the file stops growing.
|
||||
const output = (id: number, text: string) => {
|
||||
const found = find(id)
|
||||
if (!found?.pipe) return
|
||||
if (found.pipe.output_error === undefined) {
|
||||
appendFileSync(found.pipe.output_path, text)
|
||||
found.pipe.output_lines += text.split("\n").length - 1
|
||||
}
|
||||
found.output_tail += Buffer.byteLength(text)
|
||||
}
|
||||
// The daemon going away under a waiting server: the wait connection closes without a reply.
|
||||
const drop = (id: number) => {
|
||||
waiters.get(id)?.forEach((connection) => connection.destroy())
|
||||
waiters.delete(id)
|
||||
}
|
||||
const fail = (id: number, message: string) => {
|
||||
const found = find(id)
|
||||
if (found?.pipe) found.pipe.output_error = message
|
||||
}
|
||||
|
||||
yield* listen(socket, (connection, request) => {
|
||||
ops.push(String(request.op))
|
||||
if (request.op === "ping") return features ? { ...pong, features } : pong
|
||||
if (request.op === "list") return { type: "terminals", terminals }
|
||||
if (request.op === "create") {
|
||||
const base = terminal(nextID++, String(request.group_id))
|
||||
// A daemon that advertises features always serializes user_title.
|
||||
const created = features ? { ...base, user_title: null } : base
|
||||
terminals.push(created)
|
||||
return { type: "created", terminal: created }
|
||||
requests.push(request)
|
||||
if (request.op === "ping") return pong
|
||||
if (request.op === "list")
|
||||
return { type: "processes", processes: processes.filter((item) => item.mode === request.mode) }
|
||||
if (request.op === "get") {
|
||||
const found = find(request.id)
|
||||
if (!found) return { type: "error", message: `terminal ${String(request.id)} not found` }
|
||||
return { type: "process", process: found }
|
||||
}
|
||||
if (request.op === "create_pty") {
|
||||
const created = terminal(nextID++, String(request.group_id))
|
||||
processes.push(created)
|
||||
return { type: "created", process: created }
|
||||
}
|
||||
if (request.op === "create_pipe") {
|
||||
if (typeof request.cwd !== "string" || !path.isAbsolute(request.cwd))
|
||||
return { type: "error", message: "cwd must be absolute" }
|
||||
if (failCreate.message !== undefined) return { type: "error", message: failCreate.message }
|
||||
const created = pipe(nextID++, request)
|
||||
writeFileSync(String(request.output_path), "")
|
||||
processes.push(created)
|
||||
return { type: "created", process: created }
|
||||
}
|
||||
if (request.op === "control") return { type: "ok" }
|
||||
if (request.op === "terminate") {
|
||||
if (failTerminate.has(`pty_persistent_${request.id}`)) return { type: "error", message: "terminate failed" }
|
||||
const index = terminals.findIndex((item) => item.id === request.id)
|
||||
if (index === -1) return { type: "error", message: `terminal not found: ${String(request.id)}` }
|
||||
terminals.splice(index, 1)
|
||||
return { type: "ok" }
|
||||
}
|
||||
if (request.op === "rename" && features?.includes("rename")) {
|
||||
const found = terminals.find((item) => item.id === request.id)
|
||||
if (!found) return { type: "error", message: "terminal not found" }
|
||||
found.user_title = typeof request.title === "string" && request.title !== "" ? request.title : null
|
||||
found.title = found.user_title ?? "test"
|
||||
return { type: "ok" }
|
||||
}
|
||||
// Old daemons cannot parse unknown requests and drop the connection.
|
||||
if (request.op === "prepare_handoff") return { type: "handoff", ticket: "next", expires_at: Date.now() + 60_000 }
|
||||
if (request.op === "rename") {
|
||||
connection.destroy()
|
||||
const found = find(request.id)
|
||||
if (!found?.pty) return { type: "error", message: "terminal not found" }
|
||||
found.pty.user_title = typeof request.title === "string" && request.title !== "" ? request.title : null
|
||||
found.pty.title = found.pty.user_title ?? "test"
|
||||
return { type: "ok" }
|
||||
}
|
||||
if (request.op === "wait") {
|
||||
const found = find(request.id)
|
||||
if (!found?.pipe) return { type: "error", message: `terminal ${String(request.id)} not found` }
|
||||
if (found.lifecycle.status !== "running") return exited(found)
|
||||
waiters.set(found.id, [...(waiters.get(found.id) ?? []), connection])
|
||||
connection.once("close", () =>
|
||||
waiters.set(
|
||||
found.id,
|
||||
(waiters.get(found.id) ?? []).filter((waiter) => waiter !== connection),
|
||||
),
|
||||
)
|
||||
return undefined
|
||||
}
|
||||
return { type: "error", message: `unexpected request: ${String(request.op)}` }
|
||||
if (request.op === "signal") {
|
||||
const found = find(request.id)
|
||||
if (!found?.pipe) return { type: "error", message: `terminal ${String(request.id)} not found` }
|
||||
if (request.signal !== "SIGTERM" || !trap.has(found.id)) exit(found.id, null, String(request.signal))
|
||||
return { type: "ok" }
|
||||
}
|
||||
if (request.op === "set_metadata") {
|
||||
const found = find(request.id)
|
||||
if (!found?.pipe || !isRecord(request.metadata))
|
||||
return { type: "error", message: `terminal ${String(request.id)} not found` }
|
||||
found.pipe.metadata = request.metadata
|
||||
return { type: "ok" }
|
||||
}
|
||||
if (request.op === "terminate") {
|
||||
if (failTerminate.has(`pty_persistent_${request.id}`)) return { type: "error", message: "terminate failed" }
|
||||
const index = processes.findIndex((item) => item.id === request.id)
|
||||
if (index === -1) return { type: "error", message: `terminal ${String(request.id)} not found` }
|
||||
const [removed] = processes.splice(index, 1)
|
||||
waiters.get(removed.id)?.forEach((waiter) => waiter.end(frame({ type: "error", message: "terminated" })))
|
||||
waiters.delete(removed.id)
|
||||
return { type: "ok" }
|
||||
}
|
||||
return { type: "error", message: `unsupported request: ${String(request.op)}` }
|
||||
})
|
||||
yield* Effect.promise(async () => {
|
||||
await mkdir(directory, { recursive: true })
|
||||
await writeRegistration(directory, socket, "test", "test", features)
|
||||
await writeRegistration(directory, socket)
|
||||
})
|
||||
return {
|
||||
failTerminate,
|
||||
failCreate,
|
||||
trap,
|
||||
ops,
|
||||
requests,
|
||||
exit,
|
||||
output,
|
||||
fail,
|
||||
drop,
|
||||
processes,
|
||||
waiters: (id: number) => waiters.get(id)?.length ?? 0,
|
||||
options: {
|
||||
root,
|
||||
handoff: { directory, instanceID: "test", ticket: "ticket", expiresAt: Date.now() + 60_000 },
|
||||
@@ -160,20 +261,53 @@ export const fakeDaemon = Effect.fn(function* (features?: string[]) {
|
||||
}
|
||||
})
|
||||
|
||||
export function terminal(id: number, groupID = "ses_test") {
|
||||
export function terminal(id: number, groupID = "ses_test"): Process {
|
||||
return {
|
||||
id,
|
||||
mode: "pty",
|
||||
pid: null,
|
||||
title: "test",
|
||||
foreground_process: null,
|
||||
group_id: groupID,
|
||||
command: ["test"],
|
||||
cwd: "/tmp",
|
||||
cols: 80,
|
||||
rows: 24,
|
||||
group_id: groupID,
|
||||
lifecycle: { status: "running" },
|
||||
output_head: 0,
|
||||
output_tail: 0,
|
||||
started_at: Date.now(),
|
||||
exited_at: null,
|
||||
pty: { title: "test", user_title: null, foreground_process: null, cols: 80, rows: 24 },
|
||||
}
|
||||
}
|
||||
|
||||
function pipe(id: number, request: Record<string, unknown>): Process {
|
||||
return {
|
||||
id,
|
||||
mode: "pipe",
|
||||
pid: 1_000 + id,
|
||||
command: [String(request.program), ...(Array.isArray(request.args) ? request.args.map(String) : [])],
|
||||
cwd: String(request.cwd),
|
||||
group_id: String(request.group_id),
|
||||
lifecycle: { status: "running" },
|
||||
output_head: 0,
|
||||
output_tail: 0,
|
||||
started_at: Date.now(),
|
||||
exited_at: null,
|
||||
pipe: {
|
||||
output_path: String(request.output_path),
|
||||
output_lines: 0,
|
||||
metadata: isRecord(request.metadata) ? request.metadata : {},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
function exited(process: Process) {
|
||||
return {
|
||||
type: "exited",
|
||||
exit_code: process.lifecycle.exit_code ?? null,
|
||||
signal: process.lifecycle.signal,
|
||||
final_offset: process.output_tail,
|
||||
output_lines: process.pipe?.output_lines,
|
||||
output_error: process.pipe?.output_error,
|
||||
exited_at: process.exited_at ?? Date.now(),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
import { expect } from "bun:test"
|
||||
import { spawn } from "node:child_process"
|
||||
import { existsSync } from "node:fs"
|
||||
import { mkdir, stat, writeFile } from "node:fs/promises"
|
||||
import { mkdir, writeFile } from "node:fs/promises"
|
||||
import net from "node:net"
|
||||
import path from "node:path"
|
||||
import { Effect } from "effect"
|
||||
import { Effect, Fiber } from "effect"
|
||||
import { makeDaemonTransport } from "../src/persistent-pty/daemon"
|
||||
import { listen, pong, temporaryDirectory, terminal, writeRegistration } from "./fixture/persistent-pty-daemon"
|
||||
import { frame, listen, pong, temporaryDirectory, terminal, writeRegistration } from "./fixture/persistent-pty-daemon"
|
||||
import { it } from "./lib/effect"
|
||||
|
||||
it.live("rediscovers a same-protocol daemon after its registration rotates", () =>
|
||||
@@ -19,7 +19,7 @@ it.live("rediscovers a same-protocol daemon after its registration rotates", ()
|
||||
if (receivedToken !== token) return { type: "error", message: "authentication failed" }
|
||||
if (request.op === "ping") return { ...pong, instance_id: instance }
|
||||
if (request.op === "create") creates++
|
||||
return request.op === "list" ? { type: "terminals", terminals: [] } : { type: "ok" }
|
||||
return request.op === "list" ? { type: "processes", processes: [] } : { type: "ok" }
|
||||
})
|
||||
yield* Effect.promise(() => writeRegistration(directory, socketPath, instance, token))
|
||||
const daemon = yield* makeDaemonTransport(root, "daemon")
|
||||
@@ -30,7 +30,7 @@ it.live("rediscovers a same-protocol daemon after its registration rotates", ()
|
||||
yield* Effect.promise(() => writeRegistration(directory, socketPath, instance, token))
|
||||
|
||||
const running = yield* daemon.requestIfRunning({ op: "list" })
|
||||
expect(running).toEqual({ type: "terminals", terminals: [] })
|
||||
expect(running).toEqual({ type: "processes", processes: [] })
|
||||
|
||||
token = "newest-token"
|
||||
instance = "newest-instance"
|
||||
@@ -50,11 +50,11 @@ it.live("rediscovers a rotated registration when acquiring a subscription", () =
|
||||
yield* listen(socketPath, (_socket, request, receivedToken) => {
|
||||
if (receivedToken !== token) return { type: "error", message: "authentication failed" }
|
||||
if (request.op === "ping") return { ...pong, instance_id: instance }
|
||||
if (request.op !== "subscribe") return { type: "terminals", terminals: [] }
|
||||
if (request.op !== "subscribe") return { type: "processes", processes: [] }
|
||||
subscriptions++
|
||||
return {
|
||||
type: "attached",
|
||||
terminal: terminal(1),
|
||||
process: terminal(1),
|
||||
role: "observer",
|
||||
generation: 1,
|
||||
requested_offset: 0,
|
||||
@@ -85,30 +85,75 @@ it.live("rediscovers a rotated registration when acquiring a subscription", () =
|
||||
}),
|
||||
)
|
||||
|
||||
it.live("refreshes the daemon's features when its registration rotates", () =>
|
||||
it.live("waits on its own connection until the process exits", () =>
|
||||
Effect.gen(function* () {
|
||||
const { root, directory } = yield* temporaryRuntime()
|
||||
const socketPath = path.join(directory, "daemon.sock")
|
||||
let token = "old-token"
|
||||
let instance = "old-instance"
|
||||
let features: string[] | undefined
|
||||
yield* listen(socketPath, (_socket, request, receivedToken) => {
|
||||
if (receivedToken !== token) return { type: "error", message: "authentication failed" }
|
||||
if (request.op === "ping") return { ...pong, instance_id: instance, ...(features ? { features } : {}) }
|
||||
return { type: "terminals", terminals: [] }
|
||||
const waiting: net.Socket[] = []
|
||||
yield* listen(socketPath, (socket, request) => {
|
||||
if (request.op === "ping") return pong
|
||||
if (request.op === "wait" && request.id === 1) {
|
||||
waiting.push(socket)
|
||||
return undefined
|
||||
}
|
||||
return { type: "error", message: "terminal 2 not found" }
|
||||
})
|
||||
yield* Effect.promise(() => writeRegistration(directory, socketPath, instance, token))
|
||||
yield* Effect.promise(() => writeRegistration(directory, socketPath))
|
||||
const daemon = yield* makeDaemonTransport(root, "daemon")
|
||||
expect(yield* daemon.supports("rename")).toBeFalse()
|
||||
|
||||
token = "new-token"
|
||||
instance = "new-instance"
|
||||
features = ["rename"]
|
||||
yield* Effect.promise(() => writeRegistration(directory, socketPath, instance, token, features))
|
||||
// The cached registration is replaced once a request is rejected, as rename's lookup does first.
|
||||
yield* daemon.request({ op: "list" })
|
||||
const missing = yield* Effect.flip(daemon.wait(2))
|
||||
expect(missing).toMatchObject({ kind: "request", message: "terminal 2 not found" })
|
||||
|
||||
expect(yield* daemon.supports("rename")).toBeTrue()
|
||||
const fiber = yield* daemon.wait(1).pipe(Effect.forkScoped({ startImmediately: true }))
|
||||
yield* poll(() => waiting.length === 1)
|
||||
waiting[0].end(
|
||||
frame({ type: "exited", exit_code: null, signal: "SIGTERM", final_offset: 3, output_lines: 1, exited_at: 7 }),
|
||||
)
|
||||
expect(yield* Fiber.join(fiber)).toEqual({
|
||||
type: "exited",
|
||||
exit_code: null,
|
||||
signal: "SIGTERM",
|
||||
final_offset: 3,
|
||||
output_lines: 1,
|
||||
exited_at: 7,
|
||||
})
|
||||
}),
|
||||
)
|
||||
|
||||
it.live("closes the wait connection when the wait is interrupted", () =>
|
||||
Effect.gen(function* () {
|
||||
const { root, directory } = yield* temporaryRuntime()
|
||||
const socketPath = path.join(directory, "daemon.sock")
|
||||
const waiting: net.Socket[] = []
|
||||
yield* listen(socketPath, (socket, request) => {
|
||||
if (request.op === "ping") return pong
|
||||
waiting.push(socket)
|
||||
return undefined
|
||||
})
|
||||
yield* Effect.promise(() => writeRegistration(directory, socketPath))
|
||||
const daemon = yield* makeDaemonTransport(root, "daemon")
|
||||
|
||||
const fiber = yield* daemon.wait(1).pipe(Effect.forkScoped({ startImmediately: true }))
|
||||
yield* poll(() => waiting.length === 1)
|
||||
const closed = new Promise<void>((resolve) => waiting[0].once("close", () => resolve()))
|
||||
yield* Fiber.interrupt(fiber)
|
||||
yield* Effect.promise(() => closed)
|
||||
}),
|
||||
)
|
||||
|
||||
it.live("reports a daemon that goes away during a wait as unreachable", () =>
|
||||
Effect.gen(function* () {
|
||||
const { root, directory } = yield* temporaryRuntime()
|
||||
const socketPath = path.join(directory, "daemon.sock")
|
||||
yield* listen(socketPath, (socket, request) => {
|
||||
if (request.op === "ping") return pong
|
||||
socket.destroy()
|
||||
return undefined
|
||||
})
|
||||
yield* Effect.promise(() => writeRegistration(directory, socketPath))
|
||||
const daemon = yield* makeDaemonTransport(root, "daemon")
|
||||
|
||||
expect((yield* Effect.flip(daemon.wait(1))).kind).toBe("connect")
|
||||
}),
|
||||
)
|
||||
|
||||
@@ -119,7 +164,7 @@ it.live("retries a start-required request when connection fails before dispatch"
|
||||
const secondSocket = path.join(directory, "second.sock")
|
||||
const first = yield* listen(firstSocket, (_socket, request) => {
|
||||
if (request.op === "ping") return pong
|
||||
return { type: "terminals", terminals: [] }
|
||||
return { type: "processes", processes: [] }
|
||||
})
|
||||
yield* Effect.promise(() => writeRegistration(directory, firstSocket))
|
||||
const daemon = yield* makeDaemonTransport(root, "daemon")
|
||||
@@ -175,7 +220,14 @@ it.live("rejects incompatible daemons without replacing or killing them", () =>
|
||||
yield* Effect.promise(() =>
|
||||
writeFile(
|
||||
path.join(directory, "service.json"),
|
||||
JSON.stringify({ instance_id: "old", pid: existing.pid, protocol: 6, socket: "/unused", token: "old" }),
|
||||
JSON.stringify({
|
||||
instance_id: "old",
|
||||
pid: existing.pid,
|
||||
protocol: 7,
|
||||
socket: "/unused",
|
||||
token: "old",
|
||||
features: [],
|
||||
}),
|
||||
),
|
||||
)
|
||||
const daemon = yield* makeDaemonTransport(root, "daemon", () => Promise.resolve("/missing/opencode-pty"))
|
||||
@@ -183,7 +235,7 @@ it.live("rejects incompatible daemons without replacing or killing them", () =>
|
||||
const optional = yield* Effect.flip(daemon.requestIfRunning({ op: "list" }))
|
||||
expect(optional).toMatchObject({
|
||||
kind: "protocol",
|
||||
message: "opencode-pty protocol mismatch: daemon=6, client=7",
|
||||
message: "opencode-pty protocol mismatch: daemon=7, client=8",
|
||||
pid: existing.pid,
|
||||
})
|
||||
|
||||
@@ -195,36 +247,6 @@ it.live("rejects incompatible daemons without replacing or killing them", () =>
|
||||
}),
|
||||
)
|
||||
|
||||
it.live("moves an inherited legacy registration into the runtime root and keeps its lock file", () =>
|
||||
Effect.gen(function* () {
|
||||
const base = yield* temporaryDirectory()
|
||||
const legacy = path.join(base, "legacy", "inherited")
|
||||
const socketPath = path.join(base, "daemon.sock")
|
||||
yield* listen(socketPath, (_socket, request) => {
|
||||
if (request.op === "ping") return pong
|
||||
return { type: "terminals", terminals: [] }
|
||||
})
|
||||
yield* Effect.promise(async () => {
|
||||
await mkdir(legacy, { recursive: true })
|
||||
await writeFile(path.join(legacy, "service.lock"), "")
|
||||
await writeRegistration(legacy, socketPath)
|
||||
})
|
||||
const lock = yield* Effect.promise(() => stat(path.join(legacy, "service.lock")))
|
||||
const daemon = yield* makeDaemonTransport(path.join(base, "root"), "fresh", undefined, {
|
||||
directory: legacy,
|
||||
instanceID: "test",
|
||||
ticket: "ticket",
|
||||
expiresAt: Date.now() + 60_000,
|
||||
})
|
||||
|
||||
const migrated = path.join(base, "root", "inherited")
|
||||
expect(existsSync(path.join(legacy, "service.json"))).toBeFalse()
|
||||
expect((yield* Effect.promise(() => stat(path.join(migrated, "service.lock")))).ino).toBe(lock.ino)
|
||||
expect(existsSync(path.join(migrated, "service.json"))).toBeTrue()
|
||||
expect(yield* daemon.request({ op: "list" })).toEqual({ type: "terminals", terminals: [] })
|
||||
}),
|
||||
)
|
||||
|
||||
it.live("starts fresh instead of failing when an inherited registration is gone or expired", () =>
|
||||
Effect.gen(function* () {
|
||||
const base = yield* temporaryDirectory()
|
||||
@@ -264,6 +286,13 @@ it.live("stops a discovered inherited daemon when adoption fails", () =>
|
||||
}),
|
||||
)
|
||||
|
||||
function poll(ready: () => boolean) {
|
||||
return Effect.gen(function* () {
|
||||
for (let attempt = 0; attempt < 200 && !ready(); attempt++) yield* Effect.sleep(10)
|
||||
expect(ready()).toBeTrue()
|
||||
})
|
||||
}
|
||||
|
||||
function temporaryRuntime() {
|
||||
return Effect.gen(function* () {
|
||||
const root = yield* temporaryDirectory()
|
||||
@@ -272,3 +301,37 @@ function temporaryRuntime() {
|
||||
return { root, directory }
|
||||
})
|
||||
}
|
||||
|
||||
if (process.platform !== "win32")
|
||||
it.live("gives up at once on a daemon binary that speaks another protocol, and never starts it again", () =>
|
||||
Effect.gen(function* () {
|
||||
const root = yield* temporaryDirectory()
|
||||
const runtime = path.join(root, "runtime")
|
||||
const spawns = path.join(root, "spawns")
|
||||
const binary = path.join(root, "old-opencode-pty")
|
||||
// Registers like an older release would, then idles.
|
||||
yield* Effect.promise(() =>
|
||||
writeFile(
|
||||
binary,
|
||||
[
|
||||
"#!/bin/sh",
|
||||
`echo spawn >> ${JSON.stringify(spawns)}`,
|
||||
'mkdir -p "$3/$5"',
|
||||
`printf '{"instance_id":"old","pid":%s,"protocol":7,"socket":"none","token":"t","features":[]}' $$ > "$3/$5/service.json"`,
|
||||
"exec sleep 30",
|
||||
].join("\n"),
|
||||
{ mode: 0o755 },
|
||||
),
|
||||
)
|
||||
const daemon = yield* makeDaemonTransport(runtime, "daemon", () => Promise.resolve(binary))
|
||||
const started = Date.now()
|
||||
const first = yield* daemon.request({ op: "list", mode: "pipe" }, true).pipe(Effect.flip)
|
||||
expect(first.kind).toBe("protocol")
|
||||
const second = yield* daemon.request({ op: "list", mode: "pipe" }, true).pipe(Effect.flip)
|
||||
expect(second.kind).toBe("protocol")
|
||||
// Well under the 5 s spawn timeout: the daemon was not waited on again.
|
||||
expect(Date.now() - started).toBeLessThan(4_000)
|
||||
const count = yield* Effect.promise(() => Bun.file(spawns).text())
|
||||
expect(count.trim().split("\n")).toHaveLength(1)
|
||||
}),
|
||||
)
|
||||
|
||||
@@ -17,6 +17,7 @@ import { SessionStore } from "@opencode/core/session/store"
|
||||
import { SessionEnvironment } from "@opencode/core/session/environment"
|
||||
import { LocationServiceMap } from "@opencode/core/location-services"
|
||||
import { Removed, Updated } from "@opencode/schema/persistent-pty"
|
||||
import { Pty } from "@opencode/schema/pty"
|
||||
import { fakeDaemon } from "./fixture/persistent-pty-daemon"
|
||||
import { it } from "./lib/effect"
|
||||
import { globalProjectNode } from "./lib/project"
|
||||
@@ -89,7 +90,7 @@ describe("PersistentPty session cleanup", () => {
|
||||
describe("PersistentPty rename", () => {
|
||||
it.live("renames a terminal, publishes the update and clears the user title", () =>
|
||||
Effect.gen(function* () {
|
||||
const daemon = yield* fakeDaemon(["rename"])
|
||||
const daemon = yield* fakeDaemon()
|
||||
yield* Effect.gen(function* () {
|
||||
const pty = yield* PersistentPty.Service
|
||||
const bus = yield* Bus.Service
|
||||
@@ -107,31 +108,116 @@ describe("PersistentPty rename", () => {
|
||||
}).pipe(Effect.provide(layer(daemon)))
|
||||
}),
|
||||
)
|
||||
})
|
||||
|
||||
it.live("refuses to rename on a daemon without the rename feature and never sends it", () =>
|
||||
// Pipe mode is Unix-only: Windows daemons reject create_pipe, so OpenCode keeps spawning shell commands there.
|
||||
describe.skipIf(process.platform === "win32")("PersistentPty pipe processes", () => {
|
||||
const input = {
|
||||
program: "/bin/sh",
|
||||
args: ["-c", "echo hi"],
|
||||
cwd: "/tmp",
|
||||
env: { PATH: "/usr/bin" },
|
||||
groupID: "proj_test",
|
||||
outputPath: "/tmp/sh_test.out",
|
||||
metadata: { id: "sh_test", command: "echo hi" },
|
||||
}
|
||||
|
||||
it.live("creates, inspects, signals and waits for a pipe process", () =>
|
||||
Effect.gen(function* () {
|
||||
const daemon = yield* fakeDaemon()
|
||||
yield* Effect.gen(function* () {
|
||||
const pty = yield* PersistentPty.Service
|
||||
const created = yield* pty.createPipe(input)
|
||||
expect(daemon.requests.at(-1)).toEqual({
|
||||
op: "create_pipe",
|
||||
program: "/bin/sh",
|
||||
args: ["-c", "echo hi"],
|
||||
cwd: "/tmp",
|
||||
env: { PATH: "/usr/bin" },
|
||||
group_id: "proj_test",
|
||||
output_path: "/tmp/sh_test.out",
|
||||
metadata: { id: "sh_test", command: "echo hi" },
|
||||
})
|
||||
expect(created).toMatchObject({
|
||||
groupID: "proj_test",
|
||||
outputPath: "/tmp/sh_test.out",
|
||||
lifecycle: { status: "running" },
|
||||
metadata: input.metadata,
|
||||
exitedAt: undefined,
|
||||
})
|
||||
|
||||
yield* pty.setPipeMetadata(created.id, { id: "sh_test", status: "killed" })
|
||||
expect((yield* pty.getPipe(created.id)).metadata).toEqual({ id: "sh_test", status: "killed" })
|
||||
expect((yield* pty.listPipes()).map((item) => item.id)).toEqual([created.id])
|
||||
|
||||
const waiting = yield* pty.waitPipe(created.id).pipe(Effect.forkScoped({ startImmediately: true }))
|
||||
yield* pty.signalPipe(created.id, "SIGTERM")
|
||||
expect(yield* Fiber.join(waiting)).toMatchObject({ exitCode: undefined, signal: "SIGTERM", outputLines: 0 })
|
||||
// A finished process answers a later wait at once and keeps its record until it is terminated.
|
||||
expect((yield* pty.waitPipe(created.id)).signal).toBe("SIGTERM")
|
||||
expect((yield* pty.getPipe(created.id)).lifecycle).toEqual({
|
||||
status: "exited",
|
||||
exitCode: undefined,
|
||||
signal: "SIGTERM",
|
||||
})
|
||||
|
||||
yield* pty.terminatePipe(created.id)
|
||||
expect(yield* Effect.flip(pty.getPipe(created.id))).toEqual(
|
||||
new PersistentPty.ProcessNotFoundError({ processID: created.id }),
|
||||
)
|
||||
expect(yield* pty.listPipes()).toEqual([])
|
||||
}).pipe(Effect.provide(layer(daemon)))
|
||||
}),
|
||||
)
|
||||
|
||||
it.live("keeps pipe processes and terminals apart", () =>
|
||||
Effect.gen(function* () {
|
||||
const daemon = yield* fakeDaemon()
|
||||
yield* Effect.gen(function* () {
|
||||
const pty = yield* PersistentPty.Service
|
||||
const directory = yield* tmpdirScoped()
|
||||
const terminal = yield* pty.create(Session.ID.make("ses_rename"), {
|
||||
const terminal = yield* pty.create(Session.ID.make("ses_pipe"), {
|
||||
args: [],
|
||||
cwd: directory.path,
|
||||
title: "test",
|
||||
env: {},
|
||||
})
|
||||
expect(terminal.userTitle).toBeNull()
|
||||
const pipe = yield* pty.createPipe(input)
|
||||
|
||||
const error = yield* Effect.flip(pty.rename(terminal.id, "build"))
|
||||
expect((yield* pty.list()).map((item) => item.id)).toEqual([terminal.id])
|
||||
expect((yield* pty.listPipes()).map((item) => item.id)).toEqual([pipe.id])
|
||||
const ptyID = Pty.ID.make(`pty_persistent_${pipe.id}`)
|
||||
expect(yield* Effect.flip(pty.get(ptyID))).toEqual(new PersistentPty.NotFoundError({ ptyID }))
|
||||
}).pipe(Effect.provide(layer(daemon)))
|
||||
}),
|
||||
)
|
||||
|
||||
expect(error).toEqual(new PersistentPty.UnsupportedError({ feature: "rename" }))
|
||||
expect(daemon.ops).not.toContain("rename")
|
||||
expect((yield* pty.get(terminal.id)).title).toBe("test")
|
||||
it.live("reports daemon rejections as request errors and a terminated wait as one", () =>
|
||||
Effect.gen(function* () {
|
||||
const daemon = yield* fakeDaemon()
|
||||
yield* Effect.gen(function* () {
|
||||
const pty = yield* PersistentPty.Service
|
||||
expect(yield* Effect.flip(pty.createPipe({ ...input, cwd: "relative" }))).toEqual(
|
||||
new PersistentPty.RequestError({ message: "cwd must be absolute" }),
|
||||
)
|
||||
const created = yield* pty.createPipe(input)
|
||||
const waiting = yield* pty.waitPipe(created.id).pipe(Effect.forkScoped({ startImmediately: true }))
|
||||
yield* poll(() => daemon.waiters(created.id) === 1)
|
||||
yield* pty.terminatePipe(created.id)
|
||||
expect(yield* Fiber.join(waiting).pipe(Effect.flip)).toEqual(
|
||||
new PersistentPty.RequestError({ message: "terminated" }),
|
||||
)
|
||||
}).pipe(Effect.provide(layer(daemon)))
|
||||
}),
|
||||
)
|
||||
})
|
||||
|
||||
const poll = (ready: () => boolean) =>
|
||||
Effect.gen(function* () {
|
||||
for (let attempt = 0; attempt < 200 && !ready(); attempt++) yield* Effect.sleep(10)
|
||||
expect(ready()).toBeTrue()
|
||||
})
|
||||
|
||||
const nextUpdated = (bus: Bus.Interface) =>
|
||||
bus
|
||||
.subscribe(Updated)
|
||||
@@ -163,3 +249,25 @@ const layer = (daemon: { readonly options: PersistentPty.Options }) =>
|
||||
offlineModels,
|
||||
],
|
||||
)
|
||||
|
||||
describe.skipIf(process.platform === "win32")("PersistentPty handoff", () => {
|
||||
it.live("prepares a handoff more than once on the same owner connection", () =>
|
||||
Effect.gen(function* () {
|
||||
const daemon = yield* fakeDaemon()
|
||||
yield* Effect.gen(function* () {
|
||||
const pty = yield* PersistentPty.Service
|
||||
yield* pty.createPipe({
|
||||
program: "/bin/sh",
|
||||
args: ["-c", "echo hi"],
|
||||
cwd: "/tmp",
|
||||
env: {},
|
||||
groupID: "proj_test",
|
||||
outputPath: "/tmp/sh_handoff.out",
|
||||
metadata: {},
|
||||
})
|
||||
expect(yield* pty.handoff()).toMatchObject({ ticket: "next" })
|
||||
expect(yield* pty.handoff()).toMatchObject({ ticket: "next" })
|
||||
}).pipe(Effect.provide(layer(daemon)))
|
||||
}),
|
||||
)
|
||||
})
|
||||
|
||||
@@ -37,7 +37,7 @@
|
||||
"effect": "catalog:"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@opencode/pty": "0.4.0",
|
||||
"@opencode/pty": "0.5.0",
|
||||
"@opencode/client": "workspace:*",
|
||||
"@opencode/plugin": "workspace:*",
|
||||
"@tsconfig/bun": "catalog:",
|
||||
|
||||
@@ -3,7 +3,6 @@ import { PtyTicket } from "@opencode/core/pty/ticket"
|
||||
import {
|
||||
ForbiddenError,
|
||||
InvalidRequestError,
|
||||
PtyFeatureUnsupportedError,
|
||||
PtyNotFoundError,
|
||||
ServiceUnavailableError,
|
||||
} from "@opencode/protocol/errors"
|
||||
@@ -113,19 +112,7 @@ export const PersistentPtyHandler = HttpApiBuilder.group(Api, "server.experiment
|
||||
.resize(ctx.params.ptyID, ctx.payload.size.cols, ctx.payload.size.rows, ctx.payload.attachmentID)
|
||||
.pipe(mapTerminalError)
|
||||
if (ctx.payload.title === undefined) return { data: yield* pty.get(ctx.params.ptyID).pipe(mapTerminalError) }
|
||||
return {
|
||||
data: yield* pty.rename(ctx.params.ptyID, ctx.payload.title).pipe(
|
||||
Effect.catchTags({
|
||||
"PersistentPty.NotFoundError": notFound,
|
||||
"PersistentPty.UnsupportedError": (error) =>
|
||||
new PtyFeatureUnsupportedError({
|
||||
feature: error.feature,
|
||||
message: "Terminal renaming will be available after OpenCode's terminal service restarts",
|
||||
}),
|
||||
"PersistentPty.UnavailableError": unavailable,
|
||||
}),
|
||||
),
|
||||
}
|
||||
return { data: yield* pty.rename(ctx.params.ptyID, ctx.payload.title).pipe(mapTerminalError) }
|
||||
}),
|
||||
)
|
||||
.handle(
|
||||
|
||||
@@ -208,7 +208,7 @@ smoke(
|
||||
20_000,
|
||||
)
|
||||
|
||||
it.live("reports renaming as unsupported on a daemon without the rename feature", () =>
|
||||
it.live("renames without a feature check and hides unknown terminals", () =>
|
||||
Effect.gen(function* () {
|
||||
const fixture = yield* testDirectory()
|
||||
const daemon = yield* fakeDaemon()
|
||||
@@ -222,7 +222,7 @@ it.live("reports renaming as unsupported on a daemon without the rename feature"
|
||||
fs: { filewatcher: false },
|
||||
})
|
||||
const base = HttpServer.formatAddress(server.address)
|
||||
const created = yield* request(base, "POST", "/api/experimental/session/ses_old_daemon/terminal", {
|
||||
const created = yield* request(base, "POST", "/api/experimental/session/ses_v8_daemon/terminal", {
|
||||
args: [],
|
||||
cwd: fixture.root,
|
||||
title: "created",
|
||||
@@ -231,28 +231,19 @@ it.live("reports renaming as unsupported on a daemon without the rename feature"
|
||||
const terminal = Schema.decodeUnknownSync(PersistentPty.Info)(created.data)
|
||||
expect(terminal.userTitle).toBeNull()
|
||||
|
||||
const response = yield* Effect.promise(async () => {
|
||||
const response = await fetch(new URL(`/api/experimental/persistent-pty/${terminal.id}`, base), {
|
||||
method: "PUT",
|
||||
headers: { authorization: `Basic ${btoa("opencode:secret")}`, "content-type": "application/json" },
|
||||
body: JSON.stringify({ title: "build" }),
|
||||
})
|
||||
return { status: response.status, body: await response.json() }
|
||||
})
|
||||
const renamed = yield* request(base, "PUT", `/api/experimental/persistent-pty/${terminal.id}`, { title: "build" })
|
||||
expect(renamed.data).toMatchObject({ title: "build", userTitle: "build" })
|
||||
expect(daemon.ops).toContain("rename")
|
||||
expect(daemon.ops).not.toContain("list")
|
||||
|
||||
expect(response).toEqual({
|
||||
status: 501,
|
||||
body: {
|
||||
_tag: "PtyFeatureUnsupportedError",
|
||||
feature: "rename",
|
||||
message: "Terminal renaming will be available after OpenCode's terminal service restarts",
|
||||
},
|
||||
})
|
||||
expect(daemon.ops).not.toContain("rename")
|
||||
expect((yield* request(base, "GET", `/api/experimental/persistent-pty/${terminal.id}`)).data).toMatchObject({
|
||||
title: "test",
|
||||
userTitle: null,
|
||||
const missing = yield* Effect.promise(async () => {
|
||||
const response = await fetch(new URL("/api/experimental/persistent-pty/pty_persistent_99", base), {
|
||||
headers: { authorization: `Basic ${btoa("opencode:secret")}` },
|
||||
})
|
||||
await response.arrayBuffer()
|
||||
return response.status
|
||||
})
|
||||
expect(missing).toBe(404)
|
||||
}),
|
||||
)
|
||||
|
||||
@@ -573,12 +564,11 @@ smoke(
|
||||
)
|
||||
|
||||
smoke(
|
||||
"migrates a legacy runtime directory on restart and boots fresh when the registration is gone",
|
||||
"boots fresh on restart when the handed-off registration is gone",
|
||||
() =>
|
||||
Effect.gen(function* () {
|
||||
const fixture = yield* testDirectory()
|
||||
const scope = yield* Scope.Scope
|
||||
const legacy = path.join(fixture.root, "legacy")
|
||||
const options = {
|
||||
hostname: "127.0.0.1",
|
||||
port: 0,
|
||||
@@ -586,50 +576,32 @@ smoke(
|
||||
app: { version: "test-version" },
|
||||
database: { path: fixture.database },
|
||||
fs: { filewatcher: false },
|
||||
pty: { root: fixture.directory },
|
||||
}
|
||||
const sessionID = Session.ID.make("ses_persistent_pty_migration")
|
||||
const sessionID = Session.ID.make("ses_persistent_pty_gone")
|
||||
const originalScope = yield* Scope.fork(scope)
|
||||
const original = yield* ServerProcess.start<never, never>({ ...options, pty: { root: legacy } }).pipe(
|
||||
const original = yield* ServerProcess.start<never, never>(options).pipe(
|
||||
Effect.provideService(Scope.Scope, originalScope),
|
||||
)
|
||||
const base = HttpServer.formatAddress(original.address)
|
||||
const first = Schema.decodeUnknownSync(PersistentPty.Info)(
|
||||
(yield* request(base, "POST", `/api/experimental/session/${sessionID}/terminal`, {
|
||||
command: "/bin/sh",
|
||||
args: ["-c", "stty -echo; printf before-migration; exec cat"],
|
||||
args: ["-c", "stty -echo; printf before-restart; exec cat"],
|
||||
cwd: process.cwd(),
|
||||
title: "legacy",
|
||||
title: "first",
|
||||
env: {},
|
||||
})).data,
|
||||
)
|
||||
expect(yield* waitForText(base, first.id, "before-migration")).toContain("before-migration")
|
||||
const legacyHandoff = Schema.decodeUnknownSync(PersistentPty.Handoff)(
|
||||
expect(yield* waitForText(base, first.id, "before-restart")).toContain("before-restart")
|
||||
const handoff = Schema.decodeUnknownSync(PersistentPty.Handoff)(
|
||||
(yield* request(base, "POST", "/api/experimental/persistent-pty/handoff")).handoff,
|
||||
)
|
||||
yield* Scope.close(originalScope, Exit.void)
|
||||
|
||||
const migratedScope = yield* Scope.fork(scope)
|
||||
const migrated = yield* ServerProcess.start<never, never>({
|
||||
...options,
|
||||
pty: { root: fixture.directory, handoff: legacyHandoff },
|
||||
}).pipe(Effect.provideService(Scope.Scope, migratedScope))
|
||||
const migratedBase = HttpServer.formatAddress(migrated.address)
|
||||
const directory = path.join(fixture.directory, path.basename(legacyHandoff.directory))
|
||||
expect(existsSync(path.join(directory, "service.json"))).toBeTrue()
|
||||
expect(existsSync(path.join(legacyHandoff.directory, "service.json"))).toBeFalse()
|
||||
expect(
|
||||
(yield* request(migratedBase, "GET", `/api/experimental/session/${sessionID}/terminal`)).data,
|
||||
).toMatchObject([{ id: first.id, pid: first.pid }])
|
||||
|
||||
const handoff = Schema.decodeUnknownSync(PersistentPty.Handoff)(
|
||||
(yield* request(migratedBase, "POST", "/api/experimental/persistent-pty/handoff")).handoff,
|
||||
)
|
||||
expect(handoff.directory).toBe(directory)
|
||||
yield* Scope.close(migratedScope, Exit.void)
|
||||
// Simulate macOS purging the registration while the daemon waits for its successor.
|
||||
yield* Effect.promise(() => fs.rm(path.join(directory, "service.json")))
|
||||
yield* Effect.promise(() => fs.rm(path.join(handoff.directory, "service.json")))
|
||||
|
||||
const fresh = yield* ServerProcess.start<never, never>({ ...options, pty: { root: fixture.directory, handoff } })
|
||||
const fresh = yield* ServerProcess.start<never, never>({ ...options, pty: { ...options.pty, handoff } })
|
||||
const freshBase = HttpServer.formatAddress(fresh.address)
|
||||
expect((yield* request(freshBase, "GET", `/api/experimental/session/${sessionID}/terminal`)).data).toEqual([])
|
||||
const second = Schema.decodeUnknownSync(PersistentPty.Info)(
|
||||
|
||||
Reference in New Issue
Block a user