@livestore/utils-dev 0.4.0-dev.2 → 0.4.0-dev.20

package/src/node/cmd-log.ts

@@ -0,0 +1,87 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { isNotUndefined } from '@livestore/utils'
+import { Effect } 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(() => fs.renameSync(currentLogPath, archivedLog)).pipe(
+        Effect.catchAll(() =>
+          Effect.try(() => {
+            fs.copyFileSync(currentLogPath, archivedLog)
+            fs.truncateSync(currentLogPath, 0)
+          }),
+        ),
+        Effect.ignore,
+      )
+
+      // Prune archives to retain only the newest N
+      yield* Effect.try(() => fs.readdirSync(archiveDir)).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(() => fs.unlinkSync(path.join(archiveDir, e.name))).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,130 @@
+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 { cmd } from './cmd.ts'
+import { CurrentWorkingDirectory } from './workspace.ts'
+
+const withNode = Vitest.makeWithTestCtx({
+  makeLayer: () => Layer.mergeAll(PlatformNode.NodeContext.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) =>
+    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)),
+  )
+})

package/src/node/cmd.ts

@@ -0,0 +1,420 @@
+import fs from 'node:fs'
+
+import { isNotUndefined } from '@livestore/utils'
+import {
+  Cause,
+  Command,
+  type CommandExecutor,
+  Effect,
+  Fiber,
+  FiberId,
+  FiberRefs,
+  HashMap,
+  identity,
+  List,
+  LogLevel,
+  type PlatformError,
+  Schema,
+  Stream,
+} from '@livestore/utils/effect'
+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
+
+export const cmd: (
+  commandInput: string | (string | undefined)[],
+  options?:
+    | {
+        stderr?: 'inherit' | 'pipe'
+        stdout?: 'inherit' | 'pipe'
+        shell?: boolean
+        env?: Record<string, string | undefined>
+        /**
+         * When provided, streams command output to terminal AND to a canonical log file (`${logDir}/dev.log`) in this directory.
+         * Also archives the previous run to `${logDir}/archive/dev-<ISO>.log` and keeps only the latest 50 archives.
+         */
+        logDir?: string
+        /** Optional basename for the canonical log file; defaults to 'dev.log' */
+        logFileName?: string
+        /** Optional number of archived logs to retain; defaults to 50 */
+        logRetention?: number
+      }
+    | undefined,
+) => Effect.Effect<
+  CommandExecutor.ExitCode,
+  PlatformError.PlatformError | CmdError,
+  CommandExecutor.CommandExecutor | CurrentWorkingDirectory
+> = Effect.fn('cmd')(function* (commandInput, options) {
+  const cwd = yield* CurrentWorkingDirectory
+
+  const asArray = Array.isArray(commandInput)
+  const parts = asArray ? (commandInput as (string | undefined)[]).filter(isNotUndefined) : undefined
+  const [command, ...args] = asArray ? (parts as string[]) : (commandInput as string).split(' ')
+
+  const debugEnvStr = Object.entries(options?.env ?? {})
+    .map(([key, value]) => `${key}='${value}' `)
+    .join('')
+
+  const loggingOpts = {
+    ...(options?.logDir ? { logDir: options.logDir } : {}),
+    ...(options?.logFileName ? { logFileName: options.logFileName } : {}),
+    ...(options?.logRetention ? { logRetention: options.logRetention } : {}),
+  } as const
+  const { input: finalInput, subshell: needsShell, logPath } = yield* applyLoggingToCommand(commandInput, loggingOpts)
+
+  const stdoutMode = options?.stdout ?? 'inherit'
+  const stderrMode = options?.stderr ?? 'inherit'
+  const useShell = (options?.shell ? true : false) || needsShell
+
+  const commandDebugStr =
+    debugEnvStr + (Array.isArray(finalInput) ? (finalInput as string[]).join(' ') : (finalInput as string))
+  const subshellStr = useShell ? ' (in subshell)' : ''
+
+  yield* Effect.logDebug(`Running '${commandDebugStr}' in '${cwd}'${subshellStr}`)
+  yield* Effect.annotateCurrentSpan({
+    'span.label': commandDebugStr,
+    cwd,
+    command,
+    args,
+    logDir: options?.logDir,
+  })
+
+  const baseArgs = {
+    commandInput: finalInput,
+    cwd,
+    env: options?.env ?? {},
+    stdoutMode,
+    stderrMode,
+    useShell,
+  } as const
+
+  const exitCode = yield* isNotUndefined(logPath)
+    ? Effect.gen(function* () {
+        yield* Effect.sync(() => console.log(`Logging output to ${logPath}`))
+        return yield* runWithLogging({ ...baseArgs, logPath, threadName: commandDebugStr })
+      })
+    : runWithoutLogging(baseArgs)
+
+  if (exitCode !== SUCCESS_EXIT_CODE) {
+    return yield* Effect.fail(
+      CmdError.make({
+        command: command!,
+        args,
+        cwd,
+        env: options?.env ?? {},
+        stderr: stderrMode,
+      }),
+    )
+  }
+
+  return exitCode
+})
+
+export const cmdText: (
+  commandInput: string | (string | undefined)[],
+  options?: {
+    stderr?: 'inherit' | 'pipe'
+    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)
+      ? commandInput.filter(isNotUndefined)
+      : commandInput.split(' ')
+    const debugEnvStr = Object.entries(options?.env ?? {})
+      .map(([key, value]) => `${key}='${value}' `)
+      .join('')
+
+    const commandDebugStr = debugEnvStr + [command, ...args].join(' ')
+    const subshellStr = options?.runInShell ? ' (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 ? Command.runInShell(true) : identity,
+      Command.env(options?.env ?? {}),
+      Command.string,
+    )
+  })
+
+export class CmdError extends Schema.TaggedError<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'),
+}) {}
+
+type TRunBaseArgs = {
+  readonly commandInput: string | string[]
+  readonly cwd: string
+  readonly env: Record<string, string | undefined>
+  readonly stdoutMode: 'inherit' | 'pipe'
+  readonly stderrMode: 'inherit' | 'pipe'
+  readonly useShell: boolean
+}
+
+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 ? Command.runInShell(true) : identity,
+    Command.env(env),
+    Command.exitCode,
+  )
+
+type TRunWithLoggingArgs = TRunBaseArgs & {
+  readonly logPath: string
+  readonly threadName: string
+}
+
+const runWithLogging = ({
+  commandInput,
+  cwd,
+  env,
+  stdoutMode,
+  stderrMode,
+  useShell,
+  logPath,
+  threadName,
+}: TRunWithLoggingArgs) =>
+  // When logging is enabled we have to replace the `2>&1 | tee` pipeline the
+  // shell used to give us. We now pipe both streams through Effect so we can
+  // mirror to the terminal (only when requested) and append formatted entries
+  // into the canonical log ourselves.
+  Effect.scoped(
+    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({
+        colors: true,
+        stderr: false,
+        formatDate: (date) => `${FileLogger.defaultDateFormat(date)} ${threadName}`,
+      })
+
+      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,
+            message: [`[${channel}]${content.length > 0 ? ` ${content}` : ''}`],
+            cause: Cause.empty,
+            context: FiberRefs.empty(),
+            spans: List.empty(),
+            annotations: HashMap.empty(),
+            date: new Date(),
+          })
+          fs.writeSync(logFile, formatted)
+        })
+
+      const command = buildCommand(commandInput, useShell).pipe(
+        Command.stdin('inherit'),
+        Command.stdout('pipe'),
+        Command.stderr('pipe'),
+        Command.workingDirectory(cwd),
+        useShell ? Command.runInShell(true) : identity,
+        Command.env(envWithColor),
+      )
+
+      // Acquire/start the command and make sure we kill it on interruption.
+      const runningProcess = yield* Effect.acquireRelease(command.pipe(Command.start), (proc) =>
+        proc.isRunning.pipe(
+          Effect.flatMap((running) => (running ? proc.kill().pipe(Effect.catchAll(() => Effect.void)) : Effect.void)),
+          Effect.ignore,
+        ),
+      )
+
+      const stdoutHandler = makeStreamHandler({
+        channel: 'stdout',
+        ...(stdoutMode === 'inherit' ? { mirrorTarget: process.stdout } : {}),
+        appendLog,
+      })
+      const stderrHandler = makeStreamHandler({
+        channel: 'stderr',
+        ...(stderrMode === 'inherit' ? { mirrorTarget: process.stderr } : {}),
+        appendLog,
+      })
+
+      const stdoutFiber = yield* runningProcess.stdout.pipe(
+        Stream.decodeText('utf8'),
+        Stream.runForEach((chunk) => stdoutHandler.onChunk(chunk)),
+        Effect.forkScoped,
+      )
+
+      const stderrFiber = yield* runningProcess.stderr.pipe(
+        Stream.decodeText('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)))
+        if (stillRunning) {
+          yield* Effect.ignore(runningProcess.kill())
+        }
+        yield* Effect.ignore(Fiber.join(stdoutFiber))
+        yield* Effect.ignore(Fiber.join(stderrFiber))
+        yield* stdoutHandler.flush()
+        yield* stderrHandler.flush()
+      })
+
+      const exitCode = yield* runningProcess.exitCode.pipe(Effect.ensuring(flushOutputs))
+
+      return exitCode
+    }),
+  )
+
+const buildCommand = (input: string | string[], useShell: boolean) => {
+  if (Array.isArray(input)) {
+    const [c, ...a] = input
+    return Command.make(c!, ...a)
+  }
+
+  if (useShell) {
+    return Command.make(input)
+  }
+
+  const [c, ...a] = input.split(' ')
+  return Command.make(c!, ...a)
+}
+
+type TLineTerminator = 'newline' | 'carriage-return' | 'none'
+
+type TStreamHandler = {
+  readonly onChunk: (chunk: string) => Effect.Effect<void, never>
+  readonly flush: () => Effect.Effect<void, never>
+}
+
+const makeStreamHandler = ({
+  channel,
+  mirrorTarget,
+  appendLog,
+}: {
+  readonly channel: 'stdout' | 'stderr'
+  readonly mirrorTarget?: NodeJS.WriteStream
+  readonly appendLog: (args: { channel: 'stdout' | 'stderr'; content: string }) => Effect.Effect<void, never>
+}): TStreamHandler => {
+  let buffer = ''
+
+  // Effect's FileLogger expects line-oriented messages, but the subprocess
+  // gives us arbitrary UTF-8 chunks. We keep a tiny line splitter here so the
+  // log and console stay readable (and consistent with the previous `tee`
+  // behaviour).
+  const emit = (content: string, terminator: TLineTerminator) =>
+    emitSegment({
+      channel,
+      content,
+      terminator,
+      ...(mirrorTarget ? { mirrorTarget } : {}),
+      appendLog,
+    })
+
+  const consumeBuffer = (): Effect.Effect<void, never> => {
+    if (buffer.length === 0) return Effect.void
+
+    const lastChar = buffer[buffer.length - 1]
+    if (lastChar === '\r') {
+      const line = buffer.slice(0, -1)
+      buffer = ''
+      return emit(line, 'carriage-return')
+    }
+
+    const line = buffer
+    buffer = ''
+    return line.length === 0 ? Effect.void : emit(line, 'none')
+  }
+
+  return {
+    onChunk: (chunk) =>
+      Effect.gen(function* () {
+        buffer += chunk
+        while (buffer.length > 0) {
+          const newlineIndex = buffer.indexOf('\n')
+          const carriageIndex = buffer.indexOf('\r')
+
+          if (newlineIndex === -1 && carriageIndex === -1) {
+            break
+          }
+
+          let index: number
+          let terminator: TLineTerminator
+          let skip = 1
+
+          if (carriageIndex !== -1 && (newlineIndex === -1 || carriageIndex < newlineIndex)) {
+            index = carriageIndex
+            if (carriageIndex + 1 < buffer.length && buffer[carriageIndex + 1] === '\n') {
+              skip = 2
+              terminator = 'newline'
+            } else {
+              terminator = 'carriage-return'
+            }
+          } else {
+            index = newlineIndex!
+            terminator = 'newline'
+          }
+
+          const line = buffer.slice(0, index)
+          buffer = buffer.slice(index + skip)
+          yield* emit(line, terminator)
+        }
+      }),
+    flush: () => consumeBuffer(),
+  }
+}
+
+const emitSegment = ({
+  channel,
+  content,
+  terminator,
+  mirrorTarget,
+  appendLog,
+}: {
+  readonly channel: 'stdout' | 'stderr'
+  readonly content: string
+  readonly terminator: TLineTerminator
+  readonly mirrorTarget?: NodeJS.WriteStream
+  readonly appendLog: (args: { channel: 'stdout' | 'stderr'; content: string }) => Effect.Effect<void, never>
+}) =>
+  Effect.gen(function* () {
+    if (mirrorTarget) {
+      yield* Effect.sync(() => mirrorSegment(mirrorTarget, content, terminator))
+    }
+
+    const contentForLog = terminator === 'carriage-return' ? `${content}\r` : content
+
+    yield* appendLog({ channel, content: contentForLog })
+  })
+
+const mirrorSegment = (target: NodeJS.WriteStream, content: string, terminator: TLineTerminator) => {
+  switch (terminator) {
+    case 'newline': {
+      target.write(`${content}\n`)
+      break
+    }
+    case 'carriage-return': {
+      target.write(`${content}\r`)
+      break
+    }
+    case 'none': {
+      target.write(content)
+      break
+    }
+  }
+}