@sleepy-ai/cli 0.1.5 → 0.1.7

package/src/question/index.ts

@@ -1,252 +0,0 @@
-import { Deferred, Effect, Layer, Schema, Context } from "effect"
-import { Bus } from "@/bus"
-import { BusEvent } from "@/bus/bus-event"
-import { InstanceState } from "@/effect"
-import { SessionID, MessageID } from "@/session/schema"
-import { zod } from "@/util/effect-zod"
-import { Log } from "@/util"
-import { withStatics } from "@/util/schema"
-import { QuestionID } from "./schema"
-
-const log = Log.create({ service: "question" })
-
-// Schemas
-
-export class Option extends Schema.Class<Option>("QuestionOption")({
-  label: Schema.String.annotate({
-    description: "Display text (1-5 words, concise)",
-  }),
-  description: Schema.String.annotate({
-    description: "Explanation of choice",
-  }),
-}) {
-  static readonly zod = zod(this)
-}
-
-const base = {
-  question: Schema.String.annotate({
-    description: "Complete question",
-  }),
-  header: Schema.String.annotate({
-    description: "Very short label (max 30 chars)",
-  }),
-  options: Schema.Array(Option).annotate({
-    description: "Available choices",
-  }),
-  multiple: Schema.optional(Schema.Boolean).annotate({
-    description: "Allow selecting multiple choices",
-  }),
-}
-
-export class Info extends Schema.Class<Info>("QuestionInfo")({
-  ...base,
-  custom: Schema.optional(Schema.Boolean).annotate({
-    description: "Allow typing a custom answer (default: true)",
-  }),
-  key: Schema.optional(Schema.String).annotate({
-    description: "i18n key for client-side translation (e.g. plan_exit). When set, clients may translate question/options text using this key as a namespace.",
-  }),
-  params: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
-    description: "Template parameters for i18n interpolation (e.g. { plan: '.sleepycode/plans/...' })",
-  }),
-}) {
-  static readonly zod = zod(this)
-}
-
-export class Prompt extends Schema.Class<Prompt>("QuestionPrompt")(base) {
-  static readonly zod = zod(this)
-}
-
-export class Tool extends Schema.Class<Tool>("QuestionTool")({
-  messageID: MessageID,
-  callID: Schema.String,
-}) {
-  static readonly zod = zod(this)
-}
-
-export class Request extends Schema.Class<Request>("QuestionRequest")({
-  id: QuestionID,
-  sessionID: SessionID,
-  questions: Schema.Array(Info).annotate({
-    description: "Questions to ask",
-  }),
-  tool: Schema.optional(Tool),
-}) {
-  static readonly zod = zod(this)
-}
-
-export const Answer = Schema.Array(Schema.String)
-  .annotate({ identifier: "QuestionAnswer" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Answer = Schema.Schema.Type<typeof Answer>
-
-export class Reply extends Schema.Class<Reply>("QuestionReply")({
-  answers: Schema.Array(Answer).annotate({
-    description: "User answers in order of questions (each answer is an array of selected labels)",
-  }),
-}) {
-  static readonly zod = zod(this)
-}
-
-class Replied extends Schema.Class<Replied>("QuestionReplied")({
-  sessionID: SessionID,
-  requestID: QuestionID,
-  answers: Schema.Array(Answer),
-}) {}
-
-class Rejected extends Schema.Class<Rejected>("QuestionRejected")({
-  sessionID: SessionID,
-  requestID: QuestionID,
-}) {}
-
-export const Event = {
-  Asked: BusEvent.define("question.asked", Request.zod),
-  Replied: BusEvent.define("question.replied", zod(Replied)),
-  Rejected: BusEvent.define("question.rejected", zod(Rejected)),
-}
-
-export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("QuestionRejectedError", {}) {
-  override get message() {
-    return "The user dismissed this question"
-  }
-}
-
-interface PendingEntry {
-  info: Request
-  deferred: Deferred.Deferred<ReadonlyArray<Answer>, RejectedError>
-}
-
-interface State {
-  pending: Map<QuestionID, PendingEntry>
-  // When true the question tool stays visible but ask() is never reached:
-  // the tool returns a [Never-Ask] directive so the model re-picks the best
-  // option for headless execution itself. Toggleable at runtime.
-  neverAsk: boolean
-}
-
-// Service
-
-export interface Interface {
-  readonly ask: (input: {
-    sessionID: SessionID
-    questions: ReadonlyArray<Info>
-    tool?: Tool
-  }) => Effect.Effect<ReadonlyArray<Answer>, RejectedError>
-  readonly reply: (input: { requestID: QuestionID; answers: ReadonlyArray<Answer> }) => Effect.Effect<void>
-  readonly reject: (requestID: QuestionID) => Effect.Effect<void>
-  readonly list: () => Effect.Effect<ReadonlyArray<Request>>
-  readonly neverAsk: () => Effect.Effect<boolean>
-  readonly setNeverAsk: (enabled: boolean) => Effect.Effect<void>
-}
-
-export class Service extends Context.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>(),
-          neverAsk: false,
-        }
-
-        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: ReadonlyArray<Info>
-      tool?: Tool
-    }) {
-      const pending = (yield* InstanceState.get(state)).pending
-      const id = QuestionID.ascending()
-      log.info("asking", { id, questions: input.questions.length })
-
-      const deferred = yield* Deferred.make<ReadonlyArray<Answer>, RejectedError>()
-      const info = Schema.decodeUnknownSync(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: ReadonlyArray<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)
-    })
-
-    const neverAsk = Effect.fn("Question.neverAsk")(function* () {
-      return (yield* InstanceState.get(state)).neverAsk
-    })
-
-    const setNeverAsk = Effect.fn("Question.setNeverAsk")(function* (enabled: boolean) {
-      const s = yield* InstanceState.get(state)
-      s.neverAsk = enabled
-      log.info("never-ask", { enabled })
-    })
-
-    return Service.of({ ask, reply, reject, list, neverAsk, setNeverAsk })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
-
-export * as Question from "."

package/src/question/schema.ts

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

package/src/server/adapter.bun.ts

@@ -1,40 +0,0 @@
-import type { Hono } from "hono"
-import { createBunWebSocket } from "hono/bun"
-import type { Adapter } from "./adapter"
-
-export const adapter: Adapter = {
-  create(app: Hono) {
-    const ws = createBunWebSocket()
-    return {
-      upgradeWebSocket: ws.upgradeWebSocket,
-      async listen(opts) {
-        const args = {
-          fetch: app.fetch,
-          hostname: opts.hostname,
-          idleTimeout: 0,
-          websocket: ws.websocket,
-        } as const
-        const start = (port: number) => {
-          try {
-            return Bun.serve({ ...args, port })
-          } catch {
-            return
-          }
-        }
-        const server = opts.port === 0 ? (start(4096) ?? start(0)) : start(opts.port)
-        if (!server) {
-          throw new Error(`Failed to start server on port ${opts.port}`)
-        }
-        if (!server.port) {
-          throw new Error(`Failed to resolve server address for port ${opts.port}`)
-        }
-        return {
-          port: server.port,
-          stop(close?: boolean) {
-            return Promise.resolve(server.stop(close))
-          },
-        }
-      },
-    }
-  },
-}

package/src/server/adapter.node.ts

@@ -1,66 +0,0 @@
-import { createAdaptorServer, type ServerType } from "@hono/node-server"
-import { createNodeWebSocket } from "@hono/node-ws"
-import type { Hono } from "hono"
-import type { Adapter } from "./adapter"
-
-export const adapter: Adapter = {
-  create(app: Hono) {
-    const ws = createNodeWebSocket({ app })
-    return {
-      upgradeWebSocket: ws.upgradeWebSocket,
-      async listen(opts) {
-        const start = (port: number) =>
-          new Promise<ServerType>((resolve, reject) => {
-            const server = createAdaptorServer({ fetch: app.fetch })
-            ws.injectWebSocket(server)
-            const fail = (err: Error) => {
-              cleanup()
-              reject(err)
-            }
-            const ready = () => {
-              cleanup()
-              resolve(server)
-            }
-            const cleanup = () => {
-              server.off("error", fail)
-              server.off("listening", ready)
-            }
-            server.once("error", fail)
-            server.once("listening", ready)
-            server.listen(port, opts.hostname)
-          })
-
-        const server = opts.port === 0 ? await start(4096).catch(() => start(0)) : await start(opts.port)
-        const addr = server.address()
-        if (!addr || typeof addr === "string") {
-          throw new Error(`Failed to resolve server address for port ${opts.port}`)
-        }
-
-        let closing: Promise<void> | undefined
-        return {
-          port: addr.port,
-          stop(close?: boolean) {
-            closing ??= new Promise((resolve, reject) => {
-              server.close((err) => {
-                if (err) {
-                  reject(err)
-                  return
-                }
-                resolve()
-              })
-              if (close) {
-                if ("closeAllConnections" in server && typeof server.closeAllConnections === "function") {
-                  server.closeAllConnections()
-                }
-                if ("closeIdleConnections" in server && typeof server.closeIdleConnections === "function") {
-                  server.closeIdleConnections()
-                }
-              }
-            })
-            return closing
-          },
-        }
-      },
-    }
-  },
-}

package/src/server/adapter.ts

@@ -1,21 +0,0 @@
-import type { Hono } from "hono"
-import type { UpgradeWebSocket } from "hono/ws"
-
-export type Opts = {
-  port: number
-  hostname: string
-}
-
-export type Listener = {
-  port: number
-  stop: (close?: boolean) => Promise<void>
-}
-
-export interface Runtime {
-  upgradeWebSocket: UpgradeWebSocket
-  listen(opts: Opts): Promise<Listener>
-}
-
-export interface Adapter {
-  create(app: Hono): Runtime
-}

package/src/server/auth.ts

@@ -1,16 +0,0 @@
-import { Flag } from "@/flag/flag"
-
-export function serverAuthHeader(credentials?: { password?: string; username?: string }): string | undefined {
-  const password = credentials?.password ?? Flag.SLEEPYCODE_SERVER_PASSWORD
-  if (!password) return undefined
-  const username = credentials?.username ?? Flag.SLEEPYCODE_SERVER_USERNAME ?? "sleepycode"
-  return `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`
-}
-
-export function serverAuthHeaders(credentials?: { password?: string; username?: string }):
-  | { Authorization: string }
-  | undefined {
-  const header = serverAuthHeader(credentials)
-  if (!header) return undefined
-  return { Authorization: header }
-}

package/src/server/error.ts

@@ -1,53 +0,0 @@
-import { resolver } from "hono-openapi"
-import z from "zod"
-import { NotFoundError } from "../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(NotFoundError.Schema),
-      },
-    },
-  },
-  409: {
-    description: "Conflict — session resource is busy",
-    content: {
-      "application/json": {
-        schema: resolver(
-          z
-            .object({
-              name: z.literal("UnknownError"),
-              data: z.object({ message: z.string() }),
-            })
-            .meta({
-              ref: "ConflictError",
-            }),
-        ),
-      },
-    },
-  },
-} 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/fence.ts

@@ -1,81 +0,0 @@
-import type { MiddlewareHandler } from "hono"
-import { Database, inArray } from "@/storage"
-import { EventSequenceTable } from "@/sync/event.sql"
-import { Workspace } from "@/control-plane/workspace"
-import type { WorkspaceID } from "@/control-plane/schema"
-import { Log } from "@/util"
-
-const HEADER = "x-sleepycode-sync"
-type State = Record<string, number>
-const log = Log.create({ service: "fence" })
-
-export function load(ids?: string[]) {
-  const rows = Database.use((db) => {
-    if (!ids?.length) {
-      return db.select().from(EventSequenceTable).all()
-    }
-
-    return db.select().from(EventSequenceTable).where(inArray(EventSequenceTable.aggregate_id, ids)).all()
-  })
-
-  return Object.fromEntries(rows.map((row) => [row.aggregate_id, row.seq])) as State
-}
-
-export function diff(prev: State, next: State) {
-  const ids = new Set([...Object.keys(prev), ...Object.keys(next)])
-  return Object.fromEntries(
-    [...ids]
-      .map((id) => [id, next[id] ?? -1] as const)
-      .filter(([id, seq]) => {
-        return (prev[id] ?? -1) !== seq
-      }),
-  ) as State
-}
-
-export function parse(headers: Headers) {
-  const raw = headers.get(HEADER)
-  if (!raw) return
-
-  let data
-
-  try {
-    data = JSON.parse(raw)
-  } catch {
-    return
-  }
-
-  if (!data || typeof data !== "object") return
-
-  return Object.fromEntries(
-    Object.entries(data).filter(([id, seq]) => {
-      return typeof id === "string" && Number.isInteger(seq)
-    }),
-  ) as State
-}
-
-export async function wait(workspaceID: WorkspaceID, state: State, signal?: AbortSignal) {
-  log.info("waiting for state", {
-    workspaceID,
-    state,
-  })
-  await Workspace.waitForSync(workspaceID, state, signal)
-  log.info("state fully synced", {
-    workspaceID,
-    state,
-  })
-}
-
-export const FenceMiddleware: MiddlewareHandler = async (c, next) => {
-  if (c.req.method === "GET" || c.req.method === "HEAD" || c.req.method === "OPTIONS") return next()
-
-  const prev = load()
-  await next()
-  const current = diff(prev, load())
-
-  if (Object.keys(current).length > 0) {
-    log.info("header", {
-      diff: current,
-    })
-    c.res.headers.set(HEADER, JSON.stringify(current))
-  }
-}

package/src/server/mdns.ts

@@ -1,60 +0,0 @@
-import { Log } from "@/util"
-import { Bonjour } from "bonjour-service"
-
-const log = Log.create({ service: "mdns" })
-
-let bonjour: Bonjour | undefined
-let currentPort: number | undefined
-
-export function publish(port: number, domain?: string) {
-  if (currentPort === port) return
-  if (bonjour) unpublish()
-
-  try {
-    const host = domain ?? "sleepycode.local"
-    const name = `sleepycode-${port}`
-    bonjour = new Bonjour()
-    const service = bonjour.publish({
-      name,
-      type: "http",
-      host,
-      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")
-  }
-}
-
-export * as MDNS from "./mdns"