@epoch-ai/cli 2.2.4 → 2.2.5

package/src/config/validator.ts

@@ -1,52 +0,0 @@
-import { Log } from "../util/log"
-import { Effect } from "effect"
-import type { Config } from "./config"
-
-const log = Log.create({ service: "engine-validator" })
-
-export namespace EngineConfigValidator {
-  export const validate = Effect.fn("EngineConfigValidator.validate")(function* (config: Config.Info) {
-    const mainProvider = config.provider?.["local-main"]
-    const sideProvider = config.provider?.["local-side"]
-
-    if (!mainProvider || !sideProvider) {
-      log.debug("Dual-model orchestration providers not fully configured. Skipping validation.")
-      return
-    }
-
-    log.info("Validating local engine configurations for dual-model setup...")
-
-    const checkEngine = (name: string, url?: string) =>
-      Effect.promise(async () => {
-        if (!url) return
-        try {
-          const res = await fetch(`${url}/models`)
-          if (!res.ok) {
-            log.warn(`Engine ${name} at ${url} returned status ${res.status}.`)
-          } else {
-            const kvCache = res.headers.get("x-kv-cache-dtype")
-            if (kvCache && kvCache !== "fp8") {
-              log.warn(`Engine ${name} is not using fp8 KV cache. VRAM exhaustion risk!`)
-            }
-
-            const maxLen = res.headers.get("x-max-model-len")
-            if (maxLen && parseInt(maxLen, 10) > 32768) {
-              log.warn(`Engine ${name} context limit exceeds 32k. Infinite loop risk!`)
-            }
-          }
-        } catch (e) {
-          log.warn(
-            `Failed to connect to engine ${name} at ${url}. Ensure it is running with --kv-cache-dtype fp8 and --max-model-len 32768.`,
-          )
-        }
-      })
-
-    yield* Effect.all(
-      [
-        checkEngine("local-main", mainProvider.options?.baseURL),
-        checkEngine("local-side", sideProvider.options?.baseURL),
-      ],
-      { concurrency: 2 },
-    )
-  })
-}

package/src/control-plane/adaptors/index.ts

@@ -1,20 +0,0 @@
-import { lazy } from "@/util/lazy"
-import type { Adaptor } from "../types"
-
-const ADAPTORS: Record<string, () => Promise<Adaptor>> = {
-  worktree: lazy(async () => (await import("./worktree")).WorktreeAdaptor),
-}
-
-export function getAdaptor(type: string): Promise<Adaptor> {
-  return ADAPTORS[type]()
-}
-
-export function installAdaptor(type: string, adaptor: Adaptor) {
-  // This is experimental: mostly used for testing right now, but we
-  // will likely allow this in the future. Need to figure out the
-  // TypeScript story
-
-  // @ts-expect-error we force the builtin types right now, but we
-  // will implement a way to extend the types for custom adaptors
-  ADAPTORS[type] = () => adaptor
-}

package/src/control-plane/adaptors/worktree.ts

@@ -1,42 +0,0 @@
-import z from "zod"
-import { Worktree } from "@/worktree"
-import { type Adaptor, WorkspaceInfo } from "../types"
-
-const Config = WorkspaceInfo.extend({
-  name: WorkspaceInfo.shape.name.unwrap(),
-  branch: WorkspaceInfo.shape.branch.unwrap(),
-  directory: WorkspaceInfo.shape.directory.unwrap(),
-})
-
-type Config = z.infer<typeof Config>
-
-export const WorktreeAdaptor: Adaptor = {
-  async configure(info) {
-    const worktree = await Worktree.makeWorktreeInfo(info.name ?? undefined)
-    return {
-      ...info,
-      name: worktree.name,
-      branch: worktree.branch,
-      directory: worktree.directory,
-    }
-  },
-  async create(info) {
-    const config = Config.parse(info)
-    await Worktree.createFromInfo({
-      name: config.name,
-      directory: config.directory,
-      branch: config.branch,
-    })
-  },
-  async remove(info) {
-    const config = Config.parse(info)
-    await Worktree.remove({ directory: config.directory })
-  },
-  target(info) {
-    const config = Config.parse(info)
-    return {
-      type: "local",
-      directory: config.directory,
-    }
-  },
-}

package/src/control-plane/schema.ts

@@ -1,17 +0,0 @@
-import { Schema } from "effect"
-import z from "zod"
-
-import { withStatics } from "@/util/schema"
-import { Identifier } from "@/id/id"
-
-const workspaceIdSchema = Schema.String.pipe(Schema.brand("WorkspaceID"))
-
-export type WorkspaceID = typeof workspaceIdSchema.Type
-
-export const WorkspaceID = workspaceIdSchema.pipe(
-  withStatics((schema: typeof workspaceIdSchema) => ({
-    make: (id: string) => schema.makeUnsafe(id),
-    ascending: (id?: string) => schema.makeUnsafe(Identifier.ascending("workspace", id)),
-    zod: Identifier.schema("workspace").pipe(z.custom<WorkspaceID>()),
-  })),
-)

package/src/control-plane/sse.ts

@@ -1,66 +0,0 @@
-export async function parseSSE(
-  body: ReadableStream<Uint8Array>,
-  signal: AbortSignal,
-  onEvent: (event: unknown) => void,
-) {
-  const reader = body.getReader()
-  const decoder = new TextDecoder()
-  let buf = ""
-  let last = ""
-  let retry = 1000
-
-  const abort = () => {
-    void reader.cancel().catch(() => undefined)
-  }
-
-  signal.addEventListener("abort", abort)
-
-  try {
-    while (!signal.aborted) {
-      const chunk = await reader.read().catch(() => ({ done: true, value: undefined as Uint8Array | undefined }))
-      if (chunk.done) break
-
-      buf += decoder.decode(chunk.value, { stream: true })
-      buf = buf.replace(/\r\n/g, "\n").replace(/\r/g, "\n")
-
-      const chunks = buf.split("\n\n")
-      buf = chunks.pop() ?? ""
-
-      chunks.forEach((chunk) => {
-        const data: string[] = []
-        chunk.split("\n").forEach((line) => {
-          if (line.startsWith("data:")) {
-            data.push(line.replace(/^data:\s*/, ""))
-            return
-          }
-          if (line.startsWith("id:")) {
-            last = line.replace(/^id:\s*/, "")
-            return
-          }
-          if (line.startsWith("retry:")) {
-            const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10)
-            if (!Number.isNaN(parsed)) retry = parsed
-          }
-        })
-
-        if (!data.length) return
-        const raw = data.join("\n")
-        try {
-          onEvent(JSON.parse(raw))
-        } catch {
-          onEvent({
-            type: "sse.message",
-            properties: {
-              data: raw,
-              id: last || undefined,
-              retry,
-            },
-          })
-        }
-      })
-    }
-  } finally {
-    signal.removeEventListener("abort", abort)
-    reader.releaseLock()
-  }
-}

package/src/control-plane/types.ts

@@ -1,32 +0,0 @@
-import z from "zod"
-import { ProjectID } from "@/project/schema"
-import { WorkspaceID } from "./schema"
-
-export const WorkspaceInfo = z.object({
-  id: WorkspaceID.zod,
-  type: z.string(),
-  branch: z.string().nullable(),
-  name: z.string().nullable(),
-  directory: z.string().nullable(),
-  extra: z.unknown().nullable(),
-  projectID: ProjectID.zod,
-})
-export type WorkspaceInfo = z.infer<typeof WorkspaceInfo>
-
-export type Target =
-  | {
-      type: "local"
-      directory: string
-    }
-  | {
-      type: "remote"
-      url: string | URL
-      headers?: HeadersInit
-    }
-
-export type Adaptor = {
-  configure(input: WorkspaceInfo): WorkspaceInfo | Promise<WorkspaceInfo>
-  create(config: WorkspaceInfo, from?: WorkspaceInfo): Promise<void>
-  remove(config: WorkspaceInfo): Promise<void>
-  target(config: WorkspaceInfo): Target | Promise<Target>
-}

package/src/control-plane/workspace.sql.ts

@@ -1,17 +0,0 @@
-import { sqliteTable, text } from "drizzle-orm/sqlite-core"
-import { ProjectTable } from "../project/project.sql"
-import type { ProjectID } from "../project/schema"
-import type { WorkspaceID } from "./schema"
-
-export const WorkspaceTable = sqliteTable("workspace", {
-  id: text().$type<WorkspaceID>().primaryKey(),
-  type: text().notNull(),
-  branch: text(),
-  name: text(),
-  directory: text(),
-  extra: text({ mode: "json" }),
-  project_id: text()
-    .$type<ProjectID>()
-    .notNull()
-    .references(() => ProjectTable.id, { onDelete: "cascade" }),
-})

package/src/control-plane/workspace.ts

@@ -1,168 +0,0 @@
-import z from "zod"
-import { setTimeout as sleep } from "node:timers/promises"
-import { fn } from "@/util/fn"
-import { Database, eq } from "@/storage/db"
-import { Project } from "@/project/project"
-import { BusEvent } from "@/bus/bus-event"
-import { GlobalBus } from "@/bus/global"
-import { Log } from "@/util/log"
-import { ProjectID } from "@/project/schema"
-import { WorkspaceTable } from "./workspace.sql"
-import { getAdaptor } from "./adaptors"
-import { WorkspaceInfo } from "./types"
-import { WorkspaceID } from "./schema"
-import { parseSSE } from "./sse"
-
-export namespace Workspace {
-  export const Event = {
-    Ready: BusEvent.define(
-      "workspace.ready",
-      z.object({
-        name: z.string(),
-      }),
-    ),
-    Failed: BusEvent.define(
-      "workspace.failed",
-      z.object({
-        message: z.string(),
-      }),
-    ),
-  }
-
-  export const Info = WorkspaceInfo.meta({
-    ref: "Workspace",
-  })
-  export type Info = z.infer<typeof Info>
-
-  function fromRow(row: typeof WorkspaceTable.$inferSelect): Info {
-    return {
-      id: row.id,
-      type: row.type,
-      branch: row.branch,
-      name: row.name,
-      directory: row.directory,
-      extra: row.extra,
-      projectID: row.project_id,
-    }
-  }
-
-  const CreateInput = z.object({
-    id: WorkspaceID.zod.optional(),
-    type: Info.shape.type,
-    branch: Info.shape.branch,
-    projectID: ProjectID.zod,
-    extra: Info.shape.extra,
-  })
-
-  export const create = fn(CreateInput, async (input) => {
-    const id = WorkspaceID.ascending(input.id)
-    const adaptor = await getAdaptor(input.type)
-
-    const config = await adaptor.configure({ ...input, id, name: null, directory: null })
-
-    const info: Info = {
-      id,
-      type: config.type,
-      branch: config.branch ?? null,
-      name: config.name ?? null,
-      directory: config.directory ?? null,
-      extra: config.extra ?? null,
-      projectID: input.projectID,
-    }
-
-    Database.use((db) => {
-      db.insert(WorkspaceTable)
-        .values({
-          id: info.id,
-          type: info.type,
-          branch: info.branch,
-          name: info.name,
-          directory: info.directory,
-          extra: info.extra,
-          project_id: info.projectID,
-        })
-        .run()
-    })
-
-    await adaptor.create(config)
-    return info
-  })
-
-  export function list(project: Project.Info) {
-    const rows = Database.use((db) =>
-      db.select().from(WorkspaceTable).where(eq(WorkspaceTable.project_id, project.id)).all(),
-    )
-    return rows.map(fromRow).sort((a, b) => a.id.localeCompare(b.id))
-  }
-
-  export const get = fn(WorkspaceID.zod, async (id) => {
-    const row = Database.use((db) => db.select().from(WorkspaceTable).where(eq(WorkspaceTable.id, id)).get())
-    if (!row) return
-    return fromRow(row)
-  })
-
-  export const remove = fn(WorkspaceID.zod, async (id) => {
-    const row = Database.use((db) => db.select().from(WorkspaceTable).where(eq(WorkspaceTable.id, id)).get())
-    if (row) {
-      const info = fromRow(row)
-      const adaptor = await getAdaptor(row.type)
-      adaptor.remove(info)
-      Database.use((db) => db.delete(WorkspaceTable).where(eq(WorkspaceTable.id, id)).run())
-      return info
-    }
-  })
-  const log = Log.create({ service: "workspace-sync" })
-
-  async function workspaceEventLoop(space: Info, stop: AbortSignal) {
-    while (!stop.aborted) {
-      const adaptor = await getAdaptor(space.type)
-      const target = await Promise.resolve(adaptor.target(space))
-
-      if (target.type === "local") {
-        return
-      }
-
-      const baseURL = String(target.url).replace(/\/?$/, "/")
-
-      const res = await fetch(new URL(baseURL + "/event"), {
-        method: "GET",
-        signal: stop,
-      })
-
-      if (!res.ok || !res.body) {
-        await sleep(1000)
-        continue
-      }
-
-      await parseSSE(res.body, stop, (event) => {
-        GlobalBus.emit("event", {
-          directory: space.id,
-          payload: event,
-        })
-      })
-
-      // Wait 250ms and retry if SSE connection fails
-      await sleep(250)
-    }
-  }
-
-  export function startSyncing(project: Project.Info) {
-    const stop = new AbortController()
-    const spaces = list(project).filter((space) => space.type !== "worktree")
-
-    spaces.forEach((space) => {
-      void workspaceEventLoop(space, stop.signal).catch((error) => {
-        log.warn("workspace sync listener failed", {
-          workspaceID: space.id,
-          error,
-        })
-      })
-    })
-
-    return {
-      async stop() {
-        stop.abort()
-      },
-    }
-  }
-}