easc-cli 1.1.28

package/src/pty/index.ts

@@ -0,0 +1,232 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { type IPty } from "bun-pty"
+import z from "zod"
+import { Identifier } from "../id/id"
+import { Log } from "../util/log"
+import type { WSContext } from "hono/ws"
+import { Instance } from "../project/instance"
+import { lazy } from "@eliseart.ai/util/lazy"
+import { Shell } from "@/shell/shell"
+
+export namespace Pty {
+  const log = Log.create({ service: "pty" })
+
+  const BUFFER_LIMIT = 1024 * 1024 * 2
+  const BUFFER_CHUNK = 64 * 1024
+
+  const pty = lazy(async () => {
+    const { spawn } = await import("bun-pty")
+    return spawn
+  })
+
+  export const Info = z
+    .object({
+      id: Identifier.schema("pty"),
+      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: Identifier.schema("pty"), exitCode: z.number() })),
+    Deleted: BusEvent.define("pty.deleted", z.object({ id: Identifier.schema("pty") })),
+  }
+
+  interface ActiveSession {
+    info: Info
+    process: IPty
+    buffer: string
+    subscribers: Set<WSContext>
+  }
+
+  const state = Instance.state(
+    () => new Map<string, ActiveSession>(),
+    async (sessions) => {
+      for (const session of sessions.values()) {
+        try {
+          session.process.kill()
+        } catch {}
+        for (const ws of session.subscribers) {
+          ws.close()
+        }
+      }
+      sessions.clear()
+    },
+  )
+
+  export function list() {
+    return Array.from(state().values()).map((s) => s.info)
+  }
+
+  export function get(id: string) {
+    return state().get(id)?.info
+  }
+
+  export async function create(input: CreateInput) {
+    const id = Identifier.create("pty", false)
+    const command = input.command || Shell.preferred()
+    const args = input.args || []
+    if (command.endsWith("sh")) {
+      args.push("-l")
+    }
+
+    const cwd = input.cwd || Instance.directory
+    const env = { ...process.env, ...input.env, TERM: "xterm-256color" } as Record<string, string>
+    log.info("creating session", { id, cmd: command, args, cwd })
+
+    const spawn = await pty()
+    const ptyProcess = spawn(command, args, {
+      name: "xterm-256color",
+      cwd,
+      env,
+    })
+
+    const info = {
+      id,
+      title: input.title || `Terminal ${id.slice(-4)}`,
+      command,
+      args,
+      cwd,
+      status: "running",
+      pid: ptyProcess.pid,
+    } as const
+    const session: ActiveSession = {
+      info,
+      process: ptyProcess,
+      buffer: "",
+      subscribers: new Set(),
+    }
+    state().set(id, session)
+    ptyProcess.onData((data) => {
+      let open = false
+      for (const ws of session.subscribers) {
+        if (ws.readyState !== 1) {
+          session.subscribers.delete(ws)
+          continue
+        }
+        open = true
+        ws.send(data)
+      }
+      if (open) return
+      session.buffer += data
+      if (session.buffer.length <= BUFFER_LIMIT) return
+      session.buffer = session.buffer.slice(-BUFFER_LIMIT)
+    })
+    ptyProcess.onExit(({ exitCode }) => {
+      log.info("session exited", { id, exitCode })
+      session.info.status = "exited"
+      Bus.publish(Event.Exited, { id, exitCode })
+      for (const ws of session.subscribers) {
+        ws.close()
+      }
+      state().delete(id)
+    })
+    Bus.publish(Event.Created, { info })
+    return info
+  }
+
+  export async function update(id: string, input: UpdateInput) {
+    const session = state().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)
+    }
+    Bus.publish(Event.Updated, { info: session.info })
+    return session.info
+  }
+
+  export async function remove(id: string) {
+    const session = state().get(id)
+    if (!session) return
+    log.info("removing session", { id })
+    try {
+      session.process.kill()
+    } catch {}
+    for (const ws of session.subscribers) {
+      ws.close()
+    }
+    state().delete(id)
+    Bus.publish(Event.Deleted, { id })
+  }
+
+  export function resize(id: string, cols: number, rows: number) {
+    const session = state().get(id)
+    if (session && session.info.status === "running") {
+      session.process.resize(cols, rows)
+    }
+  }
+
+  export function write(id: string, data: string) {
+    const session = state().get(id)
+    if (session && session.info.status === "running") {
+      session.process.write(data)
+    }
+  }
+
+  export function connect(id: string, ws: WSContext) {
+    const session = state().get(id)
+    if (!session) {
+      ws.close()
+      return
+    }
+    log.info("client connected to session", { id })
+    session.subscribers.add(ws)
+    if (session.buffer) {
+      const buffer = session.buffer.length <= BUFFER_LIMIT ? session.buffer : session.buffer.slice(-BUFFER_LIMIT)
+      session.buffer = ""
+      try {
+        for (let i = 0; i < buffer.length; i += BUFFER_CHUNK) {
+          ws.send(buffer.slice(i, i + BUFFER_CHUNK))
+        }
+      } catch {
+        session.subscribers.delete(ws)
+        session.buffer = buffer
+        ws.close()
+        return
+      }
+    }
+    return {
+      onMessage: (message: string | ArrayBuffer) => {
+        session.process.write(String(message))
+      },
+      onClose: () => {
+        log.info("client disconnected from session", { id })
+        session.subscribers.delete(ws)
+      },
+    }
+  }
+}

package/src/question/index.ts

@@ -0,0 +1,171 @@
+import { Bus } from "@/bus"
+import { BusEvent } from "@/bus/bus-event"
+import { Identifier } from "@/id/id"
+import { Instance } from "@/project/instance"
+import { Log } from "@/util/log"
+import z from "zod"
+
+export namespace Question {
+  const log = Log.create({ service: "question" })
+
+  export const Option = z
+    .object({
+      label: z.string().max(30).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().max(30).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: Identifier.schema("question"),
+      sessionID: Identifier.schema("session"),
+      questions: z.array(Info).describe("Questions to ask"),
+      tool: z
+        .object({
+          messageID: z.string(),
+          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: z.string(),
+        requestID: z.string(),
+        answers: z.array(Answer),
+      }),
+    ),
+    Rejected: BusEvent.define(
+      "question.rejected",
+      z.object({
+        sessionID: z.string(),
+        requestID: z.string(),
+      }),
+    ),
+  }
+
+  const state = Instance.state(async () => {
+    const pending: Record<
+      string,
+      {
+        info: Request
+        resolve: (answers: Answer[]) => void
+        reject: (e: any) => void
+      }
+    > = {}
+
+    return {
+      pending,
+    }
+  })
+
+  export async function ask(input: {
+    sessionID: string
+    questions: Info[]
+    tool?: { messageID: string; callID: string }
+  }): Promise<Answer[]> {
+    const s = await state()
+    const id = Identifier.ascending("question")
+
+    log.info("asking", { id, questions: input.questions.length })
+
+    return new Promise<Answer[]>((resolve, reject) => {
+      const info: Request = {
+        id,
+        sessionID: input.sessionID,
+        questions: input.questions,
+        tool: input.tool,
+      }
+      s.pending[id] = {
+        info,
+        resolve,
+        reject,
+      }
+      Bus.publish(Event.Asked, info)
+    })
+  }
+
+  export async function reply(input: { requestID: string; answers: Answer[] }): Promise<void> {
+    const s = await state()
+    const existing = s.pending[input.requestID]
+    if (!existing) {
+      log.warn("reply for unknown request", { requestID: input.requestID })
+      return
+    }
+    delete s.pending[input.requestID]
+
+    log.info("replied", { requestID: input.requestID, answers: input.answers })
+
+    Bus.publish(Event.Replied, {
+      sessionID: existing.info.sessionID,
+      requestID: existing.info.id,
+      answers: input.answers,
+    })
+
+    existing.resolve(input.answers)
+  }
+
+  export async function reject(requestID: string): Promise<void> {
+    const s = await state()
+    const existing = s.pending[requestID]
+    if (!existing) {
+      log.warn("reject for unknown request", { requestID })
+      return
+    }
+    delete s.pending[requestID]
+
+    log.info("rejected", { requestID })
+
+    Bus.publish(Event.Rejected, {
+      sessionID: existing.info.sessionID,
+      requestID: existing.info.id,
+    })
+
+    existing.reject(new RejectedError())
+  }
+
+  export class RejectedError extends Error {
+    constructor() {
+      super("The user dismissed this question")
+    }
+  }
+
+  export async function list() {
+    return state().then((x) => Object.values(x.pending).map((x) => x.info))
+  }
+}

package/src/scheduler/index.ts

@@ -0,0 +1,61 @@
+import { Instance } from "../project/instance"
+import { Log } from "../util/log"
+
+export namespace Scheduler {
+  const log = Log.create({ service: "scheduler" })
+
+  export type Task = {
+    id: string
+    interval: number
+    run: () => Promise<void>
+    scope?: "instance" | "global"
+  }
+
+  type Timer = ReturnType<typeof setInterval>
+  type Entry = {
+    tasks: Map<string, Task>
+    timers: Map<string, Timer>
+  }
+
+  const create = (): Entry => {
+    const tasks = new Map<string, Task>()
+    const timers = new Map<string, Timer>()
+    return { tasks, timers }
+  }
+
+  const shared = create()
+
+  const state = Instance.state(
+    () => create(),
+    async (entry) => {
+      for (const timer of entry.timers.values()) {
+        clearInterval(timer)
+      }
+      entry.tasks.clear()
+      entry.timers.clear()
+    },
+  )
+
+  export function register(task: Task) {
+    const scope = task.scope ?? "instance"
+    const entry = scope === "global" ? shared : state()
+    const current = entry.timers.get(task.id)
+    if (current && scope === "global") return
+    if (current) clearInterval(current)
+
+    entry.tasks.set(task.id, task)
+    void run(task)
+    const timer = setInterval(() => {
+      void run(task)
+    }, task.interval)
+    timer.unref()
+    entry.timers.set(task.id, timer)
+  }
+
+  async function run(task: Task) {
+    log.info("run", { id: task.id })
+    await task.run().catch((error) => {
+      log.error("run failed", { id: task.id, error })
+    })
+  }
+}

package/src/server/error.ts

@@ -0,0 +1,36 @@
+import { resolver } from "hono-openapi"
+import z from "zod"
+import { Storage } from "../storage/storage"
+
+export const ERRORS = {
+  400: {
+    description: "Bad request",
+    content: {
+      "application/json": {
+        schema: resolver(
+          z
+            .object({
+              data: z.any(),
+              errors: z.array(z.record(z.string(), z.any())),
+              success: z.literal(false),
+            })
+            .meta({
+              ref: "BadRequestError",
+            }),
+        ),
+      },
+    },
+  },
+  404: {
+    description: "Not found",
+    content: {
+      "application/json": {
+        schema: resolver(Storage.NotFoundError.Schema),
+      },
+    },
+  },
+} as const
+
+export function errors(...codes: number[]) {
+  return Object.fromEntries(codes.map((code) => [code, ERRORS[code as keyof typeof ERRORS]]))
+}

package/src/server/event.ts

@@ -0,0 +1,7 @@
+import { BusEvent } from "@/bus/bus-event"
+import z from "zod"
+
+export const Event = {
+  Connected: BusEvent.define("server.connected", z.object({})),
+  Disposed: BusEvent.define("global.disposed", z.object({})),
+}

package/src/server/mdns.ts

@@ -0,0 +1,59 @@
+import { Log } from "@/util/log"
+import { Bonjour } from "bonjour-service"
+
+const log = Log.create({ service: "mdns" })
+
+export namespace MDNS {
+  let bonjour: Bonjour | undefined
+  let currentPort: number | undefined
+
+  export function publish(port: number) {
+    if (currentPort === port) return
+    if (bonjour) unpublish()
+
+    try {
+      const name = `opencode-${port}`
+      bonjour = new Bonjour()
+      const service = bonjour.publish({
+        name,
+        type: "http",
+        host: "opencode.local",
+        port,
+        txt: { path: "/" },
+      })
+
+      service.on("up", () => {
+        log.info("mDNS service published", { name, port })
+      })
+
+      service.on("error", (err) => {
+        log.error("mDNS service error", { error: err })
+      })
+
+      currentPort = port
+    } catch (err) {
+      log.error("mDNS publish failed", { error: err })
+      if (bonjour) {
+        try {
+          bonjour.destroy()
+        } catch {}
+      }
+      bonjour = undefined
+      currentPort = undefined
+    }
+  }
+
+  export function unpublish() {
+    if (bonjour) {
+      try {
+        bonjour.unpublishAll()
+        bonjour.destroy()
+      } catch (err) {
+        log.error("mDNS unpublish failed", { error: err })
+      }
+      bonjour = undefined
+      currentPort = undefined
+      log.info("mDNS service unpublished")
+    }
+  }
+}

package/src/server/routes/config.ts

@@ -0,0 +1,92 @@
+import { Hono } from "hono"
+import { describeRoute, validator, resolver } from "hono-openapi"
+import z from "zod"
+import { Config } from "../../config/config"
+import { Provider } from "../../provider/provider"
+import { mapValues } from "remeda"
+import { errors } from "../error"
+import { Log } from "../../util/log"
+import { lazy } from "../../util/lazy"
+
+const log = Log.create({ service: "server" })
+
+export const ConfigRoutes = lazy(() =>
+  new Hono()
+    .get(
+      "/",
+      describeRoute({
+        summary: "Get configuration",
+        description: "Retrieve the current OpenCode configuration settings and preferences.",
+        operationId: "config.get",
+        responses: {
+          200: {
+            description: "Get config info",
+            content: {
+              "application/json": {
+                schema: resolver(Config.Info),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        return c.json(await Config.get())
+      },
+    )
+    .patch(
+      "/",
+      describeRoute({
+        summary: "Update configuration",
+        description: "Update OpenCode configuration settings and preferences.",
+        operationId: "config.update",
+        responses: {
+          200: {
+            description: "Successfully updated config",
+            content: {
+              "application/json": {
+                schema: resolver(Config.Info),
+              },
+            },
+          },
+          ...errors(400),
+        },
+      }),
+      validator("json", Config.Info),
+      async (c) => {
+        const config = c.req.valid("json")
+        await Config.update(config)
+        return c.json(config)
+      },
+    )
+    .get(
+      "/providers",
+      describeRoute({
+        summary: "List config providers",
+        description: "Get a list of all configured AI providers and their default models.",
+        operationId: "config.providers",
+        responses: {
+          200: {
+            description: "List of providers",
+            content: {
+              "application/json": {
+                schema: resolver(
+                  z.object({
+                    providers: Provider.Info.array(),
+                    default: z.record(z.string(), z.string()),
+                  }),
+                ),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        using _ = log.time("providers")
+        const providers = await Provider.list().then((x) => mapValues(x, (item) => item))
+        return c.json({
+          providers: Object.values(providers),
+          default: mapValues(providers, (item) => Provider.sort(Object.values(item.models))[0].id),
+        })
+      },
+    ),
+)