@sleepy-ai/cli 0.1.6 → 0.1.7

package/src/server/routes/control/workspace.ts

@@ -1,203 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, resolver, validator } from "hono-openapi"
-import z from "zod"
-import { listAdaptors } from "@/control-plane/adaptors"
-import { Workspace } from "@/control-plane/workspace"
-import { Instance } from "@/project/instance"
-import { errors } from "../../error"
-import { lazy } from "@/util/lazy"
-import { Log } from "@/util"
-import { errorData } from "@/util/error"
-
-const log = Log.create({ service: "server.workspace" })
-
-export const WorkspaceRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/adaptor",
-      describeRoute({
-        summary: "List workspace adaptors",
-        description: "List all available workspace adaptors for the current project.",
-        operationId: "experimental.workspace.adaptor.list",
-        responses: {
-          200: {
-            description: "Workspace adaptors",
-            content: {
-              "application/json": {
-                schema: resolver(
-                  z.array(
-                    z.object({
-                      type: z.string(),
-                      name: z.string(),
-                      description: z.string(),
-                    }),
-                  ),
-                ),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json(await listAdaptors(Instance.project.id))
-      },
-    )
-    .post(
-      "/",
-      describeRoute({
-        summary: "Create workspace",
-        description: "Create a workspace for the current project.",
-        operationId: "experimental.workspace.create",
-        responses: {
-          200: {
-            description: "Workspace created",
-            content: {
-              "application/json": {
-                schema: resolver(Workspace.Info),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator(
-        "json",
-        Workspace.create.schema.omit({
-          projectID: true,
-        }),
-      ),
-      async (c) => {
-        const body = c.req.valid("json")
-        const workspace = await Workspace.create({
-          projectID: Instance.project.id,
-          ...body,
-        })
-        return c.json(workspace)
-      },
-    )
-    .get(
-      "/",
-      describeRoute({
-        summary: "List workspaces",
-        description: "List all workspaces.",
-        operationId: "experimental.workspace.list",
-        responses: {
-          200: {
-            description: "Workspaces",
-            content: {
-              "application/json": {
-                schema: resolver(z.array(Workspace.Info)),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json(Workspace.list(Instance.project))
-      },
-    )
-    .get(
-      "/status",
-      describeRoute({
-        summary: "Workspace status",
-        description: "Get connection status for workspaces in the current project.",
-        operationId: "experimental.workspace.status",
-        responses: {
-          200: {
-            description: "Workspace status",
-            content: {
-              "application/json": {
-                schema: resolver(z.array(Workspace.ConnectionStatus)),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        const ids = new Set(Workspace.list(Instance.project).map((item) => item.id))
-        return c.json(Workspace.status().filter((item) => ids.has(item.workspaceID)))
-      },
-    )
-    .delete(
-      "/:id",
-      describeRoute({
-        summary: "Remove workspace",
-        description: "Remove an existing workspace.",
-        operationId: "experimental.workspace.remove",
-        responses: {
-          200: {
-            description: "Workspace removed",
-            content: {
-              "application/json": {
-                schema: resolver(Workspace.Info.optional()),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator(
-        "param",
-        z.object({
-          id: Workspace.Info.shape.id,
-        }),
-      ),
-      async (c) => {
-        const { id } = c.req.valid("param")
-        return c.json(await Workspace.remove(id))
-      },
-    )
-    .post(
-      "/:id/session-restore",
-      describeRoute({
-        summary: "Restore session into workspace",
-        description: "Replay a session's sync events into the target workspace in batches.",
-        operationId: "experimental.workspace.sessionRestore",
-        responses: {
-          200: {
-            description: "Session replay started",
-            content: {
-              "application/json": {
-                schema: resolver(
-                  z.object({
-                    total: z.number().int().min(0),
-                  }),
-                ),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator("param", z.object({ id: Workspace.Info.shape.id })),
-      validator("json", Workspace.sessionRestore.schema.omit({ workspaceID: true })),
-      async (c) => {
-        const { id } = c.req.valid("param")
-        const body = c.req.valid("json")
-        log.info("session restore route requested", {
-          workspaceID: id,
-          sessionID: body.sessionID,
-          directory: Instance.directory,
-        })
-        try {
-          const result = await Workspace.sessionRestore({
-            workspaceID: id,
-            ...body,
-          })
-          log.info("session restore route complete", {
-            workspaceID: id,
-            sessionID: body.sessionID,
-            total: result.total,
-          })
-          return c.json(result)
-        } catch (err) {
-          log.error("session restore route failed", {
-            workspaceID: id,
-            sessionID: body.sessionID,
-            error: errorData(err),
-          })
-          throw err
-        }
-      },
-    ),
-)

package/src/server/routes/global.ts

@@ -1,367 +0,0 @@
-import { Hono, type Context } from "hono"
-import { describeRoute, resolver, validator } from "hono-openapi"
-import { streamSSE } from "hono/streaming"
-import { Effect } from "effect"
-import z from "zod"
-import { BusEvent } from "@/bus/bus-event"
-import { SyncEvent } from "@/sync"
-import { GlobalBus } from "@/bus/global"
-import { AppRuntime } from "@/effect/app-runtime"
-import { AsyncQueue } from "@/util/queue"
-import { Instance } from "../../project/instance"
-import { Installation } from "@/installation"
-import { InstallationVersion } from "@/installation/version"
-import { Log } from "../../util"
-import { lazy } from "../../util/lazy"
-import { Config } from "../../config"
-import { ExternalImport } from "../../session/external-import"
-import { errors } from "../error"
-
-const log = Log.create({ service: "server" })
-
-// Cap on buffered SSE events per connection. The bus delta firehose is pushed
-// into the queue synchronously and never blocks the producer, so a slow/stalled
-// consumer would otherwise grow it without limit and exhaust server memory.
-// Events are best-effort telemetry (DB authoritative + heartbeat) so drop-oldest
-// is safe under sustained backpressure. At ~1KB/event the default is ≈10MB
-// worst-case per stalled connection. See routes/instance/event.ts for the full
-// rationale (incl. heartbeat/sentinel lag under saturation). Tune via env.
-const EVENT_QUEUE_CAPACITY = Number(process.env["SLEEPYCODE_EVENT_QUEUE_CAPACITY"]) || 10_000
-
-export const GlobalDisposedEvent = BusEvent.define("global.disposed", z.object({}))
-
-async function streamEvents(c: Context, subscribe: (q: AsyncQueue<string | null>) => () => void) {
-  return streamSSE(c, async (stream) => {
-    const q = new AsyncQueue<string | null>({ capacity: EVENT_QUEUE_CAPACITY })
-    let done = false
-
-    q.push(
-      JSON.stringify({
-        payload: {
-          type: "server.connected",
-          properties: {},
-        },
-      }),
-    )
-
-    // Send heartbeat every 10s to prevent stalled proxy streams.
-    const heartbeat = setInterval(() => {
-      q.push(
-        JSON.stringify({
-          payload: {
-            type: "server.heartbeat",
-            properties: {},
-          },
-        }),
-      )
-    }, 10_000)
-
-    const stop = () => {
-      if (done) return
-      done = true
-      clearInterval(heartbeat)
-      unsub()
-      q.push(null)
-      if (q.dropped > 0) log.warn("global event dropped under backpressure", { dropped: q.dropped })
-      log.info("global event disconnected", { buffered: q.size })
-    }
-
-    const unsub = subscribe(q)
-
-    stream.onAbort(stop)
-
-    try {
-      for await (const data of q) {
-        if (data === null) return
-        await stream.writeSSE({ data })
-      }
-    } finally {
-      stop()
-    }
-  })
-}
-
-export const GlobalRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/health",
-      describeRoute({
-        summary: "Get health",
-        description: "Get health information about the OpenCode server.",
-        operationId: "global.health",
-        responses: {
-          200: {
-            description: "Health information",
-            content: {
-              "application/json": {
-                schema: resolver(z.object({ healthy: z.literal(true), version: z.string() })),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json({ healthy: true, version: InstallationVersion })
-      },
-    )
-    .get(
-      "/event",
-      describeRoute({
-        summary: "Get global events",
-        description: "Subscribe to global events from the OpenCode system using server-sent events.",
-        operationId: "global.event",
-        responses: {
-          200: {
-            description: "Event stream",
-            content: {
-              "text/event-stream": {
-                schema: resolver(
-                  z
-                    .object({
-                      directory: z.string(),
-                      project: z.string().optional(),
-                      workspace: z.string().optional(),
-                      payload: z.union([...BusEvent.payloads(), ...SyncEvent.payloads()]),
-                    })
-                    .meta({
-                      ref: "GlobalEvent",
-                    }),
-                ),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        log.info("global event connected")
-        c.header("Cache-Control", "no-cache, no-transform")
-        c.header("X-Accel-Buffering", "no")
-        c.header("X-Content-Type-Options", "nosniff")
-
-        return streamEvents(c, (q) => {
-          async function handler(event: any) {
-            q.push(JSON.stringify(event))
-          }
-          GlobalBus.on("event", handler)
-          return () => GlobalBus.off("event", handler)
-        })
-      },
-    )
-    .get(
-      "/config",
-      describeRoute({
-        summary: "Get global configuration",
-        description: "Retrieve the current global OpenCode configuration settings and preferences.",
-        operationId: "global.config.get",
-        responses: {
-          200: {
-            description: "Get global config info",
-            content: {
-              "application/json": {
-                schema: resolver(Config.Info),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json(await AppRuntime.runPromise(Config.Service.use((cfg) => cfg.getGlobal())))
-      },
-    )
-    .patch(
-      "/config",
-      describeRoute({
-        summary: "Update global configuration",
-        description: "Update global OpenCode configuration settings and preferences.",
-        operationId: "global.config.update",
-        responses: {
-          200: {
-            description: "Successfully updated global config",
-            content: {
-              "application/json": {
-                schema: resolver(Config.Info),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator("json", Config.Info),
-      async (c) => {
-        const config = c.req.valid("json")
-        const next = await AppRuntime.runPromise(Config.Service.use((cfg) => cfg.updateGlobal(config)))
-        return c.json(next)
-      },
-    )
-    .post(
-      "/dispose",
-      describeRoute({
-        summary: "Dispose instance",
-        description: "Clean up and dispose all OpenCode instances, releasing all resources.",
-        operationId: "global.dispose",
-        responses: {
-          200: {
-            description: "Global disposed",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        await Instance.disposeAll()
-        GlobalBus.emit("event", {
-          directory: "global",
-          payload: {
-            type: GlobalDisposedEvent.type,
-            properties: {},
-          },
-        })
-        return c.json(true)
-      },
-    )
-    .post(
-      "/upgrade",
-      describeRoute({
-        summary: "Upgrade opencode",
-        description: "Upgrade opencode to the specified version or latest if not specified.",
-        operationId: "global.upgrade",
-        responses: {
-          200: {
-            description: "Upgrade result",
-            content: {
-              "application/json": {
-                schema: resolver(
-                  z.union([
-                    z.object({
-                      success: z.literal(true),
-                      version: z.string(),
-                    }),
-                    z.object({
-                      success: z.literal(false),
-                      error: z.string(),
-                    }),
-                  ]),
-                ),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator(
-        "json",
-        z.object({
-          target: z.string().optional(),
-        }),
-      ),
-      async (c) => {
-        const result = await AppRuntime.runPromise(
-          Installation.Service.use((svc) =>
-            Effect.gen(function* () {
-              const method = yield* svc.method()
-              if (method === "unknown") {
-                return { success: false as const, status: 400 as const, error: "Unknown installation method" }
-              }
-
-              const target = c.req.valid("json").target || (yield* svc.latest(method))
-              const result = yield* Effect.catch(
-                svc.upgrade(method, target).pipe(Effect.as({ success: true as const, version: target })),
-                (err) =>
-                  Effect.succeed({
-                    success: false as const,
-                    status: 500 as const,
-                    error: err instanceof Error ? err.message : String(err),
-                  }),
-              )
-              if (!result.success) return result
-              return { ...result, status: 200 as const }
-            }),
-          ),
-        )
-        if (!result.success) {
-          return c.json({ success: false, error: result.error }, result.status)
-        }
-        const target = result.version
-        GlobalBus.emit("event", {
-          directory: "global",
-          payload: {
-            type: Installation.Event.Updated.type,
-            properties: { version: target },
-          },
-        })
-        return c.json({ success: true, version: target })
-      },
-    )
-    .get(
-      "/import/scan",
-      describeRoute({
-        summary: "Scan external session sources",
-        description:
-          "Detect availability and session counts of external AI tool session stores (Claude Code, Codex, opencode). Read-only.",
-        operationId: "global.import.scan",
-        responses: {
-          200: {
-            description: "Per-source availability and counts",
-            content: {
-              "application/json": {
-                schema: resolver(
-                  z.record(
-                    z.enum(["cc", "codex", "opencode"]),
-                    z.object({ available: z.boolean(), sessions: z.number(), imported: z.number() }),
-                  ),
-                ),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json(await ExternalImport.scan())
-      },
-    )
-    .post(
-      "/import/run",
-      describeRoute({
-        summary: "Import external sessions",
-        description:
-          "Import sessions from external AI tools (Claude Code, Codex, opencode) into sleepycode. Idempotent; pass force to re-sync. Per-source failures are not thrown as HTTP errors — they are collected into the corresponding stats.errors[] while other sources continue.",
-        operationId: "global.import.run",
-        responses: {
-          200: {
-            description: "Per-source import stats",
-            content: {
-              "application/json": {
-                schema: resolver(
-                  z.record(
-                    z.enum(["cc", "codex", "opencode"]),
-                    z.object({
-                      scanned: z.number(),
-                      imported: z.number(),
-                      resynced: z.number(),
-                      skipped: z.number(),
-                      errors: z.array(z.string()),
-                    }),
-                  ),
-                ),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator(
-        "json",
-        z.object({
-          sources: z.array(z.enum(["cc", "codex", "opencode"])).optional(),
-          force: z.boolean().optional(),
-        }),
-      ),
-      async (c) => {
-        const { sources, force } = c.req.valid("json")
-        return c.json(await ExternalImport.runAll({ sources, force }))
-      },
-    ),
-)

package/src/server/routes/instance/bash-interactive.ts

@@ -1,82 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator } from "hono-openapi"
-import { resolver } from "hono-openapi"
-import * as BashInteractive from "@/tool/bash-interactive"
-import z from "zod"
-import { errors } from "../../error"
-import { lazy } from "@/util/lazy"
-import { jsonRequest } from "./trace"
-
-const ReplyInput = z.object({
-  output: z.string().describe("Captured output from the interactive command"),
-  exitCode: z.number().describe("Exit code of the interactive command"),
-})
-
-export const BashInteractiveRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/",
-      describeRoute({
-        summary: "List pending interactive bash requests",
-        description: "Get all pending interactive bash requests waiting for user interaction.",
-        operationId: "bash.interactive.list",
-        responses: {
-          200: {
-            description: "List of pending interactive requests",
-            content: {
-              "application/json": {
-                schema: resolver(
-                  z.array(
-                    z.object({
-                      id: z.string(),
-                      command: z.string(),
-                      cwd: z.string(),
-                      description: z.string(),
-                    }),
-                  ),
-                ),
-              },
-            },
-          },
-        },
-      }),
-      async (c) =>
-        jsonRequest("BashInteractiveRoutes.list", c, function* () {
-          const svc = yield* BashInteractive.Service
-          return yield* svc.list()
-        }),
-    )
-    .post(
-      "/:id/reply",
-      describeRoute({
-        summary: "Reply to interactive bash request",
-        description: "Provide the result of an interactive bash command execution.",
-        operationId: "bash.interactive.reply",
-        responses: {
-          200: {
-            description: "Reply accepted",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-          ...errors(400, 404),
-        },
-      }),
-      validator("param", z.object({ id: z.string() })),
-      validator("json", ReplyInput),
-      async (c) =>
-        jsonRequest("BashInteractiveRoutes.reply", c, function* () {
-          const params = c.req.valid("param")
-          const json = c.req.valid("json")
-          const svc = yield* BashInteractive.Service
-          yield* svc.reply({
-            id: params.id,
-            output: json.output,
-            exitCode: json.exitCode,
-          })
-          return true
-        }),
-    ),
-)