alchemylab-opencode 1.0.7 → 1.0.8

package/packages/opencode/src/pty/index.ts

@@ -1,397 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import { Bus } from "@/bus"
-import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
-import { Instance } from "@/project/instance"
-import type { Proc } from "#pty"
-import z from "zod"
-import { Log } from "../util/log"
-import { lazy } from "@opencode-ai/util/lazy"
-import { Shell } from "@/shell/shell"
-import { Plugin } from "@/plugin"
-import { PtyID } from "./schema"
-import { Effect, Layer, ServiceMap } from "effect"
-
-export namespace Pty {
-  const log = Log.create({ service: "pty" })
-
-  const BUFFER_LIMIT = 1024 * 1024 * 2
-  const BUFFER_CHUNK = 64 * 1024
-  const encoder = new TextEncoder()
-
-  type Socket = {
-    readyState: number
-    data?: unknown
-    send: (data: string | Uint8Array | ArrayBuffer) => void
-    close: (code?: number, reason?: string) => void
-  }
-
-  const sock = (ws: Socket) => (ws.data && typeof ws.data === "object" ? ws.data : ws)
-
-  type Active = {
-    info: Info
-    process: Proc
-    buffer: string
-    bufferCursor: number
-    cursor: number
-    subscribers: Map<unknown, Socket>
-  }
-
-  type State = {
-    dir: string
-    sessions: Map<PtyID, Active>
-  }
-
-  // WebSocket control frame: 0x00 + UTF-8 JSON.
-  const meta = (cursor: number) => {
-    const json = JSON.stringify({ cursor })
-    const bytes = encoder.encode(json)
-    const out = new Uint8Array(bytes.length + 1)
-    out[0] = 0
-    out.set(bytes, 1)
-    return out
-  }
-
-  const pty = lazy(() => import("#pty"))
-
-  export const Info = z
-    .object({
-      id: PtyID.zod,
-      title: z.string(),
-      command: z.string(),
-      args: z.array(z.string()),
-      cwd: z.string(),
-      status: z.enum(["running", "exited"]),
-      pid: z.number(),
-    })
-    .meta({ ref: "Pty" })
-
-  export type Info = z.infer<typeof Info>
-
-  export const CreateInput = z.object({
-    command: z.string().optional(),
-    args: z.array(z.string()).optional(),
-    cwd: z.string().optional(),
-    title: z.string().optional(),
-    env: z.record(z.string(), z.string()).optional(),
-  })
-
-  export type CreateInput = z.infer<typeof CreateInput>
-
-  export const UpdateInput = z.object({
-    title: z.string().optional(),
-    size: z
-      .object({
-        rows: z.number(),
-        cols: z.number(),
-      })
-      .optional(),
-  })
-
-  export type UpdateInput = z.infer<typeof UpdateInput>
-
-  export const Event = {
-    Created: BusEvent.define("pty.created", z.object({ info: Info })),
-    Updated: BusEvent.define("pty.updated", z.object({ info: Info })),
-    Exited: BusEvent.define("pty.exited", z.object({ id: PtyID.zod, exitCode: z.number() })),
-    Deleted: BusEvent.define("pty.deleted", z.object({ id: PtyID.zod })),
-  }
-
-  export interface Interface {
-    readonly list: () => Effect.Effect<Info[]>
-    readonly get: (id: PtyID) => Effect.Effect<Info | undefined>
-    readonly create: (input: CreateInput) => Effect.Effect<Info>
-    readonly update: (id: PtyID, input: UpdateInput) => Effect.Effect<Info | undefined>
-    readonly remove: (id: PtyID) => Effect.Effect<void>
-    readonly resize: (id: PtyID, cols: number, rows: number) => Effect.Effect<void>
-    readonly write: (id: PtyID, data: string) => Effect.Effect<void>
-    readonly connect: (
-      id: PtyID,
-      ws: Socket,
-      cursor?: number,
-    ) => Effect.Effect<{ onMessage: (message: string | ArrayBuffer) => void; onClose: () => void } | undefined>
-  }
-
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Pty") {}
-
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const bus = yield* Bus.Service
-      const plugin = yield* Plugin.Service
-      function teardown(session: Active) {
-        try {
-          session.process.kill()
-        } catch {}
-        for (const [sub, ws] of session.subscribers.entries()) {
-          try {
-            if (sock(ws) === sub) ws.close()
-          } catch {}
-        }
-        session.subscribers.clear()
-      }
-
-      const state = yield* InstanceState.make<State>(
-        Effect.fn("Pty.state")(function* (ctx) {
-          const state = {
-            dir: ctx.directory,
-            sessions: new Map<PtyID, Active>(),
-          }
-
-          yield* Effect.addFinalizer(() =>
-            Effect.sync(() => {
-              for (const session of state.sessions.values()) {
-                teardown(session)
-              }
-              state.sessions.clear()
-            }),
-          )
-
-          return state
-        }),
-      )
-
-      const remove = Effect.fn("Pty.remove")(function* (id: PtyID) {
-        const s = yield* InstanceState.get(state)
-        const session = s.sessions.get(id)
-        if (!session) return
-        s.sessions.delete(id)
-        log.info("removing session", { id })
-        teardown(session)
-        yield* bus.publish(Event.Deleted, { id: session.info.id })
-      })
-
-      const list = Effect.fn("Pty.list")(function* () {
-        const s = yield* InstanceState.get(state)
-        return Array.from(s.sessions.values()).map((session) => session.info)
-      })
-
-      const get = Effect.fn("Pty.get")(function* (id: PtyID) {
-        const s = yield* InstanceState.get(state)
-        return s.sessions.get(id)?.info
-      })
-
-      const create = Effect.fn("Pty.create")(function* (input: CreateInput) {
-        const s = yield* InstanceState.get(state)
-        const id = PtyID.ascending()
-        const command = input.command || Shell.preferred()
-        const args = input.args || []
-        if (Shell.login(command)) {
-          args.push("-l")
-        }
-
-        const cwd = input.cwd || s.dir
-        const shell = yield* plugin.trigger("shell.env", { cwd }, { env: {} })
-        const env = {
-          ...process.env,
-          ...input.env,
-          ...shell.env,
-          TERM: "xterm-256color",
-          OPENCODE_TERMINAL: "1",
-        } as Record<string, string>
-
-        if (process.platform === "win32") {
-          env.LC_ALL = "C.UTF-8"
-          env.LC_CTYPE = "C.UTF-8"
-          env.LANG = "C.UTF-8"
-        }
-        log.info("creating session", { id, cmd: command, args, cwd })
-
-        const { spawn } = yield* Effect.promise(() => pty())
-        const proc = yield* Effect.sync(() =>
-          spawn(command, args, {
-            name: "xterm-256color",
-            cwd,
-            env,
-          }),
-        )
-
-        const info = {
-          id,
-          title: input.title || `Terminal ${id.slice(-4)}`,
-          command,
-          args,
-          cwd,
-          status: "running",
-          pid: proc.pid,
-        } as const
-        const session: Active = {
-          info,
-          process: proc,
-          buffer: "",
-          bufferCursor: 0,
-          cursor: 0,
-          subscribers: new Map(),
-        }
-        s.sessions.set(id, session)
-        proc.onData(
-          Instance.bind((chunk) => {
-            session.cursor += chunk.length
-
-            for (const [key, ws] of session.subscribers.entries()) {
-              if (ws.readyState !== 1) {
-                session.subscribers.delete(key)
-                continue
-              }
-              if (sock(ws) !== key) {
-                session.subscribers.delete(key)
-                continue
-              }
-              try {
-                ws.send(chunk)
-              } catch {
-                session.subscribers.delete(key)
-              }
-            }
-
-            session.buffer += chunk
-            if (session.buffer.length <= BUFFER_LIMIT) return
-            const excess = session.buffer.length - BUFFER_LIMIT
-            session.buffer = session.buffer.slice(excess)
-            session.bufferCursor += excess
-          }),
-        )
-        proc.onExit(
-          Instance.bind(({ exitCode }) => {
-            if (session.info.status === "exited") return
-            log.info("session exited", { id, exitCode })
-            session.info.status = "exited"
-            Effect.runFork(bus.publish(Event.Exited, { id, exitCode }))
-            Effect.runFork(remove(id))
-          }),
-        )
-        yield* bus.publish(Event.Created, { info })
-        return info
-      })
-
-      const update = Effect.fn("Pty.update")(function* (id: PtyID, input: UpdateInput) {
-        const s = yield* InstanceState.get(state)
-        const session = s.sessions.get(id)
-        if (!session) return
-        if (input.title) {
-          session.info.title = input.title
-        }
-        if (input.size) {
-          session.process.resize(input.size.cols, input.size.rows)
-        }
-        yield* bus.publish(Event.Updated, { info: session.info })
-        return session.info
-      })
-
-      const resize = Effect.fn("Pty.resize")(function* (id: PtyID, cols: number, rows: number) {
-        const s = yield* InstanceState.get(state)
-        const session = s.sessions.get(id)
-        if (session && session.info.status === "running") {
-          session.process.resize(cols, rows)
-        }
-      })
-
-      const write = Effect.fn("Pty.write")(function* (id: PtyID, data: string) {
-        const s = yield* InstanceState.get(state)
-        const session = s.sessions.get(id)
-        if (session && session.info.status === "running") {
-          session.process.write(data)
-        }
-      })
-
-      const connect = Effect.fn("Pty.connect")(function* (id: PtyID, ws: Socket, cursor?: number) {
-        const s = yield* InstanceState.get(state)
-        const session = s.sessions.get(id)
-        if (!session) {
-          ws.close()
-          return
-        }
-        log.info("client connected to session", { id })
-
-        const sub = sock(ws)
-        session.subscribers.delete(sub)
-        session.subscribers.set(sub, ws)
-
-        const cleanup = () => {
-          session.subscribers.delete(sub)
-        }
-
-        const start = session.bufferCursor
-        const end = session.cursor
-        const from =
-          cursor === -1 ? end : typeof cursor === "number" && Number.isSafeInteger(cursor) ? Math.max(0, cursor) : 0
-
-        const data = (() => {
-          if (!session.buffer) return ""
-          if (from >= end) return ""
-          const offset = Math.max(0, from - start)
-          if (offset >= session.buffer.length) return ""
-          return session.buffer.slice(offset)
-        })()
-
-        if (data) {
-          try {
-            for (let i = 0; i < data.length; i += BUFFER_CHUNK) {
-              ws.send(data.slice(i, i + BUFFER_CHUNK))
-            }
-          } catch {
-            cleanup()
-            ws.close()
-            return
-          }
-        }
-
-        try {
-          ws.send(meta(end))
-        } catch {
-          cleanup()
-          ws.close()
-          return
-        }
-
-        return {
-          onMessage: (message: string | ArrayBuffer) => {
-            session.process.write(String(message))
-          },
-          onClose: () => {
-            log.info("client disconnected from session", { id })
-            cleanup()
-          },
-        }
-      })
-
-      return Service.of({ list, get, create, update, remove, resize, write, connect })
-    }),
-  )
-
-  const defaultLayer = layer.pipe(Layer.provide(Bus.layer), Layer.provide(Plugin.defaultLayer))
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export async function list() {
-    return runPromise((svc) => svc.list())
-  }
-
-  export async function get(id: PtyID) {
-    return runPromise((svc) => svc.get(id))
-  }
-
-  export async function resize(id: PtyID, cols: number, rows: number) {
-    return runPromise((svc) => svc.resize(id, cols, rows))
-  }
-
-  export async function write(id: PtyID, data: string) {
-    return runPromise((svc) => svc.write(id, data))
-  }
-
-  export async function connect(id: PtyID, ws: Socket, cursor?: number) {
-    return runPromise((svc) => svc.connect(id, ws, cursor))
-  }
-
-  export async function create(input: CreateInput) {
-    return runPromise((svc) => svc.create(input))
-  }
-
-  export async function update(id: PtyID, input: UpdateInput) {
-    return runPromise((svc) => svc.update(id, input))
-  }
-
-  export async function remove(id: PtyID) {
-    return runPromise((svc) => svc.remove(id))
-  }
-}

package/packages/opencode/src/pty/pty.node.ts

@@ -1,27 +0,0 @@
-/** @ts-expect-error */
-import * as pty from "@lydell/node-pty"
-import type { Opts, Proc } from "./pty"
-
-export type { Disp, Exit, Opts, Proc } from "./pty"
-
-export function spawn(file: string, args: string[], opts: Opts): Proc {
-  const proc = pty.spawn(file, args, opts)
-  return {
-    pid: proc.pid,
-    onData(listener) {
-      return proc.onData(listener)
-    },
-    onExit(listener) {
-      return proc.onExit(listener)
-    },
-    write(data) {
-      proc.write(data)
-    },
-    resize(cols, rows) {
-      proc.resize(cols, rows)
-    },
-    kill(signal) {
-      proc.kill(signal)
-    },
-  }
-}

package/packages/opencode/src/pty/pty.ts

@@ -1,25 +0,0 @@
-export type Disp = {
-  dispose(): void
-}
-
-export type Exit = {
-  exitCode: number
-  signal?: number | string
-}
-
-export type Opts = {
-  name: string
-  cols?: number
-  rows?: number
-  cwd?: string
-  env?: Record<string, string>
-}
-
-export type Proc = {
-  pid: number
-  onData(listener: (data: string) => void): Disp
-  onExit(listener: (event: Exit) => void): Disp
-  write(data: string): void
-  resize(cols: number, rows: number): void
-  kill(signal?: string): void
-}

package/packages/opencode/src/pty/schema.ts

@@ -1,17 +0,0 @@
-import { Schema } from "effect"
-import z from "zod"
-
-import { Identifier } from "@/id/id"
-import { withStatics } from "@/util/schema"
-
-const ptyIdSchema = Schema.String.pipe(Schema.brand("PtyID"))
-
-export type PtyID = typeof ptyIdSchema.Type
-
-export const PtyID = ptyIdSchema.pipe(
-  withStatics((schema: typeof ptyIdSchema) => ({
-    make: (id: string) => schema.makeUnsafe(id),
-    ascending: (id?: string) => schema.makeUnsafe(Identifier.ascending("pty", id)),
-    zod: Identifier.schema("pty").pipe(z.custom<PtyID>()),
-  })),
-)

package/packages/opencode/src/question/index.ts

@@ -1,224 +0,0 @@
-import { Deferred, Effect, Layer, Schema, ServiceMap } from "effect"
-import { Bus } from "@/bus"
-import { BusEvent } from "@/bus/bus-event"
-import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
-import { SessionID, MessageID } from "@/session/schema"
-import { Log } from "@/util/log"
-import z from "zod"
-import { QuestionID } from "./schema"
-
-export namespace Question {
-  const log = Log.create({ service: "question" })
-
-  // Schemas
-
-  export const Option = z
-    .object({
-      label: z.string().describe("Display text (1-5 words, concise)"),
-      description: z.string().describe("Explanation of choice"),
-    })
-    .meta({ ref: "QuestionOption" })
-  export type Option = z.infer<typeof Option>
-
-  export const Info = z
-    .object({
-      question: z.string().describe("Complete question"),
-      header: z.string().describe("Very short label (max 30 chars)"),
-      options: z.array(Option).describe("Available choices"),
-      multiple: z.boolean().optional().describe("Allow selecting multiple choices"),
-      custom: z.boolean().optional().describe("Allow typing a custom answer (default: true)"),
-    })
-    .meta({ ref: "QuestionInfo" })
-  export type Info = z.infer<typeof Info>
-
-  export const Request = z
-    .object({
-      id: QuestionID.zod,
-      sessionID: SessionID.zod,
-      questions: z.array(Info).describe("Questions to ask"),
-      tool: z
-        .object({
-          messageID: MessageID.zod,
-          callID: z.string(),
-        })
-        .optional(),
-    })
-    .meta({ ref: "QuestionRequest" })
-  export type Request = z.infer<typeof Request>
-
-  export const Answer = z.array(z.string()).meta({ ref: "QuestionAnswer" })
-  export type Answer = z.infer<typeof Answer>
-
-  export const Reply = z.object({
-    answers: z
-      .array(Answer)
-      .describe("User answers in order of questions (each answer is an array of selected labels)"),
-  })
-  export type Reply = z.infer<typeof Reply>
-
-  export const Event = {
-    Asked: BusEvent.define("question.asked", Request),
-    Replied: BusEvent.define(
-      "question.replied",
-      z.object({
-        sessionID: SessionID.zod,
-        requestID: QuestionID.zod,
-        answers: z.array(Answer),
-      }),
-    ),
-    Rejected: BusEvent.define(
-      "question.rejected",
-      z.object({
-        sessionID: SessionID.zod,
-        requestID: QuestionID.zod,
-      }),
-    ),
-  }
-
-  export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("QuestionRejectedError", {}) {
-    override get message() {
-      return "The user dismissed this question"
-    }
-  }
-
-  interface PendingEntry {
-    info: Request
-    deferred: Deferred.Deferred<Answer[], RejectedError>
-  }
-
-  interface State {
-    pending: Map<QuestionID, PendingEntry>
-  }
-
-  // Service
-
-  export interface Interface {
-    readonly ask: (input: {
-      sessionID: SessionID
-      questions: Info[]
-      tool?: { messageID: MessageID; callID: string }
-    }) => Effect.Effect<Answer[], RejectedError>
-    readonly reply: (input: { requestID: QuestionID; answers: Answer[] }) => Effect.Effect<void>
-    readonly reject: (requestID: QuestionID) => Effect.Effect<void>
-    readonly list: () => Effect.Effect<Request[]>
-  }
-
-  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Question") {}
-
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const bus = yield* Bus.Service
-      const state = yield* InstanceState.make<State>(
-        Effect.fn("Question.state")(function* () {
-          const state = {
-            pending: new Map<QuestionID, PendingEntry>(),
-          }
-
-          yield* Effect.addFinalizer(() =>
-            Effect.gen(function* () {
-              for (const item of state.pending.values()) {
-                yield* Deferred.fail(item.deferred, new RejectedError())
-              }
-              state.pending.clear()
-            }),
-          )
-
-          return state
-        }),
-      )
-
-      const ask = Effect.fn("Question.ask")(function* (input: {
-        sessionID: SessionID
-        questions: Info[]
-        tool?: { messageID: MessageID; callID: string }
-      }) {
-        const pending = (yield* InstanceState.get(state)).pending
-        const id = QuestionID.ascending()
-        log.info("asking", { id, questions: input.questions.length })
-
-        const deferred = yield* Deferred.make<Answer[], RejectedError>()
-        const info: Request = {
-          id,
-          sessionID: input.sessionID,
-          questions: input.questions,
-          tool: input.tool,
-        }
-        pending.set(id, { info, deferred })
-        yield* bus.publish(Event.Asked, info)
-
-        return yield* Effect.ensuring(
-          Deferred.await(deferred),
-          Effect.sync(() => {
-            pending.delete(id)
-          }),
-        )
-      })
-
-      const reply = Effect.fn("Question.reply")(function* (input: { requestID: QuestionID; answers: Answer[] }) {
-        const pending = (yield* InstanceState.get(state)).pending
-        const existing = pending.get(input.requestID)
-        if (!existing) {
-          log.warn("reply for unknown request", { requestID: input.requestID })
-          return
-        }
-        pending.delete(input.requestID)
-        log.info("replied", { requestID: input.requestID, answers: input.answers })
-        yield* bus.publish(Event.Replied, {
-          sessionID: existing.info.sessionID,
-          requestID: existing.info.id,
-          answers: input.answers,
-        })
-        yield* Deferred.succeed(existing.deferred, input.answers)
-      })
-
-      const reject = Effect.fn("Question.reject")(function* (requestID: QuestionID) {
-        const pending = (yield* InstanceState.get(state)).pending
-        const existing = pending.get(requestID)
-        if (!existing) {
-          log.warn("reject for unknown request", { requestID })
-          return
-        }
-        pending.delete(requestID)
-        log.info("rejected", { requestID })
-        yield* bus.publish(Event.Rejected, {
-          sessionID: existing.info.sessionID,
-          requestID: existing.info.id,
-        })
-        yield* Deferred.fail(existing.deferred, new RejectedError())
-      })
-
-      const list = Effect.fn("Question.list")(function* () {
-        const pending = (yield* InstanceState.get(state)).pending
-        return Array.from(pending.values(), (x) => x.info)
-      })
-
-      return Service.of({ ask, reply, reject, list })
-    }),
-  )
-
-  export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export async function ask(input: {
-    sessionID: SessionID
-    questions: Info[]
-    tool?: { messageID: MessageID; callID: string }
-  }): Promise<Answer[]> {
-    return runPromise((s) => s.ask(input))
-  }
-
-  export async function reply(input: { requestID: QuestionID; answers: Answer[] }) {
-    return runPromise((s) => s.reply(input))
-  }
-
-  export async function reject(requestID: QuestionID) {
-    return runPromise((s) => s.reject(requestID))
-  }
-
-  export async function list() {
-    return runPromise((s) => s.list())
-  }
-}

package/packages/opencode/src/question/schema.ts

@@ -1,17 +0,0 @@
-import { Schema } from "effect"
-import z from "zod"
-
-import { Identifier } from "@/id/id"
-import { Newtype } from "@/util/schema"
-
-export class QuestionID extends Newtype<QuestionID>()("QuestionID", Schema.String) {
-  static make(id: string): QuestionID {
-    return this.makeUnsafe(id)
-  }
-
-  static ascending(id?: string): QuestionID {
-    return this.makeUnsafe(Identifier.ascending("question", id))
-  }
-
-  static readonly zod = Identifier.schema("question") as unknown as z.ZodType<QuestionID>
-}