@sleepy-ai/cli 0.1.16 → 0.1.17

package/src/acp/session.ts

@@ -1,116 +0,0 @@
-import { RequestError, type McpServer } from "@agentclientprotocol/sdk"
-import type { ACPSessionState } from "./types"
-import { Log } from "@/util"
-import type { OpencodeClient } from "@sleepy-ai/sdk/v2"
-
-const log = Log.create({ service: "acp-session-manager" })
-
-export class ACPSessionManager {
-  private sessions = new Map<string, ACPSessionState>()
-  private sdk: OpencodeClient
-
-  constructor(sdk: OpencodeClient) {
-    this.sdk = sdk
-  }
-
-  tryGet(sessionId: string): ACPSessionState | undefined {
-    return this.sessions.get(sessionId)
-  }
-
-  async create(cwd: string, mcpServers: McpServer[], model?: ACPSessionState["model"]): Promise<ACPSessionState> {
-    const session = await this.sdk.session
-      .create(
-        {
-          directory: cwd,
-        },
-        { throwOnError: true },
-      )
-      .then((x) => x.data!)
-
-    const sessionId = session.id
-    const resolvedModel = model
-
-    const state: ACPSessionState = {
-      id: sessionId,
-      cwd,
-      mcpServers,
-      createdAt: new Date(),
-      model: resolvedModel,
-    }
-    log.info("creating_session", { state })
-
-    this.sessions.set(sessionId, state)
-    return state
-  }
-
-  async load(
-    sessionId: string,
-    cwd: string,
-    mcpServers: McpServer[],
-    model?: ACPSessionState["model"],
-  ): Promise<ACPSessionState> {
-    const session = await this.sdk.session
-      .get(
-        {
-          sessionID: sessionId,
-          directory: cwd,
-        },
-        { throwOnError: true },
-      )
-      .then((x) => x.data!)
-
-    const resolvedModel = model
-
-    const state: ACPSessionState = {
-      id: sessionId,
-      cwd,
-      mcpServers,
-      createdAt: new Date(session.time.created),
-      model: resolvedModel,
-    }
-    log.info("loading_session", { state })
-
-    this.sessions.set(sessionId, state)
-    return state
-  }
-
-  get(sessionId: string): ACPSessionState {
-    const session = this.sessions.get(sessionId)
-    if (!session) {
-      log.error("session not found", { sessionId })
-      throw RequestError.invalidParams(JSON.stringify({ error: `Session not found: ${sessionId}` }))
-    }
-    return session
-  }
-
-  getModel(sessionId: string) {
-    const session = this.get(sessionId)
-    return session.model
-  }
-
-  setModel(sessionId: string, model: ACPSessionState["model"]) {
-    const session = this.get(sessionId)
-    session.model = model
-    this.sessions.set(sessionId, session)
-    return session
-  }
-
-  getVariant(sessionId: string) {
-    const session = this.get(sessionId)
-    return session.variant
-  }
-
-  setVariant(sessionId: string, variant?: string) {
-    const session = this.get(sessionId)
-    session.variant = variant
-    this.sessions.set(sessionId, session)
-    return session
-  }
-
-  setMode(sessionId: string, modeId: string) {
-    const session = this.get(sessionId)
-    session.modeId = modeId
-    this.sessions.set(sessionId, session)
-    return session
-  }
-}

package/src/acp/types.ts

@@ -1,24 +0,0 @@
-import type { McpServer } from "@agentclientprotocol/sdk"
-import type { OpencodeClient } from "@sleepy-ai/sdk/v2"
-import type { ProviderID, ModelID } from "../provider/schema"
-
-export interface ACPSessionState {
-  id: string
-  cwd: string
-  mcpServers: McpServer[]
-  createdAt: Date
-  model?: {
-    providerID: ProviderID
-    modelID: ModelID
-  }
-  variant?: string
-  modeId?: string
-}
-
-export interface ACPConfig {
-  sdk: OpencodeClient
-  defaultModel?: {
-    providerID: ProviderID
-    modelID: ModelID
-  }
-}

package/src/actor/actor.sql.ts

@@ -1,38 +0,0 @@
-import { sqliteTable, text, integer, index, primaryKey } from "drizzle-orm/sqlite-core"
-import { SessionTable } from "../session/session.sql"
-import type { SessionID, MessageID } from "../session/schema"
-import { Timestamps } from "../storage/schema.sql"
-
-export const ActorRegistryTable = sqliteTable(
-  "actor_registry",
-  {
-    session_id: text()
-      .$type<SessionID>()
-      .notNull()
-      .references(() => SessionTable.id, { onDelete: "cascade" }),
-    actor_id: text().notNull(),
-    mode: text().$type<"peer" | "subagent" | "main">().notNull(),
-    parent_actor_id: text(),
-    status: text().$type<"pending" | "running" | "idle">().notNull(),
-    last_outcome: text().$type<"success" | "failure" | "cancelled">(),
-    lifecycle: text().$type<"ephemeral" | "persistent">().notNull(),
-    agent: text().notNull(),
-    description: text().notNull(),
-    context_mode: text().$type<"none" | "state" | "full">().notNull(),
-    context_watermark: text().$type<MessageID>(),
-    background: integer({ mode: "boolean" }).notNull(),
-    tools: text({ mode: "json" }).$type<readonly string[] | "INHERIT">(),
-    last_turn_time: integer().notNull(),
-    turn_count: integer().notNull().default(0),
-    last_error: text(),
-    time_completed: integer(),
-    ...Timestamps,
-  },
-  (table) => [
-    primaryKey({ columns: [table.session_id, table.actor_id] }),
-    index("actor_registry_session_agent_idx").on(table.session_id, table.agent),
-    index("actor_registry_session_parent_idx").on(table.session_id, table.parent_actor_id),
-    index("actor_registry_status_idx").on(table.status),
-    index("actor_registry_status_last_turn_idx").on(table.status, table.last_turn_time),
-  ],
-)

package/src/actor/events.ts

@@ -1,67 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import { SessionID } from "@/session/schema"
-import { ActorStatus, ActorOutcome, SpawnMode } from "./schema"
-import z from "zod"
-
-export const ActorRegistered = BusEvent.define(
-  "actor.registered",
-  z.object({
-    sessionID: SessionID.zod,
-    actorID: z.string(),
-    mode: SpawnMode,
-    parentActorID: z.string().optional(),
-    description: z.string(),
-    agent: z.string(),
-    background: z.boolean(),
-  }),
-)
-
-export const ActorStatusChanged = BusEvent.define(
-  "actor.status",
-  z.object({
-    sessionID: SessionID.zod,
-    actorID: z.string(),
-    status: ActorStatus,
-    lastOutcome: ActorOutcome.optional(),
-    turnCount: z.number(),
-    lastTurnTime: z.number(),
-    error: z.string().optional(),
-  }),
-)
-
-export const ActorStuck = BusEvent.define(
-  "actor.stuck",
-  z.object({
-    sessionID: SessionID.zod,
-    actorID: z.string(),
-    description: z.string(),
-    lastTurnTime: z.number(),
-    stuckDuration: z.number(),
-  }),
-)
-
-export const WriterCachePerf = BusEvent.define(
-  "writer.cache_perf",
-  z.object({
-    sessionID: SessionID.zod,
-    writerActorID: z.string(),
-    status: z.enum(["completed", "failed"]),
-    total_input_tokens: z.number(),
-    cache_read_tokens: z.number(),
-    cache_write_tokens: z.number(),
-    cache_hit_rate: z.number(),
-    num_llm_calls: z.number(),
-  }),
-)
-
-export const InboxArrived = BusEvent.define(
-  "inbox.arrived",
-  z.object({
-    receiverSessionID: SessionID.zod,
-    receiverActorID: z.string(),
-    senderSessionID: SessionID.zod.optional(),
-    senderActorID: z.string().optional(),
-    inboxID: z.string(),
-    type: z.string(),
-  }),
-)

package/src/actor/index.ts

@@ -1,2 +0,0 @@
-export * as ActorRegistry from "./registry"
-export * as ActorWaiter from "./waiter"

package/src/actor/registry.ts

@@ -1,412 +0,0 @@
-import { Effect, Layer, Context, Schedule } from "effect"
-import { Database, inArray, eq, and, lte, sql } from "@/storage"
-import { Bus } from "@/bus"
-import type { SessionID, MessageID } from "@/session/schema"
-import { ActorRegistryTable } from "./actor.sql"
-import type { Actor, ActorStatus, ActorOutcome, ContextMode, Lifecycle, SpawnMode, ToolWhitelist } from "./schema"
-import * as Events from "./events"
-import { Log } from "@/util"
-import { SYSTEM_SPAWNED_AGENT_TYPES } from "@/agent/config"
-
-const log = Log.create({ service: "actor.registry" })
-
-const STUCK_THRESHOLD_MS = 5 * 60 * 1000 // 5 minutes
-const SCAN_INTERVAL_MS = 60 * 1000 // every 60s
-
-type ActorRow = typeof ActorRegistryTable.$inferSelect
-
-function fromRow(row: ActorRow): Actor {
-  return {
-    sessionID: row.session_id,
-    actorID: row.actor_id,
-    mode: row.mode,
-    parentActorID: row.parent_actor_id ?? undefined,
-    status: row.status,
-    lastOutcome: row.last_outcome ?? undefined,
-    lifecycle: row.lifecycle,
-    agent: row.agent,
-    description: row.description,
-    contextMode: row.context_mode,
-    contextWatermark: row.context_watermark ?? undefined,
-    background: Boolean(row.background),
-    tools: row.tools ?? undefined,
-    lastTurnTime: row.last_turn_time,
-    turnCount: row.turn_count,
-    lastError: row.last_error ?? undefined,
-    time: {
-      created: row.time_created,
-      updated: row.time_updated,
-      completed: row.time_completed ?? undefined,
-    },
-  }
-}
-
-export interface Interface {
-  readonly register: (input: {
-    sessionID: SessionID
-    actorID: string
-    mode: SpawnMode
-    parentActorID?: string
-    agent: string
-    description: string
-    contextMode: ContextMode
-    contextWatermark?: MessageID
-    background: boolean
-    lifecycle: Lifecycle
-    tools?: ToolWhitelist
-  }) => Effect.Effect<Actor>
-
-  readonly updateStatus: (
-    sessionID: SessionID,
-    actorID: string,
-    patch: {
-      status: ActorStatus
-      lastOutcome?: ActorOutcome | undefined
-      lastError?: string | undefined
-    },
-  ) => Effect.Effect<void>
-  readonly updateTurn: (sessionID: SessionID, actorID: string) => Effect.Effect<void>
-  readonly get: (sessionID: SessionID, actorID: string) => Effect.Effect<Actor | undefined>
-  readonly listBySession: (sessionID: SessionID) => Effect.Effect<Actor[]>
-  readonly listActive: () => Effect.Effect<Actor[]>
-  readonly listByParent: (sessionID: SessionID, parentActorID: string) => Effect.Effect<Actor[]>
-  readonly renderForAgent: (sessionID: SessionID) => Effect.Effect<string>
-  readonly agentTypeFor: (sessionID: SessionID, actorID: string) => Effect.Effect<string>
-  readonly isSystemSpawned: (sessionID: SessionID, actorID: string) => Effect.Effect<boolean>
-  readonly allocateActorID: (sessionID: SessionID, agentType: string) => Effect.Effect<string>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/ActorRegistry") {}
-
-export const layer: Layer.Layer<Service, never, Bus.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const bus = yield* Bus.Service
-
-    // --- CRUD methods ---
-
-    const register = Effect.fn("ActorRegistry.register")(function* (input: {
-      sessionID: SessionID
-      actorID: string
-      mode: SpawnMode
-      parentActorID?: string
-      agent: string
-      description: string
-      contextMode: ContextMode
-      contextWatermark?: MessageID
-      background: boolean
-      lifecycle: Lifecycle
-      tools?: ToolWhitelist
-    }) {
-      const now = Date.now()
-      const row = {
-        session_id: input.sessionID,
-        actor_id: input.actorID,
-        mode: input.mode,
-        parent_actor_id: input.parentActorID ?? null,
-        status: "pending" as const,
-        last_outcome: null,
-        lifecycle: input.lifecycle,
-        agent: input.agent,
-        description: input.description,
-        context_mode: input.contextMode,
-        context_watermark: input.contextWatermark ?? null,
-        background: input.background,
-        tools: input.tools ?? null,
-        last_turn_time: now,
-        turn_count: 0,
-        last_error: null,
-        time_completed: null,
-        time_created: now,
-        time_updated: now,
-      }
-      yield* Effect.sync(() => Database.use((db) => db.insert(ActorRegistryTable).values(row).run()))
-      yield* bus.publish(Events.ActorRegistered, {
-        sessionID: input.sessionID,
-        actorID: input.actorID,
-        mode: input.mode,
-        parentActorID: input.parentActorID,
-        description: input.description,
-        agent: input.agent,
-        background: input.background,
-      })
-      return fromRow(row)
-    })
-
-    const updateStatus = Effect.fn("ActorRegistry.updateStatus")(function* (
-      sessionID: SessionID,
-      actorID: string,
-      patch: {
-        status: ActorStatus
-        lastOutcome?: ActorOutcome | undefined
-        lastError?: string | undefined
-      },
-    ) {
-      const now = Date.now()
-      const isTerminal = patch.status === "idle" && patch.lastOutcome !== undefined
-      const set: Record<string, unknown> = {
-        status: patch.status,
-        time_updated: now,
-        ...(isTerminal ? { time_completed: now } : {}),
-      }
-      if (patch.lastOutcome !== undefined) set.last_outcome = patch.lastOutcome
-      if (patch.lastError !== undefined) set.last_error = patch.lastError
-      else if (patch.lastOutcome !== undefined && patch.lastOutcome !== "failure") set.last_error = null
-      yield* Effect.sync(() =>
-        Database.use((db) =>
-          db
-            .update(ActorRegistryTable)
-            .set(set)
-            .where(
-              and(eq(ActorRegistryTable.session_id, sessionID), eq(ActorRegistryTable.actor_id, actorID)),
-            )
-            .run(),
-        ),
-      )
-      // Re-read so the event payload reflects committed row values (not the
-      // sparse patch). Skip publish if the row vanished between UPDATE and
-      // SELECT — a dropped event beats a misleading one.
-      const row = yield* Effect.sync(() =>
-        Database.use((db) =>
-          db
-            .select()
-            .from(ActorRegistryTable)
-            .where(
-              and(eq(ActorRegistryTable.session_id, sessionID), eq(ActorRegistryTable.actor_id, actorID)),
-            )
-            .get(),
-        ),
-      )
-      if (!row) return
-      yield* bus.publish(Events.ActorStatusChanged, {
-        sessionID,
-        actorID,
-        status: row.status,
-        ...(row.last_outcome ? { lastOutcome: row.last_outcome } : {}),
-        turnCount: row.turn_count,
-        lastTurnTime: row.last_turn_time,
-        ...(row.last_error ? { error: row.last_error } : {}),
-      })
-    })
-
-    const updateTurn = Effect.fn("ActorRegistry.updateTurn")(function* (sessionID: SessionID, actorID: string) {
-      const now = Date.now()
-      yield* Effect.sync(() =>
-        Database.use((db) =>
-          db
-            .update(ActorRegistryTable)
-            .set({
-              last_turn_time: now,
-              turn_count: sql`${ActorRegistryTable.turn_count} + 1`,
-              time_updated: now,
-            })
-            .where(
-              and(eq(ActorRegistryTable.session_id, sessionID), eq(ActorRegistryTable.actor_id, actorID)),
-            )
-            .run(),
-        ),
-      )
-    })
-
-    const get = Effect.fn("ActorRegistry.get")(function* (sessionID: SessionID, actorID: string) {
-      const row = yield* Effect.sync(() =>
-        Database.use((db) =>
-          db
-            .select()
-            .from(ActorRegistryTable)
-            .where(
-              and(eq(ActorRegistryTable.session_id, sessionID), eq(ActorRegistryTable.actor_id, actorID)),
-            )
-            .get(),
-        ),
-      )
-      return row ? fromRow(row) : undefined
-    })
-
-    const listBySession = Effect.fn("ActorRegistry.listBySession")(function* (sessionID: SessionID) {
-      const rows = yield* Effect.sync(() =>
-        Database.use((db) =>
-          db.select().from(ActorRegistryTable).where(eq(ActorRegistryTable.session_id, sessionID)).all(),
-        ),
-      )
-      return rows.map(fromRow)
-    })
-
-    const listActive = Effect.fn("ActorRegistry.listActive")(function* () {
-      const rows = yield* Effect.sync(() =>
-        Database.use((db) =>
-          db
-            .select()
-            .from(ActorRegistryTable)
-            .where(
-              and(
-                inArray(ActorRegistryTable.status, ["pending", "running"]),
-                eq(ActorRegistryTable.background, true),
-              ),
-            )
-            .all(),
-        ),
-      )
-      return rows.map(fromRow)
-    })
-
-    const listByParent = Effect.fn("ActorRegistry.listByParent")(function* (
-      sessionID: SessionID,
-      parentActorID: string,
-    ) {
-      const rows = yield* Effect.sync(() =>
-        Database.use((db) =>
-          db
-            .select()
-            .from(ActorRegistryTable)
-            .where(
-              and(
-                eq(ActorRegistryTable.session_id, sessionID),
-                eq(ActorRegistryTable.parent_actor_id, parentActorID),
-              ),
-            )
-            .all(),
-        ),
-      )
-      return rows.map(fromRow)
-    })
-
-    const renderForAgent = Effect.fn("ActorRegistry.renderForAgent")(function* (sessionID: SessionID) {
-      const actors = yield* listBySession(sessionID)
-      const active = actors.filter((actor) => actor.background && (actor.status === "pending" || actor.status === "running"))
-      if (active.length === 0) return ""
-
-      const lines: string[] = []
-      lines.push("## Active Actors")
-      lines.push("")
-      lines.push(`You have ${active.length} background actor(s) registered. Interact via the \`actor\` tool.`)
-      lines.push("")
-      const now = Date.now()
-      for (const actor of active) {
-        const idleMs = now - actor.lastTurnTime
-        const idle = idleMs < 60_000 ? `${Math.floor(idleMs / 1000)}s` : `${Math.floor(idleMs / 60_000)}m`
-        lines.push(`- actor_id: ${actor.actorID} (${actor.status}, last activity ${idle} ago)`)
-        lines.push(`  description: ${actor.description}`)
-        lines.push(`  agent: ${actor.agent}`)
-      }
-      return lines.join("\n")
-    })
-
-    const agentTypeFor = Effect.fn("ActorRegistry.agentTypeFor")(function* (
-      sessionID: SessionID,
-      actorID: string,
-    ) {
-      if (actorID === "main") return "main"
-      const actor = yield* get(sessionID, actorID)
-      return actor?.agent ?? "main"
-    })
-
-    const isSystemSpawned = Effect.fn("ActorRegistry.isSystemSpawned")(function* (
-      sessionID: SessionID,
-      actorID: string,
-    ) {
-      if (actorID === "main") return false
-      const actor = yield* get(sessionID, actorID)
-      if (!actor) return false
-      return SYSTEM_SPAWNED_AGENT_TYPES.has(actor.agent)
-    })
-
-    const allocateActorID = Effect.fn("ActorRegistry.allocateActorID")(function* (
-      sessionID: SessionID,
-      agentType: string,
-    ) {
-      const existing = yield* Effect.sync(() =>
-        Database.use((db) =>
-          db
-            .select({ actor_id: ActorRegistryTable.actor_id })
-            .from(ActorRegistryTable)
-            .where(and(eq(ActorRegistryTable.session_id, sessionID), eq(ActorRegistryTable.agent, agentType)))
-            .all(),
-        ),
-      )
-      const prefix = `${agentType}-`
-      let max = 0
-      for (const row of existing) {
-        if (row.actor_id.startsWith(prefix)) {
-          const n = parseInt(row.actor_id.slice(prefix.length), 10)
-          if (Number.isFinite(n) && n > max) max = n
-        }
-      }
-      return `${agentType}-${max + 1}`
-    })
-
-    // --- Orphan Recovery ---
-    // On init, mark all pending/running actors as idle with failure outcome.
-    // Per spec B6: don't auto-revive — they wake on next sender's send.
-    yield* Effect.sync(() =>
-      Database.use((db) => {
-        const now = Date.now()
-        db.update(ActorRegistryTable)
-          .set({
-            status: "idle",
-            last_outcome: "failure",
-            last_error: "orphaned: process restarted",
-            time_updated: now,
-            time_completed: now,
-          })
-          .where(inArray(ActorRegistryTable.status, ["pending", "running"]))
-          .run()
-      }),
-    )
-    log.info("orphan recovery complete")
-
-    // --- Stuck Detection ---
-    const scanStuck = Effect.gen(function* () {
-      const cutoff = Date.now() - STUCK_THRESHOLD_MS
-      const stuck = yield* Effect.sync(() =>
-        Database.use((db) =>
-          db
-            .select()
-            .from(ActorRegistryTable)
-            .where(
-              and(
-                eq(ActorRegistryTable.status, "running"),
-                lte(ActorRegistryTable.last_turn_time, cutoff),
-              ),
-            )
-            .all(),
-        ),
-      )
-      for (const row of stuck) {
-        const entry = fromRow(row)
-        yield* bus.publish(Events.ActorStuck, {
-          sessionID: entry.sessionID,
-          actorID: entry.actorID,
-          description: entry.description,
-          lastTurnTime: entry.lastTurnTime,
-          stuckDuration: Date.now() - entry.lastTurnTime,
-        })
-      }
-    })
-
-    // Fork stuck detection fiber in the layer scope
-    yield* scanStuck.pipe(
-      Effect.repeat(Schedule.fixed(SCAN_INTERVAL_MS)),
-      Effect.ignore,
-      Effect.forkScoped,
-    )
-
-    return Service.of({
-      register,
-      updateStatus,
-      updateTurn,
-      get,
-      listBySession,
-      listActive,
-      listByParent,
-      renderForAgent,
-      agentTypeFor,
-      isSystemSpawned,
-      allocateActorID,
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
-
-export * as ActorRegistry from "./registry"

package/src/actor/return-header.ts

@@ -1,24 +0,0 @@
-export const RETURN_STATUSES = ["success", "partial", "failed", "blocked"] as const
-export type ReturnStatus = (typeof RETURN_STATUSES)[number]
-
-export interface ParsedReturnHeader {
-  status?: ReturnStatus
-  summary?: string
-}
-
-const STATUS_RE = /^\s*\*\*Status\*\*:\s*(success|partial|failed|blocked)\b/im
-const SUMMARY_RE = /\*\*Summary\*\*:\s*(.+)$/im
-
-// Parse the **Status**/**Summary** header a subagent is asked to emit
-// (see RETURN_FORMAT_INSTRUCTION in spawn.ts). Missing/malformed → {}.
-export function parseReturnHeader(finalText: string | undefined): ParsedReturnHeader {
-  if (!finalText) return {}
-  const status = finalText.match(STATUS_RE)?.[1]?.toLowerCase() as ReturnStatus | undefined
-  const summary = finalText.match(SUMMARY_RE)?.[1]?.trim()
-  return {
-    ...(status ? { status } : {}),
-    ...(summary ? { summary } : {}),
-  }
-}
-
-export * as ReturnHeader from "./return-header"