saeeol 1.4.2 → 1.4.3

package/src/config/provider.ts

@@ -1,117 +0,0 @@
-import { Schema } from "effect"
-import { PROMPTS } from "@saeeol/gateway" 
-import { zod } from "@/util/effect-zod"
-import { PositiveInt, withStatics } from "@/util/schema"
-
-export const Model = Schema.Struct({
-  id: Schema.optional(Schema.String),
-  name: Schema.optional(Schema.String),
-  family: Schema.optional(Schema.String),
-  prompt: Schema.optional(Schema.Literals(PROMPTS)), 
-  release_date: Schema.optional(Schema.String),
-  attachment: Schema.optional(Schema.Boolean),
-  reasoning: Schema.optional(Schema.Boolean),
-  temperature: Schema.optional(Schema.Boolean),
-  tool_call: Schema.optional(Schema.Boolean),
-  interleaved: Schema.optional(
-    Schema.Union([
-      Schema.Literal(true),
-      Schema.Struct({
-        field: Schema.Literals(["reasoning_content", "reasoning_details"]),
-      }),
-    ]),
-  ),
-  cost: Schema.optional(
-    Schema.Struct({
-      input: Schema.Finite,
-      output: Schema.Finite,
-      cache_read: Schema.optional(Schema.Finite),
-      cache_write: Schema.optional(Schema.Finite),
-      context_over_200k: Schema.optional(
-        Schema.Struct({
-          input: Schema.Finite,
-          output: Schema.Finite,
-          cache_read: Schema.optional(Schema.Finite),
-          cache_write: Schema.optional(Schema.Finite),
-        }),
-      ),
-    }),
-  ),
-  limit: Schema.optional(
-    Schema.Struct({
-      context: Schema.Finite,
-      input: Schema.optional(Schema.Finite),
-      output: Schema.Finite,
-    }),
-  ),
-  modalities: Schema.optional(
-    Schema.Struct({
-      input: Schema.mutable(Schema.Array(Schema.Literals(["text", "audio", "image", "video", "pdf"]))),
-      output: Schema.mutable(Schema.Array(Schema.Literals(["text", "audio", "image", "video", "pdf"]))),
-    }),
-  ),
-  experimental: Schema.optional(Schema.Boolean),
-  status: Schema.optional(Schema.Literals(["alpha", "beta", "deprecated"])),
-  provider: Schema.optional(
-    Schema.Struct({ npm: Schema.optional(Schema.String), api: Schema.optional(Schema.String) }),
-  ),
-  options: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  variants: Schema.optional(
-    Schema.Record(
-      Schema.String,
-      Schema.NullOr(
-        Schema.StructWithRest(
-          Schema.Struct({
-            disabled: Schema.optional(Schema.Boolean).annotate({ description: "Disable this variant for the model" }),
-          }),
-          [Schema.Record(Schema.String, Schema.Any)],
-        ),
-      ),
-    ).annotate({ description: "Variant-specific configuration" }),
-  ),
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-
-export const Info = Schema.Struct({
-  api: Schema.optional(Schema.String),
-  name: Schema.optional(Schema.String),
-  env: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
-  id: Schema.optional(Schema.String),
-  npm: Schema.optional(Schema.String),
-  whitelist: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
-  blacklist: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
-  options: Schema.optional(
-    Schema.StructWithRest(
-      Schema.Struct({
-        apiKey: Schema.optional(Schema.String),
-        baseURL: Schema.optional(Schema.String),
-        enterpriseUrl: Schema.optional(Schema.String).annotate({
-          description: "GitHub Enterprise URL for copilot authentication",
-        }),
-        setCacheKey: Schema.optional(Schema.Boolean).annotate({
-          description: "Enable promptCacheKey for this provider (default false)",
-        }),
-        timeout: Schema.optional(
-          Schema.Union([PositiveInt, Schema.Literal(false)]).annotate({
-            description:
-              "Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout.",
-          }),
-        ).annotate({
-          description:
-            "Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout.",
-        }),
-        chunkTimeout: Schema.optional(PositiveInt).annotate({
-          description:
-            "Timeout in milliseconds between streamed SSE chunks for this provider. If no chunk arrives within this window, the request is aborted.",
-        }),
-      }),
-      [Schema.Record(Schema.String, Schema.Any)],
-    ),
-  ),
-  models: Schema.optional(Schema.Record(Schema.String, Schema.NullOr(Model))), 
-})
-  .annotate({ identifier: "ProviderConfig" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Info = Schema.Schema.Type<typeof Info>
-
-export * as ConfigProvider from "./provider"

package/src/config/server.ts

@@ -1,22 +0,0 @@
-import { Schema } from "effect"
-import { zod } from "@/util/effect-zod"
-import { PositiveInt, withStatics } from "@/util/schema"
-
-export const Server = Schema.Struct({
-  port: Schema.optional(PositiveInt).annotate({
-    description: "Port to listen on",
-  }),
-  hostname: Schema.optional(Schema.String).annotate({ description: "Hostname to listen on" }),
-  mdns: Schema.optional(Schema.Boolean).annotate({ description: "Enable mDNS service discovery" }),
-  mdnsDomain: Schema.optional(Schema.String).annotate({
-    description: "Custom domain name for mDNS service (default: saeeol.local)", 
-  }),
-  cors: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
-    description: "Additional domains to allow for CORS",
-  }),
-})
-  .annotate({ identifier: "ServerConfig" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Server = Schema.Schema.Type<typeof Server>
-
-export * as ConfigServer from "./server"

package/src/config/skills.ts

@@ -1,16 +0,0 @@
-import { Schema } from "effect"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-export const Info = Schema.Struct({
-  paths: Schema.optional(Schema.Array(Schema.String)).annotate({
-    description: "Additional paths to skill folders",
-  }),
-  urls: Schema.optional(Schema.Array(Schema.String)).annotate({
-    description: "URLs to fetch skills from (e.g., https://example.com/.well-known/skills/)",
-  }),
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-
-export type Info = Schema.Schema.Type<typeof Info>
-
-export * as ConfigSkills from "./skills"

package/src/config/variable.ts

@@ -1,92 +0,0 @@
-export * as ConfigVariable from "./variable"
-
-import path from "path"
-import os from "os"
-import { Filesystem } from "@/util/filesystem"
-import { InvalidError } from "./error"
-
-type ParseSource =
-  | {
-      type: "path"
-      path: string
-    }
-  | {
-      type: "virtual"
-      source: string
-      dir: string
-    }
-
-type SubstituteInput = ParseSource & {
-  text: string
-  missing?: "error" | "empty"
-  escapeJson?: boolean 
-}
-
-function source(input: ParseSource) {
-  return input.type === "path" ? input.path : input.source
-}
-
-function dir(input: ParseSource) {
-  return input.type === "path" ? path.dirname(input.path) : input.dir
-}
-
-/** Apply {env:VAR} and {file:path} substitutions to config text. */
-export async function substitute(input: SubstituteInput) {
-  const missing = input.missing ?? "error"
-  const escape = input.escapeJson ?? true 
-  let text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => {
-    return process.env[varName] || ""
-  })
-
-  const fileMatches = Array.from(text.matchAll(/\{file:[^}]+\}/g))
-  if (!fileMatches.length) return text
-
-  const configDir = dir(input)
-  const configSource = source(input)
-  let out = ""
-  let cursor = 0
-
-  for (const match of fileMatches) {
-    const token = match[0]
-    const index = match.index!
-    out += text.slice(cursor, index)
-
-    const lineStart = text.lastIndexOf("\n", index - 1) + 1
-    const prefix = text.slice(lineStart, index).trimStart()
-    if (prefix.startsWith("//")) {
-      out += token
-      cursor = index + token.length
-      continue
-    }
-
-    let filePath = token.replace(/^\{file:/, "").replace(/\}$/, "")
-    if (filePath.startsWith("~/")) {
-      filePath = path.join(os.homedir(), filePath.slice(2))
-    }
-
-    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(configDir, filePath)
-    const fileContent = (
-      await Filesystem.readText(resolvedPath).catch((error: NodeJS.ErrnoException) => {
-        if (missing === "empty") return ""
-
-        const errMsg = `bad file reference: "${token}"`
-        if (error.code === "ENOENT") {
-          throw new InvalidError(
-            {
-              path: configSource,
-              message: errMsg + ` ${resolvedPath} does not exist`,
-            },
-            { cause: error },
-          )
-        }
-        throw new InvalidError({ path: configSource, message: errMsg }, { cause: error })
-      })
-    ).trim()
-
-    out += escape ? JSON.stringify(fileContent).slice(1, -1) : fileContent 
-    cursor = index + token.length
-  }
-
-  out += text.slice(cursor)
-  return out
-}

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

@@ -1,45 +0,0 @@
-import type { ProjectID } from "@/project/schema"
-import type { WorkspaceAdapter, WorkspaceAdapterEntry } from "../types"
-import { WorktreeAdapter } from "./worktree"
-
-const BUILTIN: Record<string, WorkspaceAdapter> = {
-  worktree: WorktreeAdapter,
-}
-
-const state = new Map<ProjectID, Map<string, WorkspaceAdapter>>()
-
-export function getAdapter(projectID: ProjectID, type: string): WorkspaceAdapter {
-  const custom = state.get(projectID)?.get(type)
-  if (custom) return custom
-
-  const builtin = BUILTIN[type]
-  if (builtin) return builtin
-
-  throw new Error(`Unknown workspace adapter: ${type}`)
-}
-
-export async function listAdapters(projectID: ProjectID): Promise<WorkspaceAdapterEntry[]> {
-  const builtin = await Promise.all(
-    Object.entries(BUILTIN).map(async ([type, adapter]) => {
-      return {
-        type,
-        name: adapter.name,
-        description: adapter.description,
-      }
-    }),
-  )
-  const custom = [...(state.get(projectID)?.entries() ?? [])].map(([type, adapter]) => ({
-    type,
-    name: adapter.name,
-    description: adapter.description,
-  }))
-  return [...builtin, ...custom]
-}
-
-// Plugins can be loaded per-project so we need to scope them. If you
-// want to install a global one pass `ProjectID.global`
-export function registerAdapter(projectID: ProjectID, type: string, adapter: WorkspaceAdapter) {
-  const adapters = state.get(projectID) ?? new Map<string, WorkspaceAdapter>()
-  adapters.set(type, adapter)
-  state.set(projectID, adapters)
-}

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

@@ -1,54 +0,0 @@
-import { Schema } from "effect"
-import { type WorkspaceAdapter, WorkspaceInfo } from "../types"
-
-const WorktreeConfig = Schema.Struct({
-  name: WorkspaceInfo.fields.name,
-  branch: Schema.String,
-  directory: Schema.String,
-})
-const decodeWorktreeConfig = Schema.decodeUnknownSync(WorktreeConfig)
-
-async function loadWorktree() {
-  const [{ AppRuntime }, { Worktree }] = await Promise.all([import("@/effect/app-runtime"), import("@/worktree")])
-  return { AppRuntime, Worktree }
-}
-
-export const WorktreeAdapter: WorkspaceAdapter = {
-  name: "Worktree",
-  description: "Create a git worktree",
-  async configure(info) {
-    const { AppRuntime, Worktree } = await loadWorktree()
-    const next = await AppRuntime.runPromise(Worktree.Service.use((svc) => svc.makeWorktreeInfo()))
-    return {
-      ...info,
-      name: next.name,
-      branch: next.branch,
-      directory: next.directory,
-    }
-  },
-  async create(info) {
-    const { AppRuntime, Worktree } = await loadWorktree()
-    const config = decodeWorktreeConfig(info)
-    await AppRuntime.runPromise(
-      Worktree.Service.use((svc) =>
-        svc.createFromInfo({
-          name: config.name,
-          directory: config.directory,
-          branch: config.branch,
-        }),
-      ),
-    )
-  },
-  async remove(info) {
-    const { AppRuntime, Worktree } = await loadWorktree()
-    const config = decodeWorktreeConfig(info)
-    await AppRuntime.runPromise(Worktree.Service.use((svc) => svc.remove({ directory: config.directory })))
-  },
-  target(info) {
-    const config = decodeWorktreeConfig(info)
-    return {
-      type: "local",
-      directory: config.directory,
-    }
-  },
-}

package/src/control-plane/dev/README.md

@@ -1,19 +0,0 @@
-This is a plugin to simulate a remote environment locally. Add this to `.saeeol/saeeol.jsonc`:
-
-```json
-  "plugin": ["../packages/saeeol/src/control-plane/dev/debug-workspace-plugin.ts"],
-```
-
-In a separate terminal, run a separate Saeeol server. This will act like a remote server and the local instance will proxy all requests to it:
-
-```
-./packages/saeeol/script/run-workspace-server
-```
-
-With the plugin install, you can now run Saeeol and create a `debug` workspace type. This will create a "remote" workspace which talks to the second workspace server started above.
-
-How this works:
-
-- The workspace server needs to know the workspace id and port to run. It waits for this information to be written to a file and starts the server when the data is written.
-- The debug plugin writes this information in the `create` call to the workspace. So create a `debug` workspace will always kick off a new external server.
-- The server script watches for file changes, so whenver you create a new `debug` workspace it will restart with the new information. This means that there is only ever one working `debug` workspace at a time; when you create a new one all previous sessions will show that it can't connect because previous debug workspaces do not exist.

package/src/control-plane/dev/debug-workspace-plugin.ts

@@ -1,73 +0,0 @@
-import type { Plugin } from "@saeeol/plugin"
-import { rename, writeFile } from "node:fs/promises"
-import { randomInt } from "node:crypto"
-import { setTimeout as sleep } from "node:timers/promises"
-
-const DEV_DATA_FILE = "/tmp/saeeol-workspace-dev-data.json"
-const DEV_DATA_TEMP_FILE = `${DEV_DATA_FILE}.tmp`
-
-async function waitForHealth(port: number) {
-  const url = `http://127.0.0.1:${port}/global/health`
-  const started = Date.now()
-
-  while (Date.now() - started < 30_000) {
-    try {
-      const response = await fetch(url)
-      if (response.ok) {
-        return
-      }
-    } catch {}
-
-    await sleep(250)
-  }
-
-  throw new Error(`Timed out waiting for debug server health check at ${url}`)
-}
-
-let PORT: number | undefined
-
-async function writeDebugData(port: number, id: string, env: Record<string, string | undefined>) {
-  await writeFile(
-    DEV_DATA_TEMP_FILE,
-    JSON.stringify(
-      {
-        port,
-        id,
-        env,
-      },
-      null,
-      2,
-    ),
-  )
-
-  await rename(DEV_DATA_TEMP_FILE, DEV_DATA_FILE)
-}
-
-export const DebugWorkspacePlugin: Plugin = async ({ experimental_workspace }) => {
-  experimental_workspace.register("debug", {
-    name: "Debug",
-    description: "Create a debugging server",
-    configure(config) {
-      return config
-    },
-    async create(config, env) {
-      const port = randomInt(5000, 9001)
-      PORT = port
-
-      await writeDebugData(port, config.id, env)
-
-      await waitForHealth(port)
-    },
-    async remove(_config) {},
-    target(_config) {
-      return {
-        type: "remote",
-        url: `http://localhost:${PORT!}/`,
-      }
-    },
-  })
-
-  return {}
-}
-
-export default DebugWorkspacePlugin

package/src/control-plane/schema.ts

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

package/src/control-plane/types.ts

@@ -1,45 +0,0 @@
-import { Schema } from "effect"
-import { ProjectID } from "@/project/schema"
-import { WorkspaceID } from "./schema"
-import { zod } from "@/util/effect-zod"
-import { type DeepMutable, withStatics } from "@/util/schema"
-
-export const WorkspaceInfo = Schema.Struct({
-  id: WorkspaceID,
-  type: Schema.String,
-  name: Schema.String,
-  branch: Schema.NullOr(Schema.String),
-  directory: Schema.NullOr(Schema.String),
-  extra: Schema.NullOr(Schema.Unknown),
-  projectID: ProjectID,
-})
-  .annotate({ identifier: "Workspace" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type WorkspaceInfo = DeepMutable<Schema.Schema.Type<typeof WorkspaceInfo>>
-
-export const WorkspaceAdapterEntry = Schema.Struct({
-  type: Schema.String,
-  name: Schema.String,
-  description: Schema.String,
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type WorkspaceAdapterEntry = Schema.Schema.Type<typeof WorkspaceAdapterEntry>
-
-export type Target =
-  | {
-      type: "local"
-      directory: string
-    }
-  | {
-      type: "remote"
-      url: string | URL
-      headers?: HeadersInit
-    }
-
-export type WorkspaceAdapter = {
-  name: string
-  description: string
-  configure(info: WorkspaceInfo): WorkspaceInfo | Promise<WorkspaceInfo>
-  create(info: WorkspaceInfo, env: Record<string, string | undefined>, from?: WorkspaceInfo): Promise<void>
-  remove(info: WorkspaceInfo): Promise<void>
-  target(info: WorkspaceInfo): Target | Promise<Target>
-}

package/src/control-plane/util.ts

@@ -1,39 +0,0 @@
-import { GlobalBus, type GlobalEvent } from "@/bus/global"
-import { Effect } from "effect"
-
-export function waitEvent(input: { timeout: number; signal?: AbortSignal; fn: (event: GlobalEvent) => boolean }) {
-  if (input.signal?.aborted) return Effect.fail(input.signal.reason ?? new Error("Request aborted"))
-
-  return Effect.callback<void, unknown>((resume) => {
-    const abort = () => {
-      cleanup()
-      resume(Effect.fail(input.signal?.reason ?? new Error("Request aborted")))
-    }
-
-    const handler = (event: GlobalEvent) => {
-      try {
-        if (!input.fn(event)) return
-        cleanup()
-        resume(Effect.void)
-      } catch (error) {
-        cleanup()
-        resume(Effect.fail(error))
-      }
-    }
-
-    const cleanup = () => {
-      clearTimeout(timeout)
-      GlobalBus.off("event", handler)
-      input.signal?.removeEventListener("abort", abort)
-    }
-
-    const timeout = setTimeout(() => {
-      cleanup()
-      resume(Effect.fail(new Error("Timed out waiting for global event")))
-    }, input.timeout)
-
-    GlobalBus.on("event", handler)
-    input.signal?.addEventListener("abort", abort, { once: true })
-    return Effect.sync(cleanup)
-  })
-}

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

@@ -1,26 +0,0 @@
-import { LocalContext } from "@/util/local-context"
-import type { WorkspaceID } from "../control-plane/schema"
-
-export interface WorkspaceContext {
-  workspaceID: WorkspaceID | undefined
-}
-
-const context = LocalContext.create<WorkspaceContext>("instance")
-
-export const WorkspaceContext = {
-  async provide<R>(input: { workspaceID?: WorkspaceID; fn: () => R }): Promise<R> {
-    return context.provide({ workspaceID: input.workspaceID }, () => input.fn())
-  },
-
-  restore<R>(workspaceID: WorkspaceID, fn: () => R): R {
-    return context.provide({ workspaceID }, fn)
-  },
-
-  get workspaceID() {
-    try {
-      return context.use().workspaceID
-    } catch {
-      return undefined
-    }
-  },
-}

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

@@ -1,90 +0,0 @@
-import { Context, Effect, Schema } from "effect"
-import { Database } from "@/storage/db"
-import { Project } from "@/project/project"
-import { BusEvent } from "@/bus/bus-event"
-import { Auth } from "@/auth"
-import { EventSequenceTable } from "@/sync/event.sql"
-import * as Log from "@saeeol/core/util/log"
-import { ProjectID } from "@/project/schema"
-import { WorkspaceTable } from "./workspace.sql"
-import { type WorkspaceInfo, WorkspaceInfo as WorkspaceInfoSchema } from "./types"
-import { WorkspaceID } from "./schema"
-import { SessionTable } from "@/session/session.sql"
-import { SessionID } from "@/session/schema"
-import { NonNegativeInt, withStatics } from "@/util/schema"
-import { zod as effectZod, zodObject } from "@/util/effect-zod"
-import { inArray } from "drizzle-orm"
-
-export const Info = WorkspaceInfoSchema
-export type Info = WorkspaceInfo
-
-export const ConnectionStatus = Schema.Struct({ workspaceID: WorkspaceID, status: Schema.Literals(["connected", "connecting", "disconnected", "error"]) })
-export type ConnectionStatus = Schema.Schema.Type<typeof ConnectionStatus>
-
-const Restore = Schema.Struct({ workspaceID: WorkspaceID, sessionID: SessionID, total: NonNegativeInt, step: NonNegativeInt })
-
-export const Event = {
-  Ready: BusEvent.define("workspace.ready", Schema.Struct({ name: Schema.String })),
-  Failed: BusEvent.define("workspace.failed", Schema.Struct({ message: Schema.String })),
-  Restore: BusEvent.define("workspace.restore", Restore),
-  Status: BusEvent.define("workspace.status", ConnectionStatus),
-}
-
-export 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 }
-}
-
-export const db = <T>(fn: (d: Parameters<typeof Database.use>[0] extends (trx: infer D) => any ? D : never) => T) =>
-  Effect.sync(() => Database.use(fn))
-
-export const log = Log.create({ service: "workspace-sync" })
-
-export const CreateInput = Schema.Struct({ id: Schema.optional(WorkspaceID), type: Info.fields.type, branch: Info.fields.branch, projectID: ProjectID, extra: Info.fields.extra }).pipe(withStatics((s) => ({ zod: effectZod(s), zodObject: zodObject(s) })))
-export type CreateInput = Schema.Schema.Type<typeof CreateInput>
-
-export const SessionRestoreInput = Schema.Struct({ workspaceID: WorkspaceID, sessionID: SessionID }).pipe(withStatics((s) => ({ zod: effectZod(s), zodObject: zodObject(s) })))
-export type SessionRestoreInput = Schema.Schema.Type<typeof SessionRestoreInput>
-
-export class SyncHttpError extends Schema.TaggedErrorClass<SyncHttpError>()("WorkspaceSyncHttpError", { message: Schema.String, status: Schema.Number, body: Schema.optional(Schema.String) }) {}
-export class WorkspaceNotFoundError extends Schema.TaggedErrorClass<WorkspaceNotFoundError>()("WorkspaceNotFoundError", { message: Schema.String, workspaceID: WorkspaceID }) {}
-export class SessionEventsNotFoundError extends Schema.TaggedErrorClass<SessionEventsNotFoundError>()("WorkspaceSessionEventsNotFoundError", { message: Schema.String, sessionID: SessionID }) {}
-export class SessionRestoreHttpError extends Schema.TaggedErrorClass<SessionRestoreHttpError>()("WorkspaceSessionRestoreHttpError", { message: Schema.String, workspaceID: WorkspaceID, sessionID: SessionID, status: Schema.Number, body: Schema.String }) {}
-export class SyncTimeoutError extends Schema.TaggedErrorClass<SyncTimeoutError>()("WorkspaceSyncTimeoutError", { message: Schema.String, state: Schema.Record(Schema.String, Schema.Number) }) {}
-export class SyncAbortedError extends Schema.TaggedErrorClass<SyncAbortedError>()("WorkspaceSyncAbortedError", { message: Schema.String, cause: Schema.optional(Schema.Defect) }) {}
-
-type CreateError = Auth.AuthError
-type SessionRestoreError = WorkspaceNotFoundError | SessionEventsNotFoundError | SessionRestoreHttpError | (any)
-type WaitForSyncError = SyncTimeoutError | SyncAbortedError
-type SyncLoopError = SyncHttpError | (any)
-
-export interface Interface {
-  readonly create: (input: CreateInput) => Effect.Effect<Info, CreateError>
-  readonly sessionRestore: (input: SessionRestoreInput) => Effect.Effect<{ total: number }, SessionRestoreError>
-  readonly list: (project: Project.Info) => Effect.Effect<Info[]>
-  readonly get: (id: WorkspaceID) => Effect.Effect<Info | undefined>
-  readonly remove: (id: WorkspaceID) => Effect.Effect<Info | undefined>
-  readonly status: () => Effect.Effect<ConnectionStatus[]>
-  readonly isSyncing: (workspaceID: WorkspaceID) => Effect.Effect<boolean>
-  readonly waitForSync: (workspaceID: WorkspaceID, state: Record<string, number>, signal?: AbortSignal) => Effect.Effect<void, WaitForSyncError>
-  readonly startWorkspaceSyncing: (projectID: ProjectID) => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/Workspace") {}
-
-export const TIMEOUT = 5000
-type HistoryEvent = { id: string; aggregate_id: string; seq: number; type: string; data: Record<string, unknown> }
-
-export function synced(state: Record<string, number>) {
-  const ids = Object.keys(state)
-  if (ids.length === 0) return true
-  const done = Object.fromEntries(Database.use((db) => db.select({ id: EventSequenceTable.aggregate_id, seq: EventSequenceTable.seq }).from(EventSequenceTable).where(inArray(EventSequenceTable.aggregate_id, ids)).all()).map((row) => [row.id, row.seq])) as Record<string, number>
-  return ids.every((id) => (done[id] ?? -1) >= state[id])
-}
-
-export function route(url: string | URL, path: string) {
-  const next = new URL(url)
-  next.pathname = `${next.pathname.replace(/\/$/, "")}${path}`
-  next.search = ""
-  next.hash = ""
-  return next
-}