jonsoc 1.1.48 → 1.1.50

package/src/pty/index.ts

@@ -1,241 +0,0 @@
-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 "@jonsoc/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",
-      OPENCODE_TERMINAL: "1",
-    } 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"
-      for (const ws of session.subscribers) {
-        ws.close()
-      }
-      session.subscribers.clear()
-      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

@@ -1,176 +0,0 @@
-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).max(3).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 })
-    const questions = input.questions.map((question) => ({
-      ...question,
-      options: question.options.slice(0, 3),
-      custom: true,
-    }))
-
-    return new Promise<Answer[]>((resolve, reject) => {
-      const info: Request = {
-        id,
-        sessionID: input.sessionID,
-        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

@@ -1,61 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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 = `jonsoc-${port}`
-      bonjour = new Bonjour()
-      const service = bonjour.publish({
-        name,
-        type: "http",
-        host: "jonsoc.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

@@ -1,92 +0,0 @@
-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 JonsOC 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 JonsOC 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),
-        })
-      },
-    ),
-)