effect-start 0.27.0 → 0.28.0

package/src/Docker.ts

@@ -0,0 +1,190 @@
+import * as Context from "effect/Context"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Ref from "effect/Ref"
+import * as Stream from "effect/Stream"
+
+import type * as ChildProcess from "./ChildProcess.ts"
+import * as System from "./System.ts"
+
+export class DockerError extends Data.TaggedError("DockerError")<{
+  message: string
+  cause?: unknown
+}> {}
+
+export interface ExecResult {
+  readonly exitCode: number
+  readonly stdout: string
+}
+
+export interface Container {
+  readonly id: string
+  readonly name?: string
+  readonly ports?: ReadonlyArray<readonly [host: number, container: number]>
+  readonly exec: (
+    command: ReadonlyArray<string>,
+    options?: { readonly detach?: boolean },
+  ) => Effect.Effect<ExecResult, DockerError, ChildProcess.ChildProcessSpawner>
+}
+
+export interface ContainerOptions {
+  readonly image: string
+  readonly name?: string
+  readonly detach?: boolean
+  readonly rm?: boolean
+  readonly env?: Record<string, string>
+  readonly ports?: ReadonlyArray<readonly [host: number, container: number]>
+  readonly args?: ReadonlyArray<string>
+}
+
+export interface DockerService {
+  readonly exec: (
+    container: string,
+    command: ReadonlyArray<string>,
+    options?: { readonly detach?: boolean },
+  ) => Effect.Effect<ExecResult, DockerError, ChildProcess.ChildProcessSpawner>
+  readonly run: (
+    options: ContainerOptions,
+  ) => Effect.Effect<Container, DockerError, ChildProcess.ChildProcessSpawner>
+  readonly start: (
+    container: string,
+  ) => Effect.Effect<void, DockerError, ChildProcess.ChildProcessSpawner>
+  readonly containers: Effect.Effect<ReadonlyArray<Container>>
+}
+
+export class Docker extends Context.Tag("effect-start/Docker")<Docker, DockerService>() {}
+
+export class DockerContainer extends Context.Tag("effect-start/DockerContainer")<
+  DockerContainer,
+  Container
+>() {}
+
+const dockerExec = (...args: ReadonlyArray<string>) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const handle = yield* System.spawn(["docker", ...args], {
+        stdout: "ignore",
+        stderr: "inherit",
+      })
+      return yield* handle.exitCode
+    }),
+  )
+
+const dockerExecStdout = (...args: ReadonlyArray<string>) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const handle = yield* System.spawn(["docker", ...args], {
+        stdout: "pipe",
+        stderr: "inherit",
+      })
+      const [stdout, exitCode] = yield* Effect.all(
+        [handle.stdout.pipe(Stream.decodeText("utf-8"), Stream.mkString), handle.exitCode],
+        { concurrency: 2 },
+      )
+      return { stdout, exitCode }
+    }),
+  )
+
+const removeContainer = (container: string) => dockerExec("rm", "-f", container).pipe(Effect.ignore)
+
+export const layer = Layer.scoped(
+  Docker,
+  Effect.gen(function* () {
+    const tracked = yield* Ref.make<ReadonlyArray<Container>>([])
+
+    yield* Effect.addFinalizer(() =>
+      Ref.get(tracked).pipe(
+        Effect.flatMap((containers) =>
+          Effect.forEach(containers, (c) => removeContainer(c.id), { discard: true }),
+        ),
+      ),
+    )
+
+    const track = (container: Container) => Ref.update(tracked, (cs) => [container, ...cs])
+
+    const execFn = (
+      container: string,
+      command: ReadonlyArray<string>,
+      options?: { readonly detach?: boolean },
+    ) =>
+      Effect.gen(function* () {
+        const args: Array<string> = ["exec"]
+        if (options?.detach) args.push("-d")
+        args.push(container, ...command)
+
+        const result = yield* dockerExecStdout(...args).pipe(
+          Effect.mapError((cause) => new DockerError({ message: `docker exec failed`, cause })),
+        )
+
+        return { exitCode: result.exitCode, stdout: result.stdout.trim() } satisfies ExecResult
+      })
+
+    return {
+      exec: execFn,
+
+      run: (options) =>
+        Effect.gen(function* () {
+          const args: Array<string> = ["run"]
+
+          if (options.detach) args.push("-d")
+          if (options.rm) args.push("--rm")
+          if (options.name) args.push("--name", options.name)
+
+          if (options.env) {
+            for (const [k, v] of Object.entries(options.env)) {
+              args.push("-e", `${k}=${v}`)
+            }
+          }
+
+          if (options.ports) {
+            for (const [host, container] of options.ports) {
+              args.push("-p", `${host}:${container}`)
+            }
+          }
+
+          args.push(options.image)
+
+          if (options.args) args.push(...options.args)
+
+          const result = yield* dockerExecStdout(...args).pipe(
+            Effect.mapError((cause) => new DockerError({ message: `docker run failed`, cause })),
+          )
+
+          const id = result.stdout.trim()
+          const container: Container = {
+            id,
+            name: options.name,
+            ports: options.ports,
+            exec: (command, execOptions) => execFn(id, command, execOptions),
+          }
+
+          if (!options.rm) {
+            yield* track(container)
+          }
+
+          return container
+        }),
+
+      start: (container) =>
+        Effect.gen(function* () {
+          const code = yield* dockerExec("start", container).pipe(
+            Effect.mapError((cause) => new DockerError({ message: `docker start failed`, cause })),
+          )
+          if (code !== 0) {
+            yield* Effect.fail(
+              new DockerError({ message: `docker start exited with code ${code}` }),
+            )
+          }
+        }),
+
+      containers: Ref.get(tracked),
+    } satisfies DockerService
+  }),
+)
+
+export const layerContainer = (options: ContainerOptions) =>
+  Layer.effect(
+    DockerContainer,
+    Effect.flatMap(Docker, (docker) => docker.run(options)),
+  )

package/src/Effectify.ts

@@ -269,16 +269,13 @@ export const effectify: {
   (...args: Array<any>) =>
     Effect.async<any, any>((resume) => {
       try {
-        fn(
-          ...args,
-          (err: any, result: any) => {
-            if (err) {
-              resume(Effect.fail(onError ? onError(err, args) : err))
-            } else {
-              resume(Effect.succeed(result))
-            }
-          },
-        )
+        fn(...args, (err: any, result: any) => {
+          if (err) {
+            resume(Effect.fail(onError ? onError(err, args) : err))
+          } else {
+            resume(Effect.succeed(result))
+          }
+        })
       } catch (err) {
         resume(onSyncError ? Effect.fail(onSyncError(err, args)) : Effect.die(err))
       }

package/src/FileSystem.ts

@@ -342,10 +342,7 @@ export const make = (
   })
 }
 
-const fileStream = (
-  file: File,
-  options: StreamOptions = {},
-) => {
+const fileStream = (file: File, options: StreamOptions = {}) => {
   const bytesToRead = options.bytesToRead !== undefined ? Size(options.bytesToRead) : undefined
   const chunkSize = Size(options.chunkSize ?? 64 * 1024)
 

package/src/GlobalLayer.ts

@@ -0,0 +1,85 @@
+import * as Context from "effect/Context"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import type * as Fiber from "effect/Fiber"
+import * as GlobalValue from "effect/GlobalValue"
+import * as HashMap from "effect/HashMap"
+import * as Layer from "effect/Layer"
+import * as MutableRef from "effect/MutableRef"
+import * as Option from "effect/Option"
+import * as Runtime from "effect/Runtime"
+
+import * as ChildProcess from "./ChildProcess.ts"
+
+interface CacheEntry {
+  readonly context: Context.Context<any>
+  readonly fiber: Fiber.RuntimeFiber<void>
+}
+
+const cache = GlobalValue.globalValue(Symbol.for("effect-start/GlobalLayer/cache"), () =>
+  MutableRef.make(HashMap.empty<string, CacheEntry>()),
+)
+
+export const globalLayer =
+  (key: string) =>
+  <A, E>(
+    layer: Layer.Layer<A, E> | Layer.Layer<A, E, ChildProcess.ChildProcessSpawner>,
+  ): Layer.Layer<A, E> => {
+    const existing = HashMap.get(MutableRef.get(cache), key)
+    if (existing._tag === "Some") {
+      return Layer.succeedContext(existing.value.context) as Layer.Layer<A, E>
+    }
+
+    return Layer.scopedContext(
+      Effect.gen(function* () {
+        const cached = HashMap.get(MutableRef.get(cache), key)
+        if (cached._tag === "Some") {
+          return cached.value.context as Context.Context<A>
+        }
+
+        const spawner = yield* Effect.serviceOption(ChildProcess.ChildProcessSpawner)
+        const deferred = yield* Deferred.make<Context.Context<A>, E>()
+
+        const parentRuntime = yield* Effect.runtime<never>()
+
+        const defaultRuntime = Runtime.make({
+          // Empty service context — no custom services leak into the forked fiber
+          context: Context.empty(),
+
+          // Bit flags for runtime behavior (interruption, cooperative yielding, etc.)
+          runtimeFlags: parentRuntime.runtimeFlags,
+
+          // Per-fiber state like logger config, tracer settings, span annotations.
+          // Default services are wired through FiberRefs, not the service context.
+          fiberRefs: parentRuntime.fiberRefs,
+        })
+
+        const fiber = Runtime.runFork(defaultRuntime)(
+          Effect.scoped(
+            Effect.gen(function* () {
+              const scope = yield* Effect.scope
+              const memoMap = yield* Layer.makeMemoMap
+              const ctx = yield* (layer as Layer.Layer<A, E>).pipe(
+                Layer.buildWithMemoMap(memoMap, scope),
+                Option.isSome(spawner)
+                  ? Effect.provideService(ChildProcess.ChildProcessSpawner, spawner.value)
+                  : (a) => a,
+              )
+              yield* Deferred.succeed(deferred, ctx)
+              yield* Effect.never
+            }),
+          ),
+        ) as Fiber.RuntimeFiber<void>
+
+        const ctx = yield* Deferred.await(deferred)
+
+        MutableRef.update(cache, HashMap.set(key, { context: ctx, fiber } as CacheEntry))
+
+        fiber.addObserver(() => {
+          MutableRef.update(cache, HashMap.remove(key))
+        })
+
+        return ctx
+      }),
+    )
+  }

package/src/PlatformRuntime.ts

@@ -6,8 +6,15 @@ import type * as FiberId from "effect/FiberId"
 import * as FiberRef from "effect/FiberRef"
 import * as FiberRefs from "effect/FiberRefs"
 import * as Function from "effect/Function"
+import * as GlobalValue from "effect/GlobalValue"
 import * as HashSet from "effect/HashSet"
 import * as Logger from "effect/Logger"
+import * as MutableRef from "effect/MutableRef"
+
+export const mainFiber = GlobalValue.globalValue(
+  Symbol.for("effect-start/PlatformRuntime/mainFiber"),
+  () => MutableRef.make<Fiber.RuntimeFiber<unknown, unknown> | undefined>(undefined),
+)
 
 export interface Teardown {
   <E, A>(exit: Exit.Exit<E, A>, onExit: (code: number) => void): void
@@ -95,6 +102,6 @@ export function isAgentHarness() {
   return (
     typeof process !== "undefined" &&
     !process.stdout.isTTY &&
-    (process.env.CLAUDECODE || process.env.CURSOR_AGENT)
+    (process.env.CLAUDECODE || process.env.CURSOR_AGENT || process.env.CODEX_THREAD_ID)
   )
 }

package/src/RouteHook.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect"
 import type * as Utils from "effect/Utils"
-import * as Entity from "./Entity.ts"
+import type * as Entity from "./Entity.ts"
 import * as Route from "./Route.ts"
 
 export type FilterResult<BOut, E, R> = { context: BOut } | Effect.Effect<{ context: BOut }, E, R>

package/src/SqlIntrospect.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect"
 import * as Schema from "effect/Schema"
-import * as Sql from "./sql/SqlClient.ts"
+import * as SqlClient from "./sql/SqlClient.ts"
 
 export interface Column {
   readonly tableSchema: string
@@ -336,9 +336,9 @@ const normalizeBooleans = (columns: ReadonlyArray<Column>): ReadonlyArray<Column
 export const introspect = (
   dialect: Dialect,
   options?: IntrospectOptions,
-): Effect.Effect<DatabaseSchema, Sql.SqlError, Sql.SqlClient> =>
+): Effect.Effect<DatabaseSchema, SqlClient.SqlError, SqlClient.SqlClient> =>
   Effect.gen(function* () {
-    const sql = yield* Sql.SqlClient
+    const sql = yield* SqlClient.SqlClient
     const q = dialectQueries[dialect]
     const columns = normalizeBooleans(yield* sql.unsafe<Column>(q.columns))
     const foreignKeys =
@@ -481,11 +481,13 @@ export interface TableReader {
   readonly sortableColumns: ReadonlyArray<string>
   readonly findAll: (
     options?: FindAllOptions,
-  ) => Effect.Effect<ReadonlyArray<unknown>, Sql.SqlError, Sql.SqlClient>
-  readonly findById: (id: unknown) => Effect.Effect<unknown | null, Sql.SqlError, Sql.SqlClient>
+  ) => Effect.Effect<ReadonlyArray<unknown>, SqlClient.SqlError, SqlClient.SqlClient>
+  readonly findById: (
+    id: unknown,
+  ) => Effect.Effect<unknown | null, SqlClient.SqlError, SqlClient.SqlClient>
   readonly count: (options?: {
     readonly filters?: ReadonlyArray<Filter>
-  }) => Effect.Effect<number, Sql.SqlError, Sql.SqlClient>
+  }) => Effect.Effect<number, SqlClient.SqlError, SqlClient.SqlClient>
 }
 
 export interface DatabaseReader {
@@ -496,9 +498,9 @@ export interface DatabaseReader {
 const escapeIdentifier = (id: string): string => `"${id.replace(/"/g, '""')}"`
 
 const concatSql = (
-  sql: Sql.Connection,
+  sql: SqlClient.Connection,
   fragments: Array<{ strings: ReadonlyArray<string>; values: Array<unknown> }>,
-): Effect.Effect<ReadonlyArray<unknown>, Sql.SqlError> => {
+): Effect.Effect<ReadonlyArray<unknown>, SqlClient.SqlError> => {
   const strings: Array<string> = []
   const values: Array<unknown> = []
   for (let i = 0; i < fragments.length; i++) {
@@ -559,7 +561,7 @@ const makeTableReader = (ts: TableSchema): TableReader => {
     sortableColumns: Array.from(sortableSet),
     findAll: (options) =>
       Effect.gen(function* () {
-        const sql = yield* Sql.SqlClient
+        const sql = yield* SqlClient.SqlClient
         const fragments: Array<{ strings: ReadonlyArray<string>; values: Array<unknown> }> = [
           literal(`SELECT ${selectCols} FROM ${qualifiedName}`),
         ]
@@ -581,7 +583,7 @@ const makeTableReader = (ts: TableSchema): TableReader => {
     findById: (id) =>
       Effect.gen(function* () {
         if (!primaryKey) return null
-        const sql = yield* Sql.SqlClient
+        const sql = yield* SqlClient.SqlClient
         const pkCol = escapeIdentifier(primaryKey.columnName)
         const rows = yield* concatSql(sql, [
           literal(`SELECT ${selectCols} FROM ${qualifiedName} WHERE ${pkCol} = `),
@@ -591,7 +593,7 @@ const makeTableReader = (ts: TableSchema): TableReader => {
       }),
     count: (options) =>
       Effect.gen(function* () {
-        const sql = yield* Sql.SqlClient
+        const sql = yield* SqlClient.SqlClient
         const fragments: Array<{ strings: ReadonlyArray<string>; values: Array<unknown> }> = [
           literal(`SELECT COUNT(*) as count FROM ${qualifiedName}`),
         ]

package/src/Start.ts

@@ -2,6 +2,7 @@ import type * as FileSystem from "./FileSystem.ts"
 import * as Context from "effect/Context"
 import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
+import * as FiberId from "effect/FiberId"
 import * as ExecutionStrategy from "effect/ExecutionStrategy"
 import * as Exit from "effect/Exit"
 import * as Function from "effect/Function"
@@ -9,10 +10,12 @@ import * as Layer from "effect/Layer"
 import * as Scope from "effect/Scope"
 import * as SynchronizedRef from "effect/SynchronizedRef"
 import type * as ChildProcess from "./ChildProcess.ts"
+import * as MutableRef from "effect/MutableRef"
 import * as BunRuntime from "./bun/BunRuntime.ts"
 import * as BunServer from "./bun/BunServer.ts"
 import * as NodeFileSystem from "./node/NodeFileSystem.ts"
 import * as BunChildProcessSpawner from "./bun/BunChildProcessSpawner.ts"
+import * as PlatformRuntime from "./PlatformRuntime.ts"
 import * as StartApp from "./StartApp.ts"
 
 export function layer<
@@ -48,9 +51,7 @@ export function layer<
  * @since 1.0.0
  * @category constructors
  */
-export function pack<
-  const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>],
->(
+export function pack<const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
   ...layers: Layers & OrderedPack<NoInfer<Layers>, NoInfer<Layers>>
 ): Layer.Layer<
   { [K in keyof Layers]: Layer.Layer.Success<Layers[K]> }[number],
@@ -70,8 +71,7 @@ export function pack<
   return result as AnyLayer
 }
 
-type Unsatisfied<Unmet, Success> =
-  Unmet extends Success ? Unmet : never
+type Unsatisfied<Unmet, Success> = Unmet extends Success ? Unmet : never
 
 type OrderedPack<
   Layers extends readonly Layer.Layer.Any[],
@@ -81,16 +81,19 @@ type OrderedPack<
   ...infer Tail extends Layer.Layer.Any[],
 ]
   ? [
-    [
-      Unsatisfied<
-        Exclude<Layer.Layer.Context<Head>, { [K in keyof Tail]: Layer.Layer.Success<Tail[K]> }[number]>,
-        { [K in keyof All]: Layer.Layer.Success<All[K]> }[number]
-      >,
-    ] extends [never]
-    ? Head
-    : never,
-    ...OrderedPack<Tail, All>,
-  ]
+      [
+        Unsatisfied<
+          Exclude<
+            Layer.Layer.Context<Head>,
+            { [K in keyof Tail]: Layer.Layer.Success<Tail[K]> }[number]
+          >,
+          { [K in keyof All]: Layer.Layer.Success<All[K]> }[number]
+        >,
+      ] extends [never]
+        ? Head
+        : never,
+      ...OrderedPack<Tail, All>,
+    ]
   : []
 
 /**
@@ -105,18 +108,22 @@ type OrderedPack<
  * @since 1.0.0
  * @category constructors
  */
-export function build<
-  const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>],
->(
+type BuildSuccess<Layers extends readonly Layer.Layer.Any[]> = {
+  [K in keyof Layers]: Layer.Layer.Success<Layers[K]>
+}[number]
+
+type BuildError<Layers extends readonly Layer.Layer.Any[]> = {
+  [K in keyof Layers]: Layer.Layer.Error<Layers[K]>
+}[number]
+
+type BuildContext<Layers extends readonly Layer.Layer.Any[]> = Exclude<
+  { [K in keyof Layers]: Layer.Layer.Context<Layers[K]> }[number],
+  { [K in keyof Layers]: Layer.Layer.Success<Layers[K]> }[number]
+>
+
+export function build<const Layers extends readonly [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
   ...layers: Layers
-): Layer.Layer<
-  { [K in keyof Layers]: Layer.Layer.Success<Layers[K]> }[number],
-  { [K in keyof Layers]: Layer.Layer.Error<Layers[K]> }[number],
-  Exclude<
-    { [K in keyof Layers]: Layer.Layer.Context<Layers[K]> }[number],
-    { [K in keyof Layers]: Layer.Layer.Success<Layers[K]> }[number]
-  >
-> {
+): Layer.Layer<BuildSuccess<Layers>, BuildError<Layers>, BuildContext<Layers>> {
   type AnyLayer = Layer.Layer<any, any, any>
   const layerArray = layers as unknown as ReadonlyArray<AnyLayer>
 
@@ -129,7 +136,7 @@ export function build<
       const pending = new Set<AnyLayer>(layerArray)
 
       for (let pass = 0; pass < layerArray.length && pending.size > 0; pass++) {
-        for (const layer of [...pending]) {
+        for (const layer of pending) {
           const childScope = yield* Scope.fork(scope, ExecutionStrategy.sequential)
           const exit = yield* layer.pipe(
             Layer.buildWithMemoMap(memoMap, childScope),
@@ -160,8 +167,7 @@ export function build<
 
       return ctx
     }),
-    // TODO: not sure how to properly type it yet
-  ) as any
+  )
 }
 
 export type PlatformServices =
@@ -205,3 +211,8 @@ export function serve<ROut, E, RIn extends PlatformServices>(
 
   return Function.pipe(composed, Layer.launch, BunRuntime.runMain)
 }
+
+export const mainFiberId: Effect.Effect<FiberId.FiberId> = Effect.sync(() => {
+  const fiber = MutableRef.get(PlatformRuntime.mainFiber)
+  return fiber ? fiber.id() : FiberId.none
+})

package/src/System.ts

@@ -1,11 +1,69 @@
 import * as Effect from "effect/Effect"
 import type * as Scope from "effect/Scope"
+import * as NNet from "node:net"
 
 import * as ChildProcess from "./ChildProcess.ts"
 import * as PlatformError from "./PlatformError.ts"
 
 export const cwd: Effect.Effect<string> = Effect.sync(() => process.cwd())
 
+export const randomFreePort: Effect.Effect<number, PlatformError.SystemError> = Effect.async<
+  number,
+  PlatformError.SystemError
+>((resume) => {
+  const server = NNet.createServer()
+  server.unref()
+  server.on("error", (err) =>
+    resume(
+      Effect.fail(
+        new PlatformError.SystemError({
+          reason: "Unknown",
+          module: "System",
+          method: "randomFreePort",
+          description: err.message,
+          cause: err,
+        }),
+      ),
+    ),
+  )
+  server.listen(0, "127.0.0.1", () => {
+    const address = server.address()
+    if (!address || typeof address === "string") {
+      server.close(() =>
+        resume(
+          Effect.fail(
+            new PlatformError.SystemError({
+              reason: "Unknown",
+              module: "System",
+              method: "randomFreePort",
+              description: "Failed to allocate a free port",
+            }),
+          ),
+        ),
+      )
+      return
+    }
+    const port = address.port
+    server.close((err) => {
+      if (err) {
+        resume(
+          Effect.fail(
+            new PlatformError.SystemError({
+              reason: "Unknown",
+              module: "System",
+              method: "randomFreePort",
+              description: err.message,
+              cause: err,
+            }),
+          ),
+        )
+        return
+      }
+      resume(Effect.succeed(port))
+    })
+  })
+})
+
 export const which = (name: string): Effect.Effect<string, PlatformError.SystemError> =>
   Effect.flatMap(
     Effect.try({
@@ -33,11 +91,10 @@ export const which = (name: string): Effect.Effect<string, PlatformError.SystemE
   )
 
 export const spawn = (
-  command: string,
-  args?: ReadonlyArray<string>,
+  cmd: readonly [string, ...Array<string>],
   options?: ChildProcess.Command.Options,
 ): Effect.Effect<
   ChildProcess.ChildProcessHandle,
   PlatformError.PlatformError,
   ChildProcess.ChildProcessSpawner | Scope.Scope
-> => ChildProcess.spawn(ChildProcess.make(command, args, options))
+> => ChildProcess.spawn(ChildProcess.make(cmd, options))