@sleepy-ai/cli 0.0.0-main-202607032053 → 0.1.4

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

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

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

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

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

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

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