@livestore/utils-dev 0.4.0-dev.0 → 0.4.0-dev.10

package/package.json

@@ -1,24 +1,28 @@
 {
   "name": "@livestore/utils-dev",
-  "version": "0.4.0-dev.0",
+  "version": "0.4.0-dev.10",
   "type": "module",
   "sideEffects": [
-    "./src/node-vitest/polyfill.ts"
+    "./src/node-vitest/global.ts",
+    "./dist/node-vitest/global.js"
   ],
   "exports": {
     "./node": "./dist/node/mod.js",
-    "./node-vitest": "./dist/node-vitest/mod.js"
+    "./node-vitest": "./dist/node-vitest/mod.js",
+    "./wrangler": "./dist/wrangler/mod.js"
   },
   "dependencies": {
-    "@effect/opentelemetry": "0.56.1",
-    "@effect/vitest": "0.25.0",
+    "@effect/opentelemetry": "0.58.0",
+    "@effect/vitest": "0.26.0",
+    "@iarna/toml": "2.2.5",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/exporter-metrics-otlp-http": "0.203.0",
     "@opentelemetry/exporter-trace-otlp-http": "0.203.0",
     "@opentelemetry/sdk-metrics": "2.0.1",
     "@opentelemetry/sdk-trace-base": "2.0.1",
     "@opentelemetry/sdk-trace-node": "2.0.1",
-    "@livestore/utils": "0.4.0-dev.0"
+    "wrangler": "4.38.0",
+    "@livestore/utils": "0.4.0-dev.10"
   },
   "devDependencies": {},
   "files": [
@@ -29,10 +33,7 @@
   "license": "Apache-2.0",
   "peerDependencies": {},
   "publishConfig": {
-    "access": "public",
-    "sideEffects": [
-      "./dist/node-vitest/polyfill.js"
-    ]
+    "access": "public"
   },
   "scripts": {
     "test": "echo 'No tests for utils-dev'"

package/src/node/DockerComposeService/DockerComposeService.test.ts

@@ -0,0 +1,91 @@
+import path from 'node:path'
+import { Duration, Effect, Layer, Stream } from '@livestore/utils/effect'
+import { PlatformNode } from '@livestore/utils/node'
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { expect } from 'vitest'
+import { type DockerComposeArgs, DockerComposeService } from './DockerComposeService.ts'
+
+const testTimeout = 30_000
+const testFixturePath = path.join(import.meta.dirname, 'test-fixtures')
+
+const DockerComposeTest = (args: Partial<DockerComposeArgs> = {}) =>
+  DockerComposeService.Default({
+    cwd: testFixturePath,
+    ...args,
+  })
+
+Vitest.describe('DockerComposeService', { timeout: testTimeout }, () => {
+  Vitest.describe('Basic Operations', () => {
+    const withBasicTest = (args: Partial<DockerComposeArgs> = {}) =>
+      Vitest.makeWithTestCtx({
+        timeout: testTimeout,
+        makeLayer: () => DockerComposeTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+      })
+
+    Vitest.scopedLive('can pull docker images', (test) =>
+      Effect.gen(function* () {
+        const dockerCompose = yield* DockerComposeService
+
+        // Test that pull operation works (should succeed for hello-world image)
+        yield* dockerCompose.pull
+      }).pipe(withBasicTest()(test)),
+    )
+
+    Vitest.scopedLive('can start and stop docker compose services', (test) =>
+      Effect.gen(function* () {
+        const dockerCompose = yield* DockerComposeService
+
+        // Start the service
+        yield* dockerCompose.start({ detached: true })
+
+        // Stop the service
+        yield* dockerCompose.stop
+      }).pipe(withBasicTest({ serviceName: 'hello-world' })(test)),
+    )
+
+    Vitest.scopedLive('can get logs from docker compose services', (test) =>
+      Effect.gen(function* () {
+        const dockerCompose = yield* DockerComposeService
+
+        // Start the service first
+        yield* dockerCompose.start({ detached: true })
+
+        // Get logs (should contain at least the "Hello from Docker!" message)
+        const firstLogLine = yield* dockerCompose.logs().pipe(Stream.runHead)
+
+        expect(firstLogLine._tag).toBe('Some')
+
+        // Stop the service
+        yield* dockerCompose.stop
+      }).pipe(withBasicTest({ serviceName: 'hello-world' })(test)),
+    )
+  })
+
+  Vitest.describe('Health Check Operations', () => {
+    const withHealthCheckTest = (args: Partial<DockerComposeArgs> = {}) =>
+      Vitest.makeWithTestCtx({
+        timeout: testTimeout,
+        makeLayer: () => DockerComposeTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+      })
+
+    Vitest.scopedLive('handles health check timeout gracefully', (test) =>
+      Effect.gen(function* () {
+        const dockerCompose = yield* DockerComposeService
+
+        // Test starting with a health check that will timeout (invalid URL)
+        const result = yield* dockerCompose
+          .start({
+            detached: true,
+            healthCheck: {
+              url: 'http://localhost:99999/nonexistent',
+              timeout: Duration.seconds(2),
+            },
+          })
+          .pipe(Effect.either)
+
+        // Should fail due to health check timeout
+        expect(result._tag).toBe('Left')
+      }).pipe(withHealthCheckTest({ serviceName: 'hello-world' })(test)),
+    )
+  })
+})

package/src/node/DockerComposeService/DockerComposeService.ts

@@ -0,0 +1,328 @@
+import { omitUndefineds } from '@livestore/utils'
+import {
+  Command,
+  type CommandExecutor,
+  Duration,
+  Effect,
+  Fiber,
+  type PlatformError,
+  Schedule,
+  Schema,
+  type Scope,
+  Stream,
+} from '@livestore/utils/effect'
+
+export class DockerComposeError extends Schema.TaggedError<DockerComposeError>()('DockerComposeError', {
+  cause: Schema.Defect,
+  note: Schema.String,
+}) {}
+
+export interface DockerComposeArgs {
+  readonly cwd: string
+  readonly serviceName?: string
+}
+
+export interface StartOptions {
+  readonly detached?: boolean
+  readonly env?: Record<string, string>
+  readonly healthCheck?: {
+    readonly url: string
+    readonly timeout?: Duration.Duration
+    readonly interval?: Duration.Duration
+  }
+}
+
+export interface LogsOptions {
+  readonly follow?: boolean
+  readonly tail?: number
+  readonly since?: string
+}
+
+export interface DockerComposeOperations {
+  readonly pull: Effect.Effect<void, DockerComposeError | PlatformError.PlatformError>
+  readonly start: (
+    options?: StartOptions,
+  ) => Effect.Effect<void, DockerComposeError | PlatformError.PlatformError, Scope.Scope>
+  readonly stop: Effect.Effect<void, DockerComposeError | PlatformError.PlatformError>
+  readonly down: (options?: {
+    readonly env?: Record<string, string>
+    readonly volumes?: boolean
+    readonly removeOrphans?: boolean
+  }) => Effect.Effect<void, DockerComposeError | PlatformError.PlatformError>
+  readonly logs: (
+    options?: LogsOptions,
+  ) => Stream.Stream<string, DockerComposeError | PlatformError.PlatformError, Scope.Scope>
+}
+
+export class DockerComposeService extends Effect.Service<DockerComposeService>()('DockerComposeService', {
+  scoped: (args: DockerComposeArgs) =>
+    Effect.gen(function* () {
+      const { cwd, serviceName } = args
+
+      const commandExecutorContext = yield* Effect.context<CommandExecutor.CommandExecutor>()
+
+      const pull = Effect.gen(function* () {
+        yield* Effect.log(`Pulling Docker Compose images in ${cwd}`)
+
+        // TODO (@IMax153) Refactor the effect command related code below as there is probably a much more elegant way to accomplish what we want here in a more effect idiomatic way.
+        const pullCommand = Command.make('docker', 'compose', 'pull').pipe(
+          Command.workingDirectory(cwd),
+          Command.stdout('pipe'),
+          Command.stderr('pipe'),
+        )
+
+        const process = yield* pullCommand.pipe(Command.start, Effect.provide(commandExecutorContext))
+
+        const stdoutFiber = yield* process.stdout.pipe(
+          Stream.decodeText('utf8'),
+          Stream.runFold('', (acc, chunk) => acc + chunk),
+          Effect.fork,
+        )
+
+        const stderrFiber = yield* process.stderr.pipe(
+          Stream.decodeText('utf8'),
+          Stream.runFold('', (acc, chunk) => acc + chunk),
+          Effect.fork,
+        )
+
+        const exitCode = yield* process.exitCode
+        const stdout = yield* Fiber.join(stdoutFiber)
+        const stderr = yield* Fiber.join(stderrFiber)
+
+        const exitCodeNumber = Number(exitCode)
+
+        if (exitCodeNumber !== 0) {
+          const stdoutLog = stdout.length > 0 ? stdout : '<empty stdout>'
+          const stderrLog = stderr.length > 0 ? stderr : '<empty stderr>'
+          const failureMessage = [
+            `Docker compose pull failed with exit code ${exitCodeNumber} in ${cwd}`,
+            `stdout:\n${stdoutLog}`,
+            `stderr:\n${stderrLog}`,
+          ].join('\n')
+
+          yield* Effect.logError(failureMessage)
+
+          return yield* new DockerComposeError({
+            cause: new Error(`Docker compose pull failed with exit code ${exitCodeNumber}`),
+            note: failureMessage,
+          })
+        }
+
+        yield* Effect.log(`Successfully pulled Docker Compose images`)
+      }).pipe(
+        Effect.retry({
+          schedule: Schedule.exponentialBackoff10Sec,
+          while: Schema.is(DockerComposeError),
+        }),
+        Effect.withSpan('pullDockerComposeImages'),
+        Effect.scoped,
+      )
+
+      const start = (options: StartOptions = {}) =>
+        Effect.gen(function* () {
+          const { detached = true, healthCheck } = options
+
+          // Build start command
+          const baseArgs = ['docker', 'compose', 'up']
+          if (detached) baseArgs.push('-d')
+          if (serviceName) baseArgs.push(serviceName)
+
+          const command = yield* Command.make(baseArgs[0]!, ...baseArgs.slice(1)).pipe(
+            Command.workingDirectory(cwd),
+            Command.env(options.env ?? {}),
+            Command.stderr('inherit'),
+            Command.stdout('inherit'),
+            Command.start,
+            Effect.catchAll((cause) =>
+              Effect.fail(
+                new DockerComposeError({
+                  cause,
+                  note: `Failed to start Docker Compose services in ${cwd}`,
+                }),
+              ),
+            ),
+            Effect.provide(commandExecutorContext),
+          )
+
+          // Wait for command completion
+          yield* command.exitCode.pipe(
+            Effect.flatMap((exitCode) =>
+              exitCode === 0
+                ? Effect.void
+                : Effect.fail(
+                    new DockerComposeError({
+                      cause: new Error(`Docker compose exited with code ${exitCode}`),
+                      note: `Docker Compose failed to start with exit code ${exitCode}. Env: ${JSON.stringify(options.env)}`,
+                    }),
+                  ),
+            ),
+            Effect.provide(commandExecutorContext),
+          )
+
+          // Perform health check if requested
+          if (healthCheck) {
+            yield* performHealthCheck(healthCheck).pipe(Effect.provide(commandExecutorContext))
+          }
+
+          yield* Effect.log(`Docker Compose services started successfully in ${cwd}`)
+        }).pipe(Effect.withSpan('startDockerCompose'))
+
+      const stop = Effect.gen(function* () {
+        yield* Effect.log(`Stopping Docker Compose services in ${cwd}`)
+
+        const stopCommand = serviceName
+          ? Command.make('docker', 'compose', 'stop', serviceName)
+          : Command.make('docker', 'compose', 'stop')
+
+        yield* stopCommand.pipe(
+          Command.workingDirectory(cwd),
+          Command.exitCode,
+          Effect.flatMap((exitCode: number) =>
+            exitCode === 0
+              ? Effect.void
+              : Effect.fail(
+                  new DockerComposeError({
+                    cause: new Error(`Docker compose stop exited with code ${exitCode}`),
+                    note: `Failed to stop Docker Compose services`,
+                  }),
+                ),
+          ),
+          Effect.provide(commandExecutorContext),
+        )
+
+        yield* Effect.log(`Docker Compose services stopped successfully`)
+      }).pipe(Effect.withSpan('stopDockerCompose'))
+
+      const logs = (options: LogsOptions = {}) =>
+        Effect.gen(function* () {
+          const { follow = false, tail, since } = options
+
+          const baseArgs = ['docker', 'compose', 'logs']
+          if (follow) baseArgs.push('-f')
+          if (tail) baseArgs.push('--tail', tail.toString())
+          if (since) baseArgs.push('--since', since)
+          if (serviceName) baseArgs.push(serviceName)
+
+          const command = yield* Command.make(baseArgs[0]!, ...baseArgs.slice(1)).pipe(
+            Command.workingDirectory(cwd),
+            Command.start,
+            Effect.catchAll((cause) =>
+              Effect.fail(
+                new DockerComposeError({
+                  cause,
+                  note: `Failed to read Docker Compose logs in ${cwd}`,
+                }),
+              ),
+            ),
+            Effect.provide(commandExecutorContext),
+          )
+
+          return command.stdout.pipe(
+            Stream.decodeText('utf8'),
+            Stream.splitLines,
+            Stream.mapError(
+              (cause) =>
+                new DockerComposeError({
+                  cause,
+                  note: `Error reading Docker Compose logs in ${cwd}`,
+                }),
+            ),
+          )
+        }).pipe(Stream.unwrapScoped)
+
+      const down = (options?: {
+        readonly env?: Record<string, string>
+        readonly volumes?: boolean
+        readonly removeOrphans?: boolean
+      }) =>
+        Effect.gen(function* () {
+          yield* Effect.log(`Tearing down Docker Compose services in ${cwd}`)
+
+          const baseArgs = ['docker', 'compose', 'down']
+          if (options?.volumes) baseArgs.push('-v')
+          if (options?.removeOrphans) baseArgs.push('--remove-orphans')
+          if (serviceName) baseArgs.push(serviceName)
+
+          yield* Command.make(baseArgs[0]!, ...baseArgs.slice(1)).pipe(
+            Command.workingDirectory(cwd),
+            Command.env(options?.env ?? {}),
+            Command.exitCode,
+            Effect.flatMap((exitCode: number) =>
+              exitCode === 0
+                ? Effect.void
+                : Effect.fail(
+                    new DockerComposeError({
+                      cause: new Error(`Docker compose down exited with code ${exitCode}`),
+                      note: `Failed to tear down Docker Compose services`,
+                    }),
+                  ),
+            ),
+            Effect.provide(commandExecutorContext),
+          )
+
+          yield* Effect.log(`Docker Compose services torn down successfully`)
+        }).pipe(Effect.withSpan('downDockerCompose'))
+
+      return { pull, start, stop, down, logs }
+    }),
+}) {}
+
+const performHealthCheck = ({
+  url,
+  timeout = Duration.minutes(2),
+  interval = Duration.seconds(2),
+}: {
+  url: string
+  timeout?: Duration.Duration
+  interval?: Duration.Duration
+}): Effect.Effect<void, DockerComposeError, CommandExecutor.CommandExecutor | Scope.Scope> =>
+  Effect.gen(function* () {
+    yield* Effect.log(`Performing health check on ${url}`)
+
+    const checkHealth = Command.make('curl', '-f', '-s', url).pipe(
+      Command.exitCode,
+      Effect.map((code: number) => code === 0),
+      Effect.catchAll(() => Effect.succeed(false)),
+    )
+
+    const healthCheck = checkHealth.pipe(
+      Effect.repeat({
+        while: (healthy: boolean) => !healthy,
+        schedule: Schedule.fixed(interval),
+      }),
+      Effect.timeout(timeout),
+      Effect.catchAll(() =>
+        Effect.fail(
+          new DockerComposeError({
+            cause: new Error('Health check timeout'),
+            note: `Health check failed for ${url} after ${Duration.toMillis(timeout)}ms`,
+          }),
+        ),
+      ),
+    )
+
+    yield* healthCheck
+    yield* Effect.log(`Health check passed for ${url}`)
+  })
+
+// Convenience function for scoped Docker Compose operations with automatic cleanup
+export const startDockerComposeServicesScoped = (
+  args: DockerComposeArgs & {
+    healthCheck?: StartOptions['healthCheck']
+  },
+): Effect.Effect<
+  void,
+  DockerComposeError | PlatformError.PlatformError,
+  DockerComposeService | CommandExecutor.CommandExecutor | Scope.Scope
+> =>
+  Effect.gen(function* () {
+    const dockerCompose = yield* DockerComposeService
+
+    // Start the services
+    yield* dockerCompose.start({
+      ...omitUndefineds({ healthCheck: args.healthCheck ? args.healthCheck : undefined }),
+    })
+
+    // Add cleanup finalizer to the current scope
+    yield* Effect.addFinalizer(() => dockerCompose.stop.pipe(Effect.orDie))
+  })

package/src/node/DockerComposeService/test-fixtures/docker-compose.yml

@@ -0,0 +1,4 @@
+services:
+  hello-world:
+    image: hello-world
+    profiles: [manual] # Don't auto-start this service

package/src/node/cmd-log.ts

@@ -0,0 +1,92 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { isNotUndefined } from '@livestore/utils'
+import { Effect, identity } from '@livestore/utils/effect'
+
+export type TCmdLoggingOptions = {
+  readonly logDir?: string
+  readonly logFileName?: string
+  readonly logRetention?: number
+}
+
+/**
+ * Prepares logging directories, archives previous canonical log and prunes archives.
+ * Returns the canonical current log path if logging is enabled, otherwise undefined.
+ */
+export const prepareCmdLogging: (options: TCmdLoggingOptions) => Effect.Effect<string | undefined, never, never> =
+  Effect.fn('cmd.logging.prepare')(function* ({
+    logDir,
+    logFileName = 'dev.log',
+    logRetention = 50,
+  }: TCmdLoggingOptions) {
+    if (!logDir || logDir === '') return undefined as string | undefined
+
+    const logsDir = logDir
+    const archiveDir = path.join(logsDir, 'archive')
+    const currentLogPath = path.join(logsDir, logFileName)
+
+    // Ensure directories exist
+    yield* Effect.sync(() => fs.mkdirSync(archiveDir, { recursive: true }))
+
+    // Archive previous log if present
+    if (fs.existsSync(currentLogPath)) {
+      const safeIso = new Date().toISOString().replaceAll(':', '-')
+      const archivedBase = `${path.parse(logFileName).name}-${safeIso}.log`
+      const archivedLog = path.join(archiveDir, archivedBase)
+      yield* Effect.try({ try: () => fs.renameSync(currentLogPath, archivedLog), catch: identity }).pipe(
+        Effect.catchAll(() =>
+          Effect.try({
+            try: () => {
+              fs.copyFileSync(currentLogPath, archivedLog)
+              fs.truncateSync(currentLogPath, 0)
+            },
+            catch: identity,
+          }),
+        ),
+        Effect.ignore,
+      )
+
+      // Prune archives to retain only the newest N
+      yield* Effect.try({ try: () => fs.readdirSync(archiveDir), catch: identity }).pipe(
+        Effect.map((names) => names.filter((n) => n.endsWith('.log'))),
+        Effect.map((names) =>
+          names
+            .map((name) => ({ name, mtimeMs: fs.statSync(path.join(archiveDir, name)).mtimeMs }))
+            .sort((a, b) => b.mtimeMs - a.mtimeMs),
+        ),
+        Effect.flatMap((entries) =>
+          Effect.forEach(entries.slice(logRetention), (e) =>
+            Effect.try({ try: () => fs.unlinkSync(path.join(archiveDir, e.name)), catch: identity }).pipe(
+              Effect.ignore,
+            ),
+          ),
+        ),
+        Effect.ignore,
+      )
+    }
+
+    return currentLogPath
+  })
+
+/**
+ * Given a command input, applies logging by piping output through `tee` to the
+ * canonical log file. Returns the transformed input and whether a shell is required.
+ */
+export const applyLoggingToCommand: (
+  commandInput: string | (string | undefined)[],
+  options: TCmdLoggingOptions,
+) => Effect.Effect<{ input: string | string[]; subshell: boolean; logPath?: string }, never, never> = Effect.fn(
+  'cmd.logging.apply',
+)(function* (commandInput, options) {
+  const asArray = Array.isArray(commandInput)
+  const parts = asArray ? (commandInput as (string | undefined)[]).filter(isNotUndefined) : undefined
+
+  const logPath = yield* prepareCmdLogging(options)
+
+  return {
+    input: asArray ? ((parts as string[]) ?? []) : (commandInput as string),
+    subshell: false,
+    ...(logPath ? { logPath } : {}),
+  }
+})

package/src/node/cmd.test.ts

@@ -0,0 +1,129 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { CommandExecutor, Duration, Effect } from '@livestore/utils/effect'
+import { PlatformNode } from '@livestore/utils/node'
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { expect } from 'vitest'
+import { cmd } from './cmd.ts'
+
+const withNode = Vitest.makeWithTestCtx({
+  makeLayer: () => PlatformNode.NodeContext.layer,
+  timeout: 20_000,
+})
+
+Vitest.describe('cmd helper', () => {
+  const ansiRegex = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, 'g')
+
+  Vitest.scopedLive('runs tokenized string without shell', (test) =>
+    Effect.gen(function* () {
+      const exit = yield* cmd('printf ok')
+      expect(exit).toBe(CommandExecutor.ExitCode(0))
+    }).pipe(withNode(test)),
+  )
+
+  Vitest.scopedLive('runs array input', (test) =>
+    Effect.gen(function* () {
+      const exit = yield* cmd(['printf', 'ok'])
+      expect(exit).toBe(CommandExecutor.ExitCode(0))
+    }).pipe(withNode(test)),
+  )
+
+  Vitest.scopedLive('supports logging with archive + retention', (test) =>
+    Effect.gen(function* () {
+      const workspace = process.env.WORKSPACE_ROOT!
+      const logsDir = path.join(workspace, 'tmp', 'cmd-tests', String(Date.now()))
+
+      // first run
+      const exit1 = yield* cmd('printf first', { logDir: logsDir })
+      expect(exit1).toBe(CommandExecutor.ExitCode(0))
+      const current = path.join(logsDir, 'dev.log')
+      expect(fs.existsSync(current)).toBe(true)
+      const firstLog = fs.readFileSync(current, 'utf8')
+      const firstStdoutLines = firstLog.split('\n').filter((line) => line.includes('[stdout]'))
+      expect(firstStdoutLines.length).toBeGreaterThan(0)
+      for (const line of firstStdoutLines) {
+        expect(line).toContain('[stdout] first')
+        expect(line).toContain('INFO')
+        expect(line).toContain('printf first')
+      }
+
+      // second run — archives previous
+      const exit2 = yield* cmd('printf second', { logDir: logsDir })
+      expect(exit2).toBe(CommandExecutor.ExitCode(0))
+      const archiveDir = path.join(logsDir, 'archive')
+      const archives = fs.readdirSync(archiveDir).filter((f) => f.endsWith('.log'))
+      expect(archives.length).toBe(1)
+      const archivedPath = path.join(archiveDir, archives[0]!)
+      const archivedLog = fs.readFileSync(archivedPath, 'utf8')
+      const archivedStdoutLines = archivedLog.split('\n').filter((line) => line.includes('[stdout]'))
+      expect(archivedStdoutLines.length).toBeGreaterThan(0)
+      for (const line of archivedStdoutLines) {
+        expect(line).toContain('[stdout] first')
+      }
+
+      const secondLog = fs.readFileSync(current, 'utf8')
+      const secondStdoutLines = secondLog.split('\n').filter((line) => line.includes('[stdout]'))
+      expect(secondStdoutLines.length).toBeGreaterThan(0)
+      for (const line of secondStdoutLines) {
+        expect(line).toContain('[stdout] second')
+        expect(line).toContain('INFO')
+      }
+
+      // generate many archives to exercise retention (keep 50)
+      for (let i = 0; i < 60; i++) {
+        // Use small unique payloads
+        yield* cmd(['printf', String(i)], { logDir: logsDir })
+      }
+      const archivesAfter = fs.readdirSync(archiveDir).filter((f) => f.endsWith('.log'))
+      expect(archivesAfter.length).toBeLessThanOrEqual(50)
+    }).pipe(withNode(test)),
+  )
+
+  Vitest.scopedLive('streams stdout and stderr with logger formatting', (test) =>
+    Effect.gen(function* () {
+      const workspace = process.env.WORKSPACE_ROOT!
+      const logsDir = path.join(workspace, 'tmp', 'cmd-tests', `format-${Date.now()}`)
+
+      const exit = yield* cmd(['node', '-e', "console.log('out'); console.error('err')"], {
+        logDir: logsDir,
+      })
+      expect(exit).toBe(CommandExecutor.ExitCode(0))
+
+      const current = path.join(logsDir, 'dev.log')
+      const logContent = fs.readFileSync(current, 'utf8')
+      expect(logContent).toMatch(/\[stdout] out/)
+      expect(logContent).toMatch(/\[stderr] err/)
+
+      const relevantLines = logContent
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.includes('[stdout]') || line.includes('[stderr]'))
+
+      expect(relevantLines.length).toBeGreaterThanOrEqual(2)
+
+      for (const line of relevantLines) {
+        const stripped = line.replace(ansiRegex, '')
+        expect(stripped.startsWith('[')).toBe(true)
+        expect(stripped).toMatch(/(INFO|WARN)/)
+        expect(stripped).toMatch(/\[(stdout|stderr)]/)
+      }
+    }).pipe(withNode(test)),
+  )
+
+  Vitest.scopedLive('cleans up logged child process when interrupted', (test) =>
+    Effect.gen(function* () {
+      const workspace = process.env.WORKSPACE_ROOT!
+      const logsDir = path.join(workspace, 'tmp', 'cmd-tests', `timeout-${Date.now()}`)
+
+      const result = yield* cmd(['node', '-e', 'setTimeout(() => {}, 5000)'], {
+        logDir: logsDir,
+        stdout: 'pipe',
+        stderr: 'pipe',
+      }).pipe(Effect.timeoutOption(Duration.millis(200)))
+
+      expect(result._tag).toBe('None')
+      expect(fs.existsSync(path.join(logsDir, 'dev.log'))).toBe(true)
+    }).pipe(withNode(test)),
+  )
+})