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

package/src/node/cmd.test.ts

@@ -1,37 +1,39 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { CommandExecutor, Duration, Effect, Layer } from '@livestore/utils/effect'
-import { PlatformNode } from '@livestore/utils/node'
-import { Vitest } from '@livestore/utils-dev/node-vitest'
+
 import { expect } from 'vitest'
 
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { ChildProcessSpawner, Duration, Effect, Layer } from '@livestore/utils/effect'
+import { PlatformNode } from '@livestore/utils/node'
+
 import { cmd } from './cmd.ts'
 import { CurrentWorkingDirectory } from './workspace.ts'
 
 const withNode = Vitest.makeWithTestCtx({
-  makeLayer: () => Layer.mergeAll(PlatformNode.NodeContext.layer, CurrentWorkingDirectory.live),
+  makeLayer: () => Layer.mergeAll(PlatformNode.NodeServices.layer, CurrentWorkingDirectory.live),
   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) =>
+  Vitest.live('runs tokenized string without shell', (test) =>
     Effect.gen(function* () {
       const exit = yield* cmd('printf ok')
-      expect(exit).toBe(CommandExecutor.ExitCode(0))
+      expect(exit).toBe(ChildProcessSpawner.ExitCode(0))
     }).pipe(withNode(test)),
   )
 
-  Vitest.scopedLive('runs array input', (test) =>
+  Vitest.live('runs array input', (test) =>
     Effect.gen(function* () {
       const exit = yield* cmd(['printf', 'ok'])
-      expect(exit).toBe(CommandExecutor.ExitCode(0))
+      expect(exit).toBe(ChildProcessSpawner.ExitCode(0))
     }).pipe(withNode(test)),
   )
 
   /** TODO(#1020): Investigate CI timeout flakiness for cmd tests that spawn many child processes */
-  Vitest.scopedLive(
+  Vitest.live(
     'supports logging with archive + retention',
     (test) =>
       Effect.gen(function* () {
@@ -40,7 +42,7 @@ Vitest.describe('cmd helper', () => {
 
         // first run
         const exit1 = yield* cmd('printf first', { logDir: logsDir })
-        expect(exit1).toBe(CommandExecutor.ExitCode(0))
+        expect(exit1).toBe(ChildProcessSpawner.ExitCode(0))
         const current = path.join(logsDir, 'dev.log')
         expect(fs.existsSync(current)).toBe(true)
         const firstLog = fs.readFileSync(current, 'utf8')
@@ -48,13 +50,13 @@ Vitest.describe('cmd helper', () => {
         expect(firstStdoutLines.length).toBeGreaterThan(0)
         for (const line of firstStdoutLines) {
           expect(line).toContain('[stdout] first')
-          expect(line).toContain('INFO')
+          expect(line).toMatch(/Info/i)
           expect(line).toContain('printf first')
         }
 
         // second run — archives previous
         const exit2 = yield* cmd('printf second', { logDir: logsDir })
-        expect(exit2).toBe(CommandExecutor.ExitCode(0))
+        expect(exit2).toBe(ChildProcessSpawner.ExitCode(0))
         const archiveDir = path.join(logsDir, 'archive')
         const archives = fs.readdirSync(archiveDir).filter((f) => f.endsWith('.log'))
         expect(archives.length).toBe(1)
@@ -71,7 +73,7 @@ Vitest.describe('cmd helper', () => {
         expect(secondStdoutLines.length).toBeGreaterThan(0)
         for (const line of secondStdoutLines) {
           expect(line).toContain('[stdout] second')
-          expect(line).toContain('INFO')
+          expect(line).toMatch(/Info/i)
         }
 
         // generate many archives to exercise retention (keep 50)
@@ -85,7 +87,7 @@ Vitest.describe('cmd helper', () => {
     { timeout: 30_000, retry: 3 },
   )
 
-  Vitest.scopedLive('streams stdout and stderr with logger formatting', (test) =>
+  Vitest.live('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()}`)
@@ -93,7 +95,7 @@ Vitest.describe('cmd helper', () => {
       const exit = yield* cmd(['node', '-e', "console.log('out'); console.error('err')"], {
         logDir: logsDir,
       })
-      expect(exit).toBe(CommandExecutor.ExitCode(0))
+      expect(exit).toBe(ChildProcessSpawner.ExitCode(0))
 
       const current = path.join(logsDir, 'dev.log')
       const logContent = fs.readFileSync(current, 'utf8')
@@ -110,13 +112,13 @@ Vitest.describe('cmd helper', () => {
       for (const line of relevantLines) {
         const stripped = line.replace(ansiRegex, '')
         expect(stripped.startsWith('[')).toBe(true)
-        expect(stripped).toMatch(/(INFO|WARN)/)
+        expect(stripped).toMatch(/(Info|Warn)/i)
         expect(stripped).toMatch(/\[(stdout|stderr)]/)
       }
     }).pipe(withNode(test)),
   )
 
-  Vitest.scopedLive('cleans up logged child process when interrupted', (test) =>
+  Vitest.live('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()}`)

package/src/node/cmd.ts

@@ -1,29 +1,24 @@
-import fs from 'node:fs'
-
-import { isNotUndefined } from '@livestore/utils'
 import {
   Cause,
-  Command,
-  type CommandExecutor,
+  ChildProcess,
+  ChildProcessSpawner,
   Effect,
   Fiber,
-  FiberId,
-  FiberRefs,
-  HashMap,
-  identity,
-  List,
-  LogLevel,
+  Logger,
   type PlatformError,
+  Predicate,
+  References,
   Schema,
   Stream,
 } from '@livestore/utils/effect'
+import { NodeFileSystem } from '@livestore/utils/node'
 
 import { applyLoggingToCommand } from './cmd-log.ts'
 import * as FileLogger from './FileLogger.ts'
 import { CurrentWorkingDirectory } from './workspace.ts'
 
 // Branded zero value so we can compare exit codes without touching internals.
-const SUCCESS_EXIT_CODE: CommandExecutor.ExitCode = 0 as CommandExecutor.ExitCode
+const SUCCESS_EXIT_CODE: ChildProcessSpawner.ExitCode = ChildProcessSpawner.ExitCode(0)
 
 export const cmd: (
   commandInput: string | (string | undefined)[],
@@ -43,14 +38,14 @@ export const cmd: (
     logRetention?: number
   },
 ) => Effect.Effect<
-  CommandExecutor.ExitCode,
+  ChildProcessSpawner.ExitCode,
   PlatformError.PlatformError | CmdError,
-  CommandExecutor.CommandExecutor | CurrentWorkingDirectory
+  ChildProcessSpawner.ChildProcessSpawner | CurrentWorkingDirectory
 > = Effect.fn('cmd')(function* (commandInput, options) {
   const cwd = yield* CurrentWorkingDirectory
 
   const asArray = Array.isArray(commandInput)
-  const parts = asArray === true ? commandInput.filter(isNotUndefined) : undefined
+  const parts = asArray === true ? commandInput.filter(Predicate.isNotUndefined) : undefined
   const [command, ...args] = asArray === true ? (parts as string[]) : commandInput.split(' ')
 
   const debugEnvStr = Object.entries(options?.env ?? {})
@@ -89,7 +84,7 @@ export const cmd: (
     useShell,
   } as const
 
-  const exitCode = yield* isNotUndefined(logPath) === true
+  const exitCode = yield* Predicate.isNotUndefined(logPath) === true
     ? Effect.gen(function* () {
         yield* Effect.sync(() => console.log(`Logging output to ${logPath}`))
         return yield* runWithLogging({ ...baseArgs, logPath, threadName: commandDebugStr })
@@ -116,37 +111,42 @@ export const cmdText: (
     runInShell?: boolean
     env?: Record<string, string | undefined>
   },
-) => Effect.Effect<string, PlatformError.PlatformError, CommandExecutor.CommandExecutor | CurrentWorkingDirectory> =
-  Effect.fn('cmdText')(function* (commandInput, options) {
-    const cwd = yield* CurrentWorkingDirectory
-    const [command, ...args] =
-      Array.isArray(commandInput) === true ? commandInput.filter(isNotUndefined) : commandInput.split(' ')
-    const debugEnvStr = Object.entries(options?.env ?? {})
-      .map(([key, value]) => `${key}='${String(value)}' `)
-      .join('')
-
-    const commandDebugStr = debugEnvStr + [command, ...args].join(' ')
-    const subshellStr = options?.runInShell === true ? ' (in subshell)' : ''
-
-    yield* Effect.logDebug(`Running '${commandDebugStr}' in '${cwd}'${subshellStr}`)
-    yield* Effect.annotateCurrentSpan({ 'span.label': commandDebugStr, command, cwd })
-
-    return yield* Command.make(command!, ...args).pipe(
-      // inherit = Stream stderr to process.stderr, pipe = Stream stderr to process.stdout
-      Command.stderr(options?.stderr ?? 'inherit'),
-      Command.workingDirectory(cwd),
-      options?.runInShell === true ? Command.runInShell(true) : identity,
-      Command.env(options?.env ?? {}),
-      Command.string,
-    )
-  })
+) => Effect.Effect<
+  string,
+  PlatformError.PlatformError,
+  ChildProcessSpawner.ChildProcessSpawner | CurrentWorkingDirectory
+> = Effect.fn('cmdText')(function* (commandInput, options) {
+  const cwd = yield* CurrentWorkingDirectory
+  const commandParts =
+    Array.isArray(commandInput) === true ? commandInput.filter(Predicate.isNotUndefined) : commandInput.split(' ')
+  const [command, ...args] = commandParts
+  const debugEnvStr = Object.entries(options?.env ?? {})
+    .map(([key, value]) => `${key}='${String(value)}' `)
+    .join('')
+
+  const commandDebugStr = debugEnvStr + [command, ...args].join(' ')
+  const subshellStr = options?.runInShell === true ? ' (in subshell)' : ''
+
+  yield* Effect.logDebug(`Running '${commandDebugStr}' in '${cwd}'${subshellStr}`)
+  yield* Effect.annotateCurrentSpan({ 'span.label': commandDebugStr, command, cwd })
+
+  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+  return yield* spawner.string(
+    buildCommand(commandParts, {
+      cwd,
+      env: options?.env ?? {},
+      stderr: options?.stderr ?? 'inherit',
+      shell: options?.runInShell === true,
+    }),
+  )
+})
 
 export class CmdError extends Schema.TaggedError<CmdError>('~@livestore/utils-dev/CmdError')('CmdError', {
   command: Schema.String,
   args: Schema.Array(Schema.String),
   cwd: Schema.String,
-  env: Schema.Record({ key: Schema.String, value: Schema.String.pipe(Schema.UndefinedOr) }),
-  stderr: Schema.Literal('inherit', 'pipe'),
+  env: Schema.Record(Schema.String, Schema.String.pipe(Schema.UndefinedOr)),
+  stderr: Schema.Literals(['inherit', 'pipe']),
 }) {}
 
 type TRunBaseArgs = {
@@ -159,15 +159,19 @@ type TRunBaseArgs = {
 }
 
 const runWithoutLogging = ({ commandInput, cwd, env, stdoutMode, stderrMode, useShell }: TRunBaseArgs) =>
-  buildCommand(commandInput, useShell).pipe(
-    Command.stdin('inherit'),
-    Command.stdout(stdoutMode),
-    Command.stderr(stderrMode),
-    Command.workingDirectory(cwd),
-    useShell === true ? Command.runInShell(true) : identity,
-    Command.env(env),
-    Command.exitCode,
-  )
+  Effect.gen(function* () {
+    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+    return yield* spawner.exitCode(
+      buildCommand(commandInput, {
+        cwd,
+        env,
+        stdin: 'inherit',
+        stdout: stdoutMode,
+        stderr: stderrMode,
+        shell: useShell,
+      }),
+    )
+  })
 
 type TRunWithLoggingArgs = TRunBaseArgs & {
   readonly logPath: string
@@ -192,46 +196,54 @@ const runWithLogging = ({
     Effect.gen(function* () {
       const envWithColor = env.FORCE_COLOR === undefined ? { ...env, FORCE_COLOR: '1' } : env
 
-      const logFile = yield* Effect.acquireRelease(
-        Effect.sync(() => fs.openSync(logPath, 'a', 0o666)),
-        (fd) => Effect.sync(() => fs.closeSync(fd)),
-      )
-
-      const prettyLogger = FileLogger.prettyLoggerTty({
+      const prettyLoggerOptions = {
         colors: true,
         stderr: false,
-        formatDate: (date) => `${FileLogger.defaultDateFormat(date)} ${threadName}`,
-      })
+        formatDate: FileLogger.formatLogTime,
+      } as const
+
+      const logStringToFile = yield* Logger.make<unknown, string>(({ message }) => {
+        if (typeof message === 'string') return message
+        return String(message)
+      }).pipe(Logger.toFile(logPath, { flag: 'a' }), Effect.provide(NodeFileSystem.layer))
+
+      const FileLoggerLive = Logger.layer([logStringToFile])
 
       const appendLog = ({ channel, content }: { channel: 'stdout' | 'stderr'; content: string }) =>
-        Effect.sync(() => {
-          const formatted = prettyLogger.log({
-            fiberId: FiberId.none,
-            logLevel: channel === 'stdout' ? LogLevel.Info : LogLevel.Warning,
+        Effect.gen(function* () {
+          const date = new Date()
+          const formatted = FileLogger.formatPrettyLog({
+            logLevel: channel === 'stdout' ? 'Info' : 'Warn',
             message: [`[${channel}]${content.length > 0 ? ` ${content}` : ''}`],
             cause: Cause.empty,
-            context: FiberRefs.empty(),
-            spans: List.empty(),
-            annotations: HashMap.empty(),
-            date: new Date(),
+            date,
+            fiberId: 0,
+            spans: [[threadName, date.getTime()]],
+            annotations: { thread: threadName },
+            options: prettyLoggerOptions,
           })
-          fs.writeSync(logFile, formatted)
+
+          yield* Effect.log(formatted.endsWith('\n') === true ? formatted.slice(0, -1) : formatted).pipe(
+            Effect.provideService(References.MinimumLogLevel, 'All'),
+            Effect.provide(FileLoggerLive),
+          )
         })
 
-      const command = buildCommand(commandInput, useShell).pipe(
-        Command.stdin('inherit'),
-        Command.stdout('pipe'),
-        Command.stderr('pipe'),
-        Command.workingDirectory(cwd),
-        useShell === true ? Command.runInShell(true) : identity,
-        Command.env(envWithColor),
-      )
+      const command = buildCommand(commandInput, {
+        cwd,
+        env: envWithColor,
+        stdin: 'inherit',
+        stdout: 'pipe',
+        stderr: 'pipe',
+        shell: useShell,
+      })
 
       // Acquire/start the command and make sure we kill it on interruption.
-      const runningProcess = yield* Effect.acquireRelease(command.pipe(Command.start), (proc) =>
+      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+      const runningProcess = yield* Effect.acquireRelease(spawner.spawn(command), (proc) =>
         proc.isRunning.pipe(
           Effect.flatMap((running) =>
-            running === true ? proc.kill().pipe(Effect.catchAll(() => Effect.void)) : Effect.void,
+            running === true ? proc.kill().pipe(Effect.catch(() => Effect.void)) : Effect.void,
           ),
           Effect.ignore,
         ),
@@ -249,20 +261,20 @@ const runWithLogging = ({
       })
 
       const stdoutFiber = yield* runningProcess.stdout.pipe(
-        Stream.decodeText('utf8'),
+        Stream.decodeText({ encoding: 'utf8' }),
         Stream.runForEach((chunk) => stdoutHandler.onChunk(chunk)),
         Effect.forkScoped,
       )
 
       const stderrFiber = yield* runningProcess.stderr.pipe(
-        Stream.decodeText('utf8'),
+        Stream.decodeText({ encoding: 'utf8' }),
         Stream.runForEach((chunk) => stderrHandler.onChunk(chunk)),
         Effect.forkScoped,
       )
 
       // Dump any buffered data and finish both stream fibers before we return.
       const flushOutputs = Effect.gen(function* () {
-        const stillRunning = yield* runningProcess.isRunning.pipe(Effect.catchAll(() => Effect.succeed(false)))
+        const stillRunning = yield* runningProcess.isRunning.pipe(Effect.orElseSucceed(() => false))
         if (stillRunning === true) {
           yield* Effect.ignore(runningProcess.kill())
         }
@@ -278,18 +290,37 @@ const runWithLogging = ({
     }),
   )
 
-const buildCommand = (input: string | string[], useShell: boolean) => {
+type TBuildCommandOptions = {
+  readonly cwd: string
+  readonly env: Record<string, string | undefined>
+  readonly stdin?: ChildProcess.CommandInput
+  readonly stdout?: ChildProcess.CommandOutput
+  readonly stderr?: ChildProcess.CommandOutput
+  readonly shell: boolean
+}
+
+const buildCommand = (input: string | string[], options: TBuildCommandOptions): ChildProcess.Command => {
+  const commandOptions = {
+    cwd: options.cwd,
+    env: options.env,
+    extendEnv: true,
+    shell: options.shell,
+    ...(options.stdin !== undefined ? { stdin: options.stdin } : {}),
+    ...(options.stdout !== undefined ? { stdout: options.stdout } : {}),
+    ...(options.stderr !== undefined ? { stderr: options.stderr } : {}),
+  } as const
+
   if (Array.isArray(input) === true) {
     const [c, ...a] = input
-    return Command.make(c!, ...a)
+    return ChildProcess.make(c ?? '', a, commandOptions)
   }
 
-  if (useShell === true) {
-    return Command.make(input)
+  if (options.shell === true) {
+    return ChildProcess.make(input, commandOptions)
   }
 
   const [c, ...a] = input.split(' ')
-  return Command.make(c!, ...a)
+  return ChildProcess.make(c ?? '', a, commandOptions)
 }
 
 type TLineTerminator = 'newline' | 'carriage-return' | 'none'