@kaynooo/cli-docker 0.2.0 → 0.4.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@kaynooo/cli-docker",
   "type": "module",
-  "version": "0.2.0",
-  "description": "dc and dx: docker compose on the stack found here, including one only its containers tell of, and a compose service's shell, logs, restart, stop or rebuild.",
+  "version": "0.4.0",
+  "description": "dc, dx, dlog and sf: docker compose on the stack found here, including one only its containers tell of, a compose service's shell, logs, restart, stop or rebuild, every service's health and recent errors in one call, and a Symfony console command picked and run.",
   "author": "Kaynooo <contact@kaynooo.fr>",
   "license": "MIT",
   "homepage": "https://git.kaynooo.fr/kaynooo/cli/src/branch/main/packages/docker#readme",
@@ -18,7 +18,9 @@
   },
   "bin": {
     "dc": "./dist/dc-cli.js",
-    "dx": "./dist/dx-cli.js"
+    "dlog": "./dist/dlog-cli.js",
+    "dx": "./dist/dx-cli.js",
+    "sf": "./dist/sf-cli.js"
   },
   "files": ["dist", "src"],
   "engines": {
@@ -28,11 +30,14 @@
     "registry": "https://git.kaynooo.fr/api/packages/kaynooo/npm/"
   },
   "scripts": {
-    "build": "$npm_execpath build src/dc-cli.ts src/dx-cli.ts --target bun --outdir dist",
+    "build": "$npm_execpath build src/dc-cli.ts src/dlog-cli.ts src/dx-cli.ts src/sf-cli.ts --target bun --outdir dist",
     "dc": "$npm_execpath src/dc-cli.ts",
-    "dx": "$npm_execpath src/dx-cli.ts"
+    "dlog": "$npm_execpath src/dlog-cli.ts",
+    "dx": "$npm_execpath src/dx-cli.ts",
+    "sf": "$npm_execpath src/sf-cli.ts"
   },
   "devDependencies": {
+    "@kaynooo/cli-env": "0.8.1",
     "@kaynooo/cli-kit": "0.20.0"
   }
 }

package/src/dlog-cli.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env bun
+
+import process from 'node:process'
+import { runMain } from '@kaynooo/cli-kit'
+import { version } from '../package.json'
+import { dlog } from './dlog'
+
+process.exitCode = await runMain({ name: 'dlog', version, run: dlog })

package/src/dlog.ts

@@ -0,0 +1,179 @@
+import type { Container, Service } from './stack'
+import process from 'node:process'
+import { maskLine, PEM_BEGIN, PEM_END } from '@kaynooo/cli-env/mask'
+import { fail, jsonOption, paint, parse, printJson, stripAnsi } from '@kaynooo/cli-kit'
+import { allServices, attempt, containers, key, stateColor } from './stack'
+
+const usage = `dlog [service...]
+
+One line per compose service with its state and health, then the last distinct error lines of the services that log some or are not healthy, repeats collapsed to one line with a count and secrets masked as redact does.
+With service names, only those are read. The stacks are the ones dx lists: this folder's, its child folders' and the ones only their containers tell of.
+
+Exits 0 when every service is up and quiet, 1 when one is down, unhealthy or still starting, logged an error or has logs compose could not read, so it can gate a script, 1 too when there is no compose service here. A service that exited with code 0 (a migration, an init) is not down.`
+
+const options = {
+  lines: { type: 'string', short: 'n', default: '5', description: 'error lines kept per service' },
+  since: { type: 'string', default: '1h', description: 'how far back the logs are read (compose --since: 30m, 2h, a timestamp)' },
+  all: { type: 'boolean', short: 'a', description: 'the last log lines of a service with no error too' },
+  json: jsonOption('[{ key, state, health, status, errors: [{ line, count }], tail }]'),
+} as const
+
+const ERROR = /\b(?:error|err|fatal|exception|panic|critical|crit|traceback|failed|failure|refused|denied|timeout|timed out|oom|killed)\b/i
+const TAIL = 500
+const MAX_WIDTH = 220
+const TIMESTAMP = /\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:[.,]\d+)?(?:Z|[+-]\d{2}:?\d{2})?|\d{2}[/-][A-Za-z]{3}[/-]\d{4}:\d{2}:\d{2}:\d{2}(?: [+-]\d{4})?|\d{2}:\d{2}:\d{2}(?:[.,]\d+)?/g
+const IDENTIFIER = /\b(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|0x[0-9a-f]+|[0-9a-f]{12,})\b/gi
+const NUMBER = /\d+/g
+const STATUS_HEALTH = /\((healthy|unhealthy|health: starting)\)/
+const LEADING_BRACKETS = /^(?:\[\s*\]|\s)+/
+
+export interface ErrorLine {
+  line: string
+  count: number
+}
+
+/** The line two occurrences of the same message share: no timestamp, id or number. */
+function shape(line: string): string {
+  return line.replace(TIMESTAMP, '').replace(IDENTIFIER, '#').replace(NUMBER, '#').replace(LEADING_BRACKETS, '').trim()
+}
+
+function clip(line: string): string {
+  return line.length > MAX_WIDTH ? `${line.slice(0, MAX_WIDTH - 1)}…` : line
+}
+
+/** The last `limit` distinct error lines of a log, oldest first, each as its latest occurrence with how often its message came up, secrets masked. */
+export function errorLines(log: string, limit: number): ErrorLine[] {
+  const seen = new Map<string, ErrorLine>()
+
+  for (const raw of log.split('\n')) {
+    const line = stripAnsi(raw).trim()
+
+    if (line === '' || !ERROR.test(line))
+      continue
+
+    const shared = shape(line)
+    const before = seen.get(shared)
+
+    // Re-inserted so the Map's order is the order of the latest occurrences.
+    seen.delete(shared)
+    seen.set(shared, { line: clip(maskLine(line)), count: (before?.count ?? 0) + 1 })
+  }
+
+  return [...seen.values()].slice(-limit)
+}
+
+export interface Health {
+  /** `healthy`, `unhealthy`, `starting`, or empty when the container has no healthcheck. */
+  health: string
+  /** Whether the service is up and, when it has a healthcheck, healthy. */
+  fine: boolean
+}
+
+export function healthOf(state: string, container: Container | undefined): Health {
+  const health = (container?.Health ?? '') || (STATUS_HEALTH.exec(container?.Status ?? '')?.[1]?.replace('health: ', '') ?? '')
+  const finished = state === 'exited' && container?.ExitCode === 0
+
+  return { health, fine: (state === 'running' || finished) && (health === '' || health === 'healthy') }
+}
+
+export interface Report {
+  key: string
+  state: string
+  health: string
+  status: string
+  errors: ErrorLine[]
+  tail: string[]
+  /** Why compose could not list the service or read its logs. */
+  unreadable: string | undefined
+  fine: boolean
+}
+
+async function read(service: Service, since: string): Promise<{ log: string, container: Container | undefined, unreadable: string | undefined }> {
+  const [ps, logs] = await Promise.all([
+    attempt(service.stack, ['ps', '--all', '--format', 'json', service.name]),
+    attempt(service.stack, ['logs', '--no-color', '--no-log-prefix', `--tail=${TAIL}`, `--since=${since}`, service.name]),
+  ])
+
+  return { log: logs.text, container: containers(ps.text)[0], unreadable: ps.error ?? logs.error }
+}
+
+/** The lines of a log without the body of a private key. */
+export function withoutKeys(lines: string[]): string[] {
+  let inKey = false
+
+  return lines.filter((text) => {
+    const opens = PEM_BEGIN.test(text)
+    const hidden = inKey || opens
+
+    inKey = (inKey || opens) && !PEM_END.test(text)
+
+    return !hidden
+  })
+}
+
+function line(report: Report): string {
+  const colors = paint(process.stdout)
+  const status = report.status.replace(STATUS_HEALTH, '').trim()
+  const detail = [report.health, status].filter(Boolean).join(' · ')
+
+  return `${report.key.padEnd(24)} ${colors[stateColor(report.state)](report.state.padEnd(9))} ${colors.dim(detail)}`.trimEnd()
+}
+
+function show(reports: Report[]): void {
+  const colors = paint(process.stdout)
+
+  for (const report of reports) {
+    console.log(line(report))
+
+    if (report.unreadable !== undefined)
+      console.log(`  ${colors.red(`logs unavailable: ${report.unreadable}`)}`)
+
+    for (const { line: text, count } of report.errors)
+      console.log(`  ${colors.red(text)}${count > 1 ? colors.dim(` ×${count}`) : ''}`)
+
+    for (const text of report.tail)
+      console.log(`  ${colors.dim(text)}`)
+  }
+}
+
+export async function dlog(args: string[]): Promise<number> {
+  const parsed = parse(args, usage, options, { replaces: 'docker compose ps, logs --tail | grep -i error and docker inspect for health', examples: ['dlog', ['dlog php db', 'only those services'], ['dlog -n 10 --since 15m', 'ten error lines of the last quarter of an hour'], ['dlog --json', 'the report as JSON']] })
+  const limit = Number(parsed.values.lines)
+
+  if (!Number.isInteger(limit) || limit < 1)
+    fail('--lines takes a positive whole number')
+
+  const services = await allServices()
+
+  if (services.length === 0)
+    fail('no compose service here', 1)
+
+  const wanted = parsed.positionals
+  const unknown = wanted.filter(name => !services.some(service => key(service) === name || service.name === name))
+
+  if (unknown.length > 0)
+    fail(`no service named ${unknown.join(', ')}`, 1)
+
+  const chosen = wanted.length === 0 ? services : services.filter(service => wanted.includes(key(service)) || wanted.includes(service.name))
+  const reports: Report[] = await Promise.all(chosen.map(async (service) => {
+    const { log, container, unreadable } = await read(service, parsed.values.since)
+    const { health, fine } = healthOf(service.state, container)
+    const lines = withoutKeys(log.split('\n'))
+    const errors = errorLines(lines.join('\n'), limit)
+    const tail = parsed.values.all === true && errors.length === 0 ? lines.map(text => clip(maskLine(stripAnsi(text).trim()))).filter(Boolean).slice(-limit) : []
+
+    return { key: key(service), state: service.state, health, status: service.status, errors, tail, unreadable, fine }
+  }))
+
+  if (parsed.values.json === true)
+    printJson(reports)
+  else
+    show(reports)
+
+  const down = reports.filter(report => !report.fine || report.unreadable !== undefined || report.errors.length > 0)
+
+  if (parsed.values.json !== true && down.length > 0)
+    console.error(paint(process.stderr).dim(`${down.length} of ${reports.length} services need a look: ${down.map(report => report.key).join(', ')}`))
+
+  return down.length > 0 ? 1 : 0
+}

package/src/dx.ts

@@ -1,7 +1,7 @@
 import type { Action, Service } from './stack'
 import process from 'node:process'
 import { closest, fail, jsonOption, paint, parse, printJson } from '@kaynooo/cli-kit'
-import { byRecency, record, runs } from './history'
+import { byRecency, record, runs } from '@kaynooo/cli-kit/fzf'
 import { KEY_LABELS, KEYS, pickService } from './picker'
 import { ACTIONS, allServices, commandFor, defaultAction, key, logsOf, serviceNamed, stateColor } from './stack'
 
@@ -46,7 +46,7 @@ function find(services: Service[], named: string): Service {
 
 // The rows term lists in place of the picker: what it types back for enter and for each key.
 function listed(services: Service[]): unknown[] {
-  return byRecency(services, runs(), key).map(service => ({
+  return byRecency(services, runs('dx'), key).map(service => ({
     label: key(service),
     hint: [service.state, service.ports, service.image].filter(Boolean).join(' · '),
     typed: key(service),
@@ -130,7 +130,7 @@ export async function dx(args: string[]): Promise<number> {
       return 0
     }
 
-    const picked = pickService(byRecency(services, runs(), key))
+    const picked = pickService(byRecency(services, runs('dx'), key))
 
     if (picked === undefined)
       return 1
@@ -139,7 +139,7 @@ export async function dx(args: string[]): Promise<number> {
     action = KEYS[picked.key]
   }
   else if (named === '-') {
-    const last = runs()[0]
+    const last = runs('dx')[0]
 
     service = last && services.find(candidate => key(candidate) === last.id)
 
@@ -160,7 +160,7 @@ export async function dx(args: string[]): Promise<number> {
   const chosen = action ?? defaultAction(service)
   const command = await commandFor(service, chosen)
 
-  record({ id: key(service), args: [chosen] })
+  record('dx', { id: key(service), args: [chosen] })
 
   if (emit) {
     console.log(['run', action === undefined ? key(service) : `${key(service)} ${action}`, '', ...command.map(word => `=${word}`)].join('\n'))

package/src/picker.ts

@@ -1,13 +1,15 @@
+import type { Row } from '@kaynooo/cli-kit/fzf'
 import type { Action, Service } from './stack'
 import process from 'node:process'
 import { paint } from '@kaynooo/cli-kit'
+import { fzf, heightFor } from '@kaynooo/cli-kit/fzf'
 import { key, stateColor } from './stack'
 
 export const KEYS: Record<string, Action> = { 'ctrl-l': 'logs', 'ctrl-r': 'restart', 'ctrl-x': 'stop', 'ctrl-b': 'build' }
 export const KEY_LABELS: Record<string, string> = { 'ctrl-l': 'Logs', 'ctrl-r': 'Restart', 'ctrl-x': 'Stop', 'ctrl-b': 'Rebuild' }
 
-// The fields fzf hands back after the visible ones, tab separated: folder, name, key, compose project.
-function row(service: Service): { hidden: string[], cells: string[] } {
+// The hidden fields come back with the choice: folder, name, key, compose project.
+function row(service: Service): Row {
   const colors = paint(process.stderr)
   const dir = service.stack.dir
   const project = service.stack.project
@@ -19,49 +21,17 @@ function row(service: Service): { hidden: string[], cells: string[] } {
   }
 }
 
-// Every cell but the last padded to its column, one space short of the two between columns since a tab renders as one.
-function table(rows: { hidden: string[], cells: string[] }[]): string {
-  const widths = rows[0]?.cells.map((_, index) => Math.max(...rows.map(each => Bun.stringWidth(each.cells[index]!)))) ?? []
-
-  return rows.map(each => [
-    ...each.hidden,
-    ...each.cells.map((cell, index) => (index === each.cells.length - 1 ? cell.trimEnd() : `${cell}${' '.repeat(widths[index]! + 1 - Bun.stringWidth(cell))}`)),
-  ].join('\t')).join('\n')
-}
-
 // The service picked with fzf and the key that picked it, enter's being empty; undefined on escape.
 export function pickService(services: Service[]): { service: Service, key: string } | undefined {
-  const proc = Bun.spawnSync([
-    'fzf',
-    '--prompt',
-    'dx> ',
-    '--header',
-    'enter shell or up, ctrl-l logs, ctrl-r restart, ctrl-x stop, ctrl-b rebuild',
-    '--expect',
-    Object.keys(KEYS).join(','),
-    '--ansi',
-    '--reverse',
-    '--height',
-    String(Math.max(15, Math.ceil((services.length + 4) / 0.6))),
-    '--delimiter',
-    '\t',
-    '--with-nth',
-    '5..',
-    '--nth',
-    '1',
-    '--tabstop',
-    '1',
-    '--tiebreak',
-    'chunk,index',
-    '--preview',
-    `${process.execPath} ${process.argv[1]} --show {1} {2} {4}`,
-    '--preview-window',
-    'down,40%',
-  ], { stdin: new TextEncoder().encode(table(services.map(row))), stdout: 'pipe', stderr: 'inherit' })
-
-  const [pressed = '', line] = proc.stdout.toString().split('\n')
-  const keyed = line?.split('\t')[2]
-  const service = services.find(candidate => key(candidate) === keyed)
-
-  return service === undefined ? undefined : { service, key: pressed }
+  const picked = fzf(services.map(row), {
+    prompt: 'dx> ',
+    header: 'enter shell or up, ctrl-l logs, ctrl-r restart, ctrl-x stop, ctrl-b rebuild',
+    expect: Object.keys(KEYS),
+    searched: 1,
+    height: heightFor(services.length),
+    preview: `${process.execPath} ${process.argv[1]} --show {1} {2} {4}`,
+  })
+  const service = services.find(candidate => key(candidate) === picked?.hidden[2])
+
+  return picked === undefined || service === undefined ? undefined : { service, key: picked.key }
 }

package/src/sf-cli.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env bun
+
+import process from 'node:process'
+import { runMain } from '@kaynooo/cli-kit'
+import { version } from '../package.json'
+import { sf } from './sf'
+
+process.exitCode = await runMain({ name: 'sf', version, run: sf })