@sleepy-ai/cli 0.1.6 → 0.1.8

package/src/server/routes/instance/workflows.ts

@@ -1,142 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import z from "zod"
-import { lazy } from "@/util/lazy"
-import { Identifier } from "@/id/id"
-import { workflowRef } from "@/workflow/runtime-ref"
-import { jsonRequest } from "./trace"
-import type { SessionID } from "@/session/schema"
-
-// Read-only routes (transcript/structure) accept BOTH runID shapes: a top-level
-// run is `wf_` + 26 base62 (Identifier.descending), a nested child workflow is
-// `wf_` + 64 hex (sha256 of parent runID + key, see runtime.ts). The resume route
-// keeps the strict 26-char form because only top-level runs are resumable AND it
-// builds a filesystem path from the id; these read routes only do an in-memory
-// runtime map lookup, so the wider (still traversal-proof — no `.`/`/`) charset is
-// safe here.
-const READ_RUN_ID = /^wf_(?:[0-9A-Za-z]{26}|[0-9a-f]{64})$/
-
-export const WorkflowRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/",
-      describeRoute({
-        summary: "List workflow runs",
-        description:
-          "List dynamic-workflow runs for a session. sessionID is REQUIRED — there is no per-user identity, so the session is the access boundary and an omitted/invalid sessionID is a 400 (never an unfiltered all-session listing). Empty when the workflow runtime is not running.",
-        operationId: "workflow.list",
-        responses: {
-          200: {
-            description: "Workflow runs",
-            content: { "application/json": { schema: resolver(z.array(z.any())) } },
-          },
-        },
-      }),
-      validator("query", z.object({ sessionID: Identifier.schema("session") })),
-      async (c) =>
-        jsonRequest("WorkflowRoutes.list", c, function* () {
-          const runtime = workflowRef.current
-          if (!runtime) return []
-          const query = c.req.valid("query")
-          return yield* runtime.list({ sessionID: query.sessionID as SessionID })
-        }),
-    )
-    .post(
-      "/:runID/resume",
-      describeRoute({
-        summary: "Resume a workflow run",
-        description:
-          "Re-launch a persisted workflow run by id. Returns { runID, resumed }; resumed is false if the run is unknown, still running, or has no persisted script.",
-        operationId: "workflow.resume",
-        responses: {
-          200: {
-            description: "Resume result",
-            content: {
-              "application/json": { schema: resolver(z.object({ runID: z.string(), resumed: z.boolean() })) },
-            },
-          },
-        },
-      }),
-      validator(
-        "param",
-        z.object({
-          // Strict shape, NOT just startsWith("wf"): runID flows into
-          // scriptPath = join(scriptDir, runID + ".js"), so a value like
-          // `wf_../../../etc/passwd` (which startsWith "wf") would escape scriptDir.
-          // Identifier mints `wf_` + 26 base62 chars; this charset has no `.` or `/`,
-          // so it is traversal-proof by construction. The `{26}` tracks
-          // Identifier.LENGTH — if that constant ever changes, widen this too (the
-          // in-depth persistence guard uses `+`, so it stays correct regardless).
-          runID: z.string().regex(/^wf_[0-9A-Za-z]{26}$/, "invalid workflow runID"),
-        }),
-      ),
-      async (c) =>
-        jsonRequest("WorkflowRoutes.resume", c, function* () {
-          const runtime = workflowRef.current
-          const params = c.req.valid("param")
-          if (!runtime) return { runID: params.runID, resumed: false }
-          return yield* runtime.resume({ runID: params.runID })
-        }),
-    )
-    .get(
-      "/:runID/transcript",
-      describeRoute({
-        summary: "Get a workflow run's full transcript",
-        description:
-          "Return the complete ordered phase/log transcript for one run, straight from the runtime's in-memory buffer (uncapped, unlike the tool-part metadata copy). Empty when the runtime is down or the run is unknown.",
-        operationId: "workflow.transcript",
-        responses: {
-          200: {
-            description: "Full transcript",
-            content: {
-              "application/json": {
-                schema: resolver(
-                  z.object({
-                    runID: z.string(),
-                    transcript: z.array(z.object({ kind: z.enum(["phase", "log"]), text: z.string() })),
-                  }),
-                ),
-              },
-            },
-          },
-        },
-      }),
-      validator("param", z.object({ runID: z.string().regex(READ_RUN_ID, "invalid workflow runID") })),
-      async (c) =>
-        jsonRequest("WorkflowRoutes.transcript", c, function* () {
-          const runtime = workflowRef.current
-          const params = c.req.valid("param")
-          if (!runtime) return { runID: params.runID, transcript: [] }
-          const transcript = yield* runtime.transcript({ runID: params.runID })
-          return { runID: params.runID, transcript: transcript.slice() }
-        }),
-    )
-    .get(
-      "/:runID/structure",
-      describeRoute({
-        summary: "Get a workflow run's structure tree",
-        description:
-          "Return the observability-only structure tree (phase/agent/workflow nodes with live status) for one run. Empty when the runtime is down or the run is unknown.",
-        operationId: "workflow.structure",
-        responses: {
-          200: {
-            description: "Structure tree",
-            content: {
-              "application/json": {
-                schema: resolver(z.object({ runID: z.string(), nodes: z.array(z.any()) })),
-              },
-            },
-          },
-        },
-      }),
-      validator("param", z.object({ runID: z.string().regex(READ_RUN_ID, "invalid workflow runID") })),
-      async (c) =>
-        jsonRequest("WorkflowRoutes.structure", c, function* () {
-          const runtime = workflowRef.current
-          const params = c.req.valid("param")
-          if (!runtime) return { runID: params.runID, nodes: [] }
-          const s = yield* runtime.structure({ runID: params.runID })
-          return { runID: params.runID, nodes: s.nodes }
-        }),
-    ),
-)

package/src/server/routes/ui.ts

@@ -1,37 +0,0 @@
-import { Flag } from "@/flag/flag"
-import { Hono } from "hono"
-import { getMimeType } from "hono/utils/mime"
-import fs from "node:fs/promises"
-
-const embeddedUIPromise = Flag.SLEEPYCODE_DISABLE_EMBEDDED_WEB_UI
-  ? Promise.resolve(null)
-  : // @ts-expect-error - generated file at build time
-    import("opencode-web-ui.gen.ts").then((module) => module.default as Record<string, string>).catch(() => null)
-
-const DEFAULT_CSP =
-  "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; media-src 'self' data:; connect-src 'self' data:"
-
-export const UIRoutes = (): Hono =>
-  new Hono().all("/*", async (c) => {
-    const embeddedWebUI = await embeddedUIPromise
-    const path = c.req.path
-
-    if (embeddedWebUI) {
-      const match = embeddedWebUI[path.replace(/^\//, "")] ?? embeddedWebUI["index.html"] ?? null
-      if (!match) return c.json({ error: "Not Found" }, 404)
-
-      if (await fs.exists(match)) {
-        const mime = getMimeType(match) ?? "text/plain"
-        c.header("Content-Type", mime)
-        if (mime.startsWith("text/html")) {
-          c.header("Content-Security-Policy", DEFAULT_CSP)
-        }
-        return c.body(new Uint8Array(await fs.readFile(match)))
-      } else {
-        return c.json({ error: "Not Found" }, 404)
-      }
-    } else {
-      // Web UI temporarily disabled. Embedded UI was not included in this build.
-      return c.json({ error: "Web UI is temporarily unavailable." }, 503)
-    }
-  })

package/src/server/server.ts

@@ -1,146 +0,0 @@
-import { generateSpecs } from "hono-openapi"
-import { Hono } from "hono"
-import { adapter } from "#hono"
-import { lazy } from "@/util/lazy"
-import { Log } from "@/util"
-import { Flag } from "@/flag/flag"
-import { WorkspaceID } from "@/control-plane/schema"
-import { MDNS } from "./mdns"
-import { AuthMiddleware, CompressionMiddleware, CorsMiddleware, ErrorMiddleware, LoggerMiddleware } from "./middleware"
-import { FenceMiddleware } from "./fence"
-import { initProjectors } from "./projectors"
-import { InstanceRoutes } from "./routes/instance"
-import { ControlPlaneRoutes } from "./routes/control"
-import { UIRoutes } from "./routes/ui"
-import { GlobalRoutes } from "./routes/global"
-import { WorkspaceRouterMiddleware } from "./workspace"
-import { InstanceMiddleware } from "./routes/instance/middleware"
-import { WorkspaceRoutes } from "./routes/control/workspace"
-
-// @ts-ignore This global is needed to prevent ai-sdk from logging warnings to stdout https://github.com/vercel/ai/blob/2dc67e0ef538307f21368db32d5a12345d98831b/packages/ai/src/logger/log-warnings.ts#L85
-globalThis.AI_SDK_LOG_WARNINGS = false
-
-initProjectors()
-
-const log = Log.create({ service: "server" })
-
-export type Listener = {
-  hostname: string
-  port: number
-  url: URL
-  stop: (close?: boolean) => Promise<void>
-}
-
-export const Default = lazy(() => create({}))
-
-function create(opts: { cors?: string[] }) {
-  const app = new Hono()
-    .onError(ErrorMiddleware)
-    .use(CorsMiddleware(opts))
-    .use(LoggerMiddleware)
-    .use(AuthMiddleware)
-    .use(CompressionMiddleware)
-    .route("/global", GlobalRoutes())
-
-  const runtime = adapter.create(app)
-
-  if (Flag.SLEEPYCODE_WORKSPACE_ID) {
-    return {
-      app: app
-        .use(InstanceMiddleware(Flag.SLEEPYCODE_WORKSPACE_ID ? WorkspaceID.make(Flag.SLEEPYCODE_WORKSPACE_ID) : undefined))
-        .use(FenceMiddleware)
-        .route("/", InstanceRoutes(runtime.upgradeWebSocket)),
-      runtime,
-    }
-  }
-
-  return {
-    app: app
-      .route("/", ControlPlaneRoutes())
-      .route(
-        "/",
-        new Hono()
-          .use(InstanceMiddleware())
-          .route("/experimental/workspace", WorkspaceRoutes())
-          .use(WorkspaceRouterMiddleware(runtime.upgradeWebSocket))
-          .route("/", InstanceRoutes(runtime.upgradeWebSocket)),
-      )
-      .route("/", UIRoutes()),
-    runtime,
-  }
-}
-
-export async function openapi() {
-  // Build a fresh app with all routes registered directly so
-  // hono-openapi can see describeRoute metadata (`.route()` wraps
-  // handlers when the sub-app has a custom errorHandler, which
-  // strips the metadata symbol).
-  const { app } = create({})
-  const result = await generateSpecs(app, {
-    documentation: {
-      info: {
-        title: "opencode",
-        version: "1.0.0",
-        description: "opencode api",
-      },
-      openapi: "3.1.1",
-    },
-  })
-  return result
-}
-
-export let url: URL
-
-export async function listen(opts: {
-  port: number
-  hostname: string
-  mdns?: boolean
-  mdnsDomain?: string
-  cors?: string[]
-  noAuth?: boolean
-}): Promise<Listener> {
-  const isLoopback =
-    opts.hostname === "127.0.0.1" || opts.hostname === "localhost" || opts.hostname === "::1"
-  if (!isLoopback && !Flag.SLEEPYCODE_SERVER_PASSWORD && !opts.noAuth) {
-    throw new Error(
-      "Refusing to bind to non-loopback address without SLEEPYCODE_SERVER_PASSWORD. " +
-        "Set the environment variable or pass noAuth to explicitly allow unauthenticated access.",
-    )
-  }
-
-  const built = create(opts)
-  const server = await built.runtime.listen(opts)
-
-  const next = new URL("http://localhost")
-  next.hostname = opts.hostname
-  next.port = String(server.port)
-  url = next
-
-  const mdns =
-    opts.mdns &&
-    server.port &&
-    opts.hostname !== "127.0.0.1" &&
-    opts.hostname !== "localhost" &&
-    opts.hostname !== "::1"
-  if (mdns) {
-    MDNS.publish(server.port, opts.mdnsDomain)
-  } else if (opts.mdns) {
-    log.warn("mDNS enabled but hostname is loopback; skipping mDNS publish")
-  }
-
-  let closing: Promise<void> | undefined
-  return {
-    hostname: opts.hostname,
-    port: server.port,
-    url: next,
-    stop(close?: boolean) {
-      closing ??= (async () => {
-        if (mdns) MDNS.unpublish()
-        await server.stop(close)
-      })()
-      return closing
-    },
-  }
-}
-
-export * as Server from "./server"

package/src/server/workspace.ts

@@ -1,122 +0,0 @@
-import type { MiddlewareHandler } from "hono"
-import type { UpgradeWebSocket } from "hono/ws"
-import { getAdaptor } from "@/control-plane/adaptors"
-import { WorkspaceID } from "@/control-plane/schema"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import { Workspace } from "@/control-plane/workspace"
-import { Flag } from "@/flag/flag"
-import { InstanceBootstrap } from "@/project/bootstrap"
-import { Instance } from "@/project/instance"
-import { Session } from "@/session"
-import { SessionID } from "@/session/schema"
-import { AppRuntime } from "@/effect/app-runtime"
-import { Effect } from "effect"
-import { Log } from "@/util"
-import { ServerProxy } from "./proxy"
-
-type Rule = { method?: string; path: string; exact?: boolean; action: "local" | "forward" }
-
-const RULES: Array<Rule> = [
-  { path: "/session/status", action: "forward" },
-  { method: "GET", path: "/session", action: "local" },
-]
-
-function local(method: string, path: string) {
-  for (const rule of RULES) {
-    if (rule.method && rule.method !== method) continue
-    const match = rule.exact ? path === rule.path : path === rule.path || path.startsWith(rule.path + "/")
-    if (match) return rule.action === "local"
-  }
-  return false
-}
-
-function getSessionID(url: URL) {
-  if (url.pathname === "/session/status") return null
-
-  const id = url.pathname.match(/^\/session\/([^/]+)(?:\/|$)/)?.[1]
-  if (!id) return null
-
-  return SessionID.make(id)
-}
-
-async function getSessionWorkspace(url: URL) {
-  const id = getSessionID(url)
-  if (!id) return null
-
-  const session = await AppRuntime.runPromise(
-    Session.Service.use((svc) => svc.get(id)).pipe(Effect.withSpan("WorkspaceRouter.lookup")),
-  ).catch(() => undefined)
-  return session?.workspaceID
-}
-
-export function WorkspaceRouterMiddleware(upgrade: UpgradeWebSocket): MiddlewareHandler {
-  const log = Log.create({ service: "workspace-router" })
-
-  return async (c, next) => {
-    const url = new URL(c.req.url)
-
-    const sessionWorkspaceID = await getSessionWorkspace(url)
-    const workspaceID = sessionWorkspaceID || url.searchParams.get("workspace")
-
-    if (!workspaceID || url.pathname.startsWith("/console") || Flag.SLEEPYCODE_WORKSPACE_ID) {
-      return next()
-    }
-
-    const workspace = await Workspace.get(WorkspaceID.make(workspaceID))
-
-    if (!workspace) {
-      return new Response(`Workspace not found: ${workspaceID}`, {
-        status: 500,
-        headers: {
-          "content-type": "text/plain; charset=utf-8",
-        },
-      })
-    }
-
-    if (local(c.req.method, url.pathname)) {
-      // No instance provided because we are serving cached data; there
-      // is no instance to work with
-      return next()
-    }
-
-    const adaptor = await getAdaptor(workspace.projectID, workspace.type)
-    const target = await adaptor.target(workspace)
-
-    if (target.type === "local") {
-      return WorkspaceContext.provide({
-        workspaceID: WorkspaceID.make(workspaceID),
-        fn: () =>
-          Instance.provide({
-            directory: target.directory,
-            init: () => AppRuntime.runPromise(InstanceBootstrap),
-            async fn() {
-              return next()
-            },
-          }),
-      })
-    }
-
-    const proxyURL = new URL(target.url)
-    proxyURL.pathname = `${proxyURL.pathname.replace(/\/$/, "")}${url.pathname}`
-    proxyURL.search = url.search
-    proxyURL.hash = url.hash
-    proxyURL.searchParams.delete("workspace")
-
-    log.info("workspace proxy forwarding", {
-      workspaceID,
-      request: url.toString(),
-      target: String(target.url),
-      proxy: proxyURL.toString(),
-    })
-
-    if (c.req.header("upgrade")?.toLowerCase() === "websocket") {
-      return ServerProxy.websocket(upgrade, proxyURL, target.headers, c.req.raw, c.env)
-    }
-
-    const headers = new Headers(c.req.raw.headers)
-    headers.delete("x-sleepycode-workspace")
-
-    const req = new Request(c.req.raw, { headers })
-    return ServerProxy.http(proxyURL, target.headers, req, workspace.id)
-  }
-}

package/src/session/auto-dream.ts

@@ -1,123 +0,0 @@
-import { Effect } from "effect"
-import { Database, eq, desc, asc, isNull } from "@/storage"
-import { SessionTable } from "./session.sql"
-import { Log } from "@/util"
-import type { Config } from "@/config"
-
-const log = Log.create({ service: "auto-dream" })
-
-const DAY_MS = 24 * 60 * 60 * 1000
-const DEFAULT_DREAM_INTERVAL_DAYS = 7
-const DEFAULT_DISTILL_INTERVAL_DAYS = 30
-const MIN_SPAWN_GAP_MS = 10_000
-
-export const AUTO_DREAM_TITLE = "Auto Dream"
-export const AUTO_DISTILL_TITLE = "Auto Distill"
-
-let lastDreamSpawnTime = 0
-let lastDistillSpawnTime = 0
-
-export const DREAM_TASK = [
-  "Run one automatic dream memory consolidation pass for the current project.",
-  "",
-  "Use the memory files as the working index and the raw sleepycode trajectory database as the source of truth.",
-  "Use bash for read-only SQLite and filesystem inspection. Do not modify the database.",
-  "Consolidate only durable, verified information into project memory.",
-].join("\n")
-
-export const DISTILL_TASK = [
-  "Run one automatic distill pass for the current project.",
-  "",
-  "Review the past month of sessions and identify repeated manual workflows worth packaging.",
-  "Use the raw sleepycode trajectory database as the source of truth and memory files to spot cross-session patterns.",
-  "Inventory existing skills, agents, and commands first so you reuse or extend instead of duplicating.",
-  "Use bash for read-only SQLite and filesystem inspection. Do not modify the database.",
-  "Produce a compact shortlist, then create only the high-confidence missing assets.",
-].join("\n")
-
-function shouldAutoRun(input: {
-  enabled: boolean
-  intervalDays: number
-  title: string
-  label: string
-}) {
-  return Effect.gen(function* () {
-    if (!input.enabled) return false
-
-    const intervalMs = input.intervalDays * DAY_MS
-
-    const lastRun = yield* Effect.sync(() =>
-      Database.use((db) =>
-        db
-          .select({ time_created: SessionTable.time_created })
-          .from(SessionTable)
-          .where(eq(SessionTable.title, input.title))
-          .orderBy(desc(SessionTable.time_created))
-          .limit(1)
-          .get(),
-      ),
-    )
-
-    const now = Date.now()
-    const elapsed = lastRun ? now - lastRun.time_created : Infinity
-
-    // First time ever: check if the project is old enough to have anything worth consolidating.
-    // Look at the earliest top-level session (no parent) as the project start time.
-    if (!lastRun) {
-      const earliest = yield* Effect.sync(() =>
-        Database.use((db) =>
-          db
-            .select({ time_created: SessionTable.time_created })
-            .from(SessionTable)
-            .where(isNull(SessionTable.parent_id))
-            .orderBy(asc(SessionTable.time_created))
-            .limit(1)
-            .get(),
-        ),
-      )
-      if (!earliest || now - earliest.time_created < intervalMs) {
-        log.info(`auto-${input.label} skipped — project too young`, {
-          projectAge: earliest ? Math.round((now - earliest.time_created) / DAY_MS) + "d" : "empty",
-          interval: input.intervalDays + "d",
-        })
-        return false
-      }
-    }
-
-    if (elapsed < intervalMs) {
-      log.info(`auto-${input.label} skipped — last run too recent`, {
-        lastRunAgo: Math.round(elapsed / DAY_MS) + "d",
-        interval: input.intervalDays + "d",
-      })
-      return false
-    }
-
-    log.info(`auto-${input.label} triggering`, {
-      lastRun: lastRun ? new Date(lastRun.time_created).toISOString() : "never",
-      interval: input.intervalDays + "d",
-    })
-    return true
-  })
-}
-
-export function shouldAutoDream(cfg: Config.Info) {
-  const enabled = cfg.dream?.auto !== false
-  if (!enabled) return Effect.succeed(false)
-  const now = Date.now()
-  if (now - lastDreamSpawnTime < MIN_SPAWN_GAP_MS) return Effect.succeed(false)
-  lastDreamSpawnTime = now
-  const intervalDays = cfg.dream?.interval_days ?? DEFAULT_DREAM_INTERVAL_DAYS
-  return shouldAutoRun({ enabled, intervalDays, title: AUTO_DREAM_TITLE, label: "dream" })
-}
-
-export function shouldAutoDistill(cfg: Config.Info) {
-  const enabled = cfg.distill?.auto !== false
-  if (!enabled) return Effect.succeed(false)
-  const now = Date.now()
-  if (now - lastDistillSpawnTime < MIN_SPAWN_GAP_MS) return Effect.succeed(false)
-  lastDistillSpawnTime = now
-  const intervalDays = cfg.distill?.interval_days ?? DEFAULT_DISTILL_INTERVAL_DAYS
-  return shouldAutoRun({ enabled, intervalDays, title: AUTO_DISTILL_TITLE, label: "distill" })
-}
-
-export * as AutoDream from "./auto-dream"

package/src/session/boundary.ts

@@ -1,77 +0,0 @@
-type AnyMessage = {
-  role: string
-  content?: unknown[]
-  id?: string
-}
-
-function getToolResultIds(msg: AnyMessage): string[] {
-  if (!Array.isArray(msg.content)) return []
-  const ids: string[] = []
-  for (const block of msg.content as Array<Record<string, unknown>>) {
-    if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
-      ids.push(block.tool_use_id)
-    }
-  }
-  return ids
-}
-
-function getToolUseIds(msg: AnyMessage): string[] {
-  if (!Array.isArray(msg.content)) return []
-  const ids: string[] = []
-  for (const block of msg.content as Array<Record<string, unknown>>) {
-    if (block.type === "tool_use" && typeof block.id === "string") {
-      ids.push(block.id)
-    }
-  }
-  return ids
-}
-
-/**
- * Walk the boundary backward to ensure tool_use/tool_result pairs are not
- * split across the summary/tail divide, and that thinking blocks sharing
- * a message.id with kept assistants are included.
- */
-export function adjustBoundaryForApiInvariants(
-  messages: AnyMessage[],
-  candidateBoundary: number,
-): number {
-  if (candidateBoundary <= 0 || candidateBoundary >= messages.length) {
-    return candidateBoundary
-  }
-
-  let idx = candidateBoundary
-
-  // Step 1: tool_use/tool_result pairing.
-  const tailToolResults: string[] = []
-  const tailToolUses = new Set<string>()
-  for (let i = idx; i < messages.length; i++) {
-    tailToolResults.push(...getToolResultIds(messages[i]))
-    for (const useId of getToolUseIds(messages[i])) tailToolUses.add(useId)
-  }
-  let orphans = tailToolResults.filter((id) => !tailToolUses.has(id))
-
-  for (let i = idx - 1; i >= 0 && orphans.length > 0; i--) {
-    const m = messages[i]
-    if (m.role !== "assistant") continue
-    const useIds = getToolUseIds(m)
-    const matched = useIds.filter((id) => orphans.includes(id))
-    if (matched.length > 0) {
-      idx = i
-      orphans = orphans.filter((id) => !matched.includes(id))
-    }
-  }
-
-  // Step 2: same message.id walk-back (thinking blocks share id with sibling).
-  const boundaryMsgId = messages[idx]?.id
-  if (boundaryMsgId) {
-    for (let i = idx - 1; i >= 0; i--) {
-      if (messages[i].id === boundaryMsgId) {
-        idx = i
-      } else {
-        break
-      }
-    }
-  }
-
-  return idx
-}