diff options
Diffstat (limited to 'src/commands/tail.js')
| -rw-r--r-- | src/commands/tail.js | 597 |
1 files changed, 597 insertions, 0 deletions
diff --git a/src/commands/tail.js b/src/commands/tail.js new file mode 100644 index 0000000..6934d4d --- /dev/null +++ b/src/commands/tail.js @@ -0,0 +1,597 @@ +#!/usr/bin/env bun + +import { closeSync, existsSync, constants as fsConstants, fstatSync, openSync, readSync } from "node:fs"; +import { lstat, open, stat, writeFile } from "node:fs/promises"; +import { dirname as pathDirname } from "node:path"; +import { SEEK_SET, cstrPath, headTailDiagnosticName, isWriteError, libc, localeQuotedDiagnostic, localeQuotedEscapedDiagnostic, nodeErrorMessage, normalizeLongOptionByPrefix, normalizeLongOptionsByPrefix, parseOptions, pathLikeJoin, readAll, readFdChunkViews, readdirPathEntries, systemErrorMessage } from "../shared/common.js"; +import { UsageError, stderr, stdout } from "../shared/diagnostics.js"; +import { headTailHeaderMode, headTailShouldPrintHeader, isTailStreamingDevice, normalizeHeadTailArgs, parseByteCount, splitDelimitedByteRecords, tailFirstBytes } from "../shared/head-tail.js"; +import { POLLERR, POLLHUP, POLLNVAL, POLLOUT, pollFd, readStdinChunks } from "../shared/text.js"; +import { defineCommand, runAsMain } from "../shared/command.js"; + +export const SEEK_END = 2; + +export const POLLIN = 0x001; + +export const IN_MODIFY = 0x00000002; + +export const IN_ATTRIB = 0x00000004; + +export const IN_CLOSE_WRITE = 0x00000008; + +export const IN_MOVED_FROM = 0x00000040; + +export const IN_MOVED_TO = 0x00000080; + +export const IN_CREATE = 0x00000100; + +export const IN_DELETE = 0x00000200; + +export const IN_DELETE_SELF = 0x00000400; + +export const IN_MOVE_SELF = 0x00000800; + +export const TAIL_LONG_OPTIONS = ["bytes", "debug", "follow", "lines", "max-unchanged-stats", "pid", "quiet", "retry", "silent", "sleep-interval", "verbose", "zero-terminated", "help", "version"]; + +export function tailMetaOption(args) { + const longValueOptions = new Set(["bytes", "lines", "sleep-interval", "max-unchanged-stats", "pid"]); + const longOptionalValueOptions = new Set(["follow"]); + const shortValueOptions = new Set(["c", "n", "s"]); + const shortKnownOptions = new Set(["c", "n", "q", "v", "z", "f", "F", "s"]); + for (let i = 0; i < args.length; i++) { + const arg = args[i]; + if (arg === "--") return null; + if (arg.startsWith("--")) { + const option = normalizeTailLongOption(arg); + const [name, inlineValue] = option.slice(2).split(/=(.*)/s, 2); + if (!TAIL_LONG_OPTIONS.includes(name) && name !== "-disable-inotify") return null; + if (name === "follow" && inlineValue != null && !["descriptor", "name"].includes(inlineValue)) return null; + if ((option === "--help" || option === "--version") && inlineValue == null) return option; + if (longValueOptions.has(name)) { + const value = inlineValue ?? args[i + 1]; + if (value !== undefined) { + if (name === "bytes") parseTailCount(value, 10, true); + if (name === "lines") parseTailCount(value, 10, false); + if (name === "sleep-interval") parseTailSleepInterval(value); + if (name === "pid" && !/^\d*$/.test(value)) throw new UsageError(`invalid PID: ${localeQuotedEscapedDiagnostic(value)}`); + } + if (inlineValue == null) i++; + } + else if (inlineValue == null && longOptionalValueOptions.has(name)) continue; + continue; + } + if (!arg.startsWith("-") || arg === "-") continue; + if (/^-\d/.test(arg) || /^\+\d/.test(arg)) continue; + for (let j = 1; j < arg.length; j++) { + const ch = arg[j]; + if (!shortKnownOptions.has(ch)) return null; + if (shortValueOptions.has(ch)) { + const inlineValue = arg.slice(j + 1); + const value = inlineValue === "" ? args[i + 1] : inlineValue; + if (value !== undefined) { + if (ch === "s") parseTailSleepInterval(value); + else parseTailCount(value, 10, ch === "c"); + } + if (inlineValue === "") i++; + break; + } + } + } + return null; +} + +export async function tail(args) { + args = normalizeHeadTailArgs(normalizeTailLongOptions(args), "tail"); + const pidList = tailPidList(args); + const headerMode = headTailHeaderMode(args); + const { opts, operands } = parseOptions(args, { short: { n: "value", c: "value", q: false, v: false, z: false, f: false, F: false, s: "value" }, long: { lines: "value", bytes: "value", quiet: false, silent: false, verbose: false, "zero-terminated": false, follow: "optional-value", sleep: "value", "sleep-interval": "value", "max-unchanged-stats": "value", pid: "value", retry: false, debug: false, "-disable-inotify": false, help: false, version: false } }); + const files = operands.length ? operands : ["-"]; + const bytesMode = opts.c ?? opts.bytes; + const count = parseTailCount(bytesMode ?? opts.n ?? opts.lines, 10, bytesMode != null); + const rawCount = String(bytesMode ?? opts.n ?? opts.lines ?? ""); + const delimiter = opts.z || opts["zero-terminated"] ? "\0" : "\n"; + const follow = opts.f || opts.F || opts.follow != null; + const followMode = opts.F ? "name" : opts.follow === true ? "descriptor" : opts.follow ?? (opts.f ? "descriptor" : null); + if (followMode != null && !["descriptor", "name"].includes(followMode)) { + const kind = followMode === "" ? "ambiguous" : "invalid"; + throw new UsageError(`${kind} argument ${localeQuotedDiagnostic(followMode)} for ${localeQuotedDiagnostic("--follow")}\nValid arguments are:\n - ${localeQuotedDiagnostic("descriptor")}\n - ${localeQuotedDiagnostic("name")}`, true); + } + const followByName = followMode === "name"; + const retryInitialOpen = opts.retry || opts.F; + const sleepInterval = parseTailSleepInterval(opts.s ?? opts.sleep ?? opts["sleep-interval"]); + parseTailMaxUnchangedStats(opts["max-unchanged-stats"]); + if (opts.retry && !follow) stderr("tail: warning: --retry ignored; --retry is useful only when following\n"); + if (follow && files.includes("-") && process.env.BNU_STDIN_CLOSED === "1") { + stderr("tail: cannot fstat 'standard input'\n"); + stderr("tail: no files remaining\n"); + return 1; + } + if (count === 0 && !follow && !rawCount.startsWith("+")) return 0; + const followOffsets = new Map(); + const followIdentities = new Map(); + const followInaccessible = new Map(); + const followFiles = []; + let followHasNonRegular = false; + let renderedAnyFile = false; + let lastOutputFile = null; + let failed = false; + for (let i = 0; i < files.length; i++) { + const file = files[i]; + const header = headTailShouldPrintHeader(headerMode, files.length) ? `${renderedAnyFile ? "\n" : ""}==> ${tailDisplayName(file)} <==\n` : ""; + const rawBytes = bytesMode == null ? "" : String(bytesMode); + if (!follow && file === "-" && bytesMode != null && rawBytes.startsWith("+")) { + if (header) stdout(header); + let skip = Math.max(0, tailStartOffset(count)); + readStdinChunks((chunk) => { + if (skip >= chunk.length) { + skip -= chunk.length; + return; + } + stdout(skip > 0 ? chunk.slice(skip) : chunk); + skip = 0; + }); + renderedAnyFile = true; + continue; + } + if (!follow && file === "-" && bytesMode == null && rawCount.startsWith("+")) { + if (header) stdout(header); + readTailFdFromRecord(0, count, delimiter); + renderedAnyFile = true; + continue; + } + if (!follow && file !== "-" && bytesMode == null && rawCount.startsWith("+") && await isTailStreamingDevice(file)) { + if (header) stdout(header); + let fd; + try { + fd = openSync(file, "r"); + readTailFdFromRecord(fd, count, delimiter); + renderedAnyFile = true; + } catch (error) { + if (isWriteError(error)) throw error; + stderr(`tail: error reading ${headTailDiagnosticName(file)}: ${systemErrorMessage(error)}\n`); + failed = true; + } finally { + if (fd != null) closeSync(fd); + } + continue; + } + if (bytesMode != null && file !== "-" && await isTailBlockDevice(file)) { + if (header) stdout(header); + try { + await tailBlockDeviceBytes(file, count, rawBytes.startsWith("+")); + } catch (error) { + stderr(`tail: error reading ${headTailDiagnosticName(file)}: ${systemErrorMessage(error)}\n`); + failed = true; + } + continue; + } + if (bytesMode != null && file !== "-" && !rawBytes.startsWith("+") && await isTailStreamingDevice(file)) { + if (header) stdout(header); + try { + await tailFirstBytes(file, count); + } catch (error) { + stderr(`tail: error reading ${headTailDiagnosticName(file)}: ${systemErrorMessage(error)}\n`); + failed = true; + } + continue; + } + if (follow && file === "-") { + try { + fstatSync(0); + } catch { + stderr("tail: cannot fstat 'standard input'\n"); + failed = true; + continue; + } + } + const fileInfo = file === "-" ? null : await stat(file).catch(() => null); + if (follow && (!fileInfo || !fileInfo.isFile())) followHasNonRegular = true; + if (follow && pidList.length && fileInfo?.isFIFO?.()) { + followOffsets.set(file, 0); + followIdentities.set(file, await tailFollowIdentity(file, followByName)); + followFiles.push(file); + renderedAnyFile = true; + continue; + } + if (retryInitialOpen && fileInfo?.isDirectory()) { + stderr(`tail: cannot follow ${headTailDiagnosticName(file)}: Is a directory\n`); + // -F retries an initially untailable name. Report its inaccessible + // state now, rather than waiting for the first polling cycle: callers + // (and GNU's follow protocol) need both diagnostics before a rapid + // directory-to-file replacement can occur. + if (followByName) stderr(`tail: ${headTailDiagnosticName(file)} has become inaccessible: Is a directory\n`); + failed = true; + followFiles.push(file); + followOffsets.set(file, null); + followIdentities.set(file, await tailFollowIdentity(file, followByName)); + if (!followByName) followInaccessible.set(file, "Is a directory"); + continue; + } + let data; + try { + data = await readAll(file); + } catch (error) { + if (error?.code === "EISDIR") { + if (header) stdout(header); + renderedAnyFile = true; + stderr(`tail: error reading ${headTailDiagnosticName(file)}: ${systemErrorMessage(error)}\n`); + } else { + stderr(file === "-" ? `tail: ${nodeErrorMessage(error)}\n` : `tail: cannot open ${headTailDiagnosticName(file)} for reading: ${systemErrorMessage(error)}\n`); + } + failed = true; + if (retryInitialOpen && file !== "-") { + followFiles.push(file); + followOffsets.set(file, null); + followIdentities.set(file, null); + } + continue; + } + followOffsets.set(file, data.length); + followIdentities.set(file, await tailFollowIdentity(file, followByName)); + if (file !== "-") followFiles.push(file); + if (header) { + stdout(header); + lastOutputFile = file; + } + renderedAnyFile = true; + if (bytesMode != null) { + stdout(rawBytes.startsWith("+") ? data.slice(Math.max(0, tailStartOffset(count))) : data.slice(Math.max(0, data.length - count))); + } else { + const raw = String(opts.n ?? opts.lines ?? ""); + const lines = splitDelimitedByteRecords(data, delimiter); + stdout(raw.startsWith("+") ? Buffer.concat(lines.slice(Math.max(0, tailStartOffset(count)))) : count === 0 ? "" : Buffer.concat(lines.slice(-count))); + } + } + if (follow && followFiles.length) { + if (opts.retry && followMode === "descriptor") stderr("tail: warning: --retry only effective for the initial open\n"); + if (opts.debug) { + // Descriptor-following a device uses its blocking read semantics; + // regular files use inotify unless explicitly disabled, while + // name-following non-regular files must poll. + const mode = opts["-disable-inotify"] + ? "polling" + : followHasNonRegular + ? followByName ? "polling" : "blocking" + : "notification"; + stderr(`tail: using ${mode} mode\n`); + } + const followStatus = await followTailFiles(followFiles, followOffsets, { + followByName, + inotifyMode: !opts["-disable-inotify"], + retryInitialOpen, + identities: followIdentities, + inaccessible: followInaccessible, + interval: sleepInterval, + headers: (opts.v || opts.verbose || files.length > 1) && !(opts.q || opts.quiet || opts.silent), + lastOutputFile, + pids: pidList, + }); + if (followStatus !== 0) return followStatus; + } else if (follow && failed) { + stderr("tail: no files remaining\n"); + } + return failed ? 1 : 0; +} + +export async function followTailFiles(files, offsets, options) { + const removedParentDirs = new Set(); + const inotify = options.inotifyMode ? tailInotifyOpen(files, options.followByName) : null; + if (!inotify) options.inotifyMode = false; + await tailTestPauseBeforeInotifyScan(); + try { + while (true) { + if (options.pids?.length && !options.pids.some(tailPidAlive)) return 0; + if (pollFd(1, POLLOUT) & (POLLERR | POLLHUP | POLLNVAL)) return 0; + const iterationFiles = inotify?.pendingFiles?.length ? inotify.pendingFiles.splice(0) : files; + for (const file of iterationFiles) { + let actualFile = file; + let identity = await tailFollowIdentity(file, options.followByName); + let s = await stat(file).catch(() => null); + if (!s && !options.followByName && options.identities?.get(file) != null) { + actualFile = await findTailMovedPath(file, options.identities.get(file)) ?? file; + if (actualFile !== file) { + identity = await tailFollowIdentity(actualFile, false); + s = await stat(actualFile).catch(() => null); + } + } + tailInotifyUpdateFile(inotify, file, s, identity); + if (!s || s.isDirectory()) { + if (offsets.get(file) === null && s?.isDirectory() && !options.followByName) { + stderr(`tail: ${headTailDiagnosticName(file)} has been replaced with an untailable file\n`); + stderr("tail: no files remaining\n"); + return 1; + } + if (options.followByName && options.identities?.get(file) != null && offsets.get(file) !== null) { + stderr(`tail: ${headTailDiagnosticName(file)} has become inaccessible: ${s?.isDirectory() ? "Is a directory" : "No such file or directory"}\n`); + if (options.inotifyMode && !s && !removedParentDirs.has(pathDirname(String(file))) && !(await lstat(pathDirname(String(file))).catch(() => null))) { + removedParentDirs.add(pathDirname(String(file))); + stderr("tail: directory containing watched file was removed\n"); + stderr("tail: inotify cannot be used, reverting to polling\n"); + } + if (!s && !options.retryInitialOpen && await findTailMovedPath(file, options.identities.get(file))) { + stderr("tail: no files remaining\n"); + return 1; + } + offsets.set(file, null); + options.identities.set(file, null); + } else if (options.followByName && offsets.get(file) === null && s?.isDirectory() && options.inaccessible?.has(file)) { + stderr(`tail: ${headTailDiagnosticName(file)} has become inaccessible: ${options.inaccessible.get(file)}\n`); + options.inaccessible.delete(file); + } + continue; + } + let offset = offsets.has(file) ? offsets.get(file) : 0; + const previousIdentity = options.identities?.get(file); + if (offset === null) { + if (options.inaccessible?.has(file)) { + stderr(`tail: ${headTailDiagnosticName(file)} has become inaccessible: ${options.inaccessible.get(file)}\n`); + options.inaccessible.delete(file); + } + stderr(`tail: ${headTailDiagnosticName(file)} has appeared; following new file\n`); + offset = 0; + } else if (options.followByName && previousIdentity != null && identity != null && previousIdentity !== identity) { + stderr(`tail: ${headTailDiagnosticName(file)} has been replaced; following new file\n`); + offset = 0; + } else if (s.size < offset) { + stderr(`tail: ${headTailDiagnosticName(file)}: file truncated\n`); + offset = 0; + } + if (s.size <= offset) { + offsets.set(file, offset); + if (identity != null) options.identities?.set(file, identity); + continue; + } + if (options.headers && options.lastOutputFile !== file) { + stdout(`${options.lastOutputFile == null ? "" : "\n"}==> ${tailDisplayName(file)} <==\n`); + options.lastOutputFile = file; + } + await writeFileRange(actualFile, offset, s.size - offset); + offsets.set(file, s.size); + if (identity != null) options.identities?.set(file, identity); + } + if (inotify) tailInotifyWait(inotify, options.interval); + else await Bun.sleep(options.interval); + } + } finally { + tailInotifyClose(inotify); + } +} + +export async function tailTestPauseBeforeInotifyScan() { + const ready = process.env.BNU_TAIL_INOTIFY_READY_FILE; + const proceed = process.env.BNU_TAIL_INOTIFY_CONTINUE_FILE; + if (!ready || !proceed) return; + await writeFile(ready, "ready\n"); + const deadline = Date.now() + 30_000; + while (!existsSync(proceed)) { + if (Date.now() >= deadline) throw new Error("timed out waiting for the inotify race test continuation marker"); + await Bun.sleep(10); + } +} + +export function tailInotifyOpen(files, followByName) { + let fd; + try { + fd = libc.symbols.inotify_init1(fsConstants.O_NONBLOCK | fsConstants.O_CLOEXEC); + } catch { + return null; + } + if (fd < 0) return null; + const state = { fd, files: new Map(), parents: new Map(), pendingFiles: [] }; + if (followByName) { + for (const file of files) { + const parent = pathDirname(String(file)); + if (state.parents.has(parent)) continue; + const wd = libc.symbols.inotify_add_watch(fd, cstrPath(parent), IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO | IN_ATTRIB); + if (wd >= 0) state.parents.set(parent, wd); + } + } + return state; +} + +export function tailInotifyUpdateFile(state, file, statInfo, identity) { + if (!state) return; + const current = state.files.get(file); + const watchable = statInfo && (statInfo.isFile() || statInfo.isFIFO()); + if (current && (!watchable || current.identity !== identity)) { + libc.symbols.inotify_rm_watch(state.fd, current.wd); + state.files.delete(file); + } + if (!watchable || state.files.has(file)) return; + const wd = libc.symbols.inotify_add_watch(state.fd, cstrPath(file), IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE | IN_DELETE_SELF | IN_MOVE_SELF); + if (wd >= 0) state.files.set(file, { wd, identity }); +} + +export function tailInotifyWait(state, timeout) { + if (!(pollFd(state.fd, POLLIN, timeout) & POLLIN)) return; + const events = Buffer.allocUnsafe(64 * 1024); + try { + const bytesRead = readSync(state.fd, events, 0, events.length, null); + for (let offset = 0; offset + 16 <= bytesRead;) { + const wd = events.readInt32LE(offset); + const nameLength = events.readUInt32LE(offset + 12); + for (const [file, watch] of state.files) { + if (watch.wd === wd && state.pendingFiles.at(-1) !== file) { + state.pendingFiles.push(file); + break; + } + } + offset += 16 + nameLength; + } + } catch (error) { + if (error?.code !== "EAGAIN") throw error; + } +} + +export function tailInotifyClose(state) { + if (!state) return; + for (const { wd } of state.files.values()) libc.symbols.inotify_rm_watch(state.fd, wd); + for (const wd of state.parents.values()) libc.symbols.inotify_rm_watch(state.fd, wd); + closeSync(state.fd); +} + +export function tailPidList(args) { + const pids = []; + for (let i = 0; i < args.length; i++) { + const arg = args[i]; + let value = null; + if (arg === "--pid") value = args[++i]; + else if (arg.startsWith("--pid=")) value = arg.slice("--pid=".length); + if (value == null) continue; + if (value === "") { + pids.push(0); + continue; + } + if (!/^\d+$/.test(value)) throw new UsageError(`invalid PID: ${localeQuotedEscapedDiagnostic(value)}`); + pids.push(Number(value)); + } + return pids; +} + +export function normalizeTailLongOptions(args) { + return normalizeLongOptionsByPrefix(args, TAIL_LONG_OPTIONS); +} + +export function normalizeTailLongOption(arg) { + return normalizeLongOptionByPrefix(arg, TAIL_LONG_OPTIONS); +} + +export function tailPidAlive(pid) { + if (!Number.isSafeInteger(pid) || pid <= 0) return false; + try { + process.kill(pid, 0); + return true; + } catch { + return false; + } +} + +export function tailDisplayName(file) { + return file === "-" ? "standard input" : file; +} + +export async function tailFollowIdentity(file, followByName = true) { + const s = await (followByName ? lstat(file) : stat(file)).catch(() => null); + return s ? `${s.dev}:${s.ino}` : null; +} + +export async function findTailMovedPath(file, identity) { + const dir = pathDirname(String(file)); + for (const entry of await readdirPathEntries(dir).catch(() => [])) { + const candidate = pathLikeJoin(dir, entry); + if (candidate === file) continue; + if (await tailFollowIdentity(candidate, false) === identity) return candidate; + } + return null; +} + +export async function writeFileRange(file, offset, length) { + const handle = await open(file, "r"); + const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, length)); + let position = offset; + let remaining = length; + try { + while (remaining > 0) { + const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, remaining), position); + if (bytesRead === 0) break; + stdout(buffer.subarray(0, bytesRead)); + position += bytesRead; + remaining -= bytesRead; + } + } finally { + await handle.close().catch(() => {}); + } +} + +export function parseTailSleepInterval(value) { + if (value == null || value === true) return 1000; + const seconds = Number(value); + if (!Number.isFinite(seconds) || seconds < 0) throw new UsageError(`invalid number of seconds: ${localeQuotedEscapedDiagnostic(value)}`); + return Math.max(1, Math.trunc(seconds * 1000)); +} + +export function parseTailMaxUnchangedStats(value) { + if (value == null) return null; + const text = String(value); + if (!/^\d+$/.test(text)) throw new UsageError(`invalid maximum number of unchanged stats between opens: ${localeQuotedEscapedDiagnostic(text)}`); + return Number(text); +} + +export async function isTailBlockDevice(file) { + const s = await stat(file).catch(() => null); + return Boolean(s?.isBlockDevice?.()); +} + +export async function tailBlockDeviceBytes(file, count, fromStart) { + const handle = await open(file, "r"); + try { + const end = libc.symbols.lseek(handle.fd, 0n, SEEK_END); + if (end < 0n) throw new Error("cannot seek to end of device"); + const requested = BigInt(Math.max(0, count)); + const start = fromStart + ? BigInt(Math.max(0, tailStartOffset(count))) + : end > requested ? end - requested : 0n; + const boundedStart = start > end ? end : start; + if (libc.symbols.lseek(handle.fd, boundedStart, SEEK_SET) < 0n) throw new Error("cannot seek on device"); + let remaining = end - boundedStart; + const buffer = Buffer.allocUnsafe(Number(remaining > 64n * 1024n ? 64n * 1024n : remaining || 1n)); + while (remaining > 0n) { + const wanted = Number(remaining > BigInt(buffer.length) ? BigInt(buffer.length) : remaining); + const { bytesRead } = await handle.read(buffer, 0, wanted, null); + if (bytesRead === 0) break; + stdout(buffer.subarray(0, bytesRead)); + remaining -= BigInt(bytesRead); + } + } finally { + await handle.close().catch(() => {}); + } +} + +export function parseTailCount(value, defaultValue, bytesMode) { + if (value == null) return defaultValue; + const text = String(value); + const countText = text.replace(/^[+-]/, ""); + let count; + try { + count = parseByteCount(countText); + } catch (error) { + if (error instanceof UsageError) throw new UsageError(`invalid number of ${bytesMode ? "bytes" : "lines"}: ${localeQuotedEscapedDiagnostic(countText)}`); + throw error; + } + if (!Number.isFinite(count) || count < 0) throw new UsageError(`invalid number of ${bytesMode ? "bytes" : "lines"}: ${localeQuotedEscapedDiagnostic(countText)}`); + return Math.trunc(count); +} + +export function tailStartOffset(count) { + return Math.max(0, count - 1); +} + +export function readTailFdFromRecord(fd, count, delimiter) { + const targetRecord = tailStartOffset(count); + const sep = delimiter.charCodeAt(0); + let seen = 0; + let emitting = targetRecord === 0; + readFdChunkViews(fd, (chunk) => { + if (emitting) { + stdout(chunk); + return; + } + let offset = 0; + while (offset < chunk.length) { + if (chunk[offset] === sep) { + seen++; + if (seen >= targetRecord) { + stdout(chunk.subarray(offset + 1)); + emitting = true; + return; + } + } + offset++; + } + }); +} + +const singleCall = defineCommand("tail", tail, tailMetaOption); +export default singleCall; + +if (import.meta.main) await runAsMain(singleCall); |
