@kaynooo/cli-docker 0.2.0 → 0.4.0

package/src/sf.ts

@@ -0,0 +1,368 @@
+import type { Arg, Row } from '@kaynooo/cli-kit/fzf'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import process from 'node:process'
+import { fail, paint, parse } from '@kaynooo/cli-kit'
+import { byRecency, emit, fzf, list, record, runs, table } from '@kaynooo/cli-kit/fzf'
+import { input } from '@kaynooo/cli-kit/prompt'
+import { children, from, nearestStack, services, up } from './stack'
+
+interface Argument {
+  name: string
+  is_required: boolean
+  is_array: boolean
+  description: string
+}
+
+interface Option {
+  name: string
+  shortcut: string
+  accept_value: boolean
+  description: string
+}
+
+/** A command as `bin/console list --format=json` describes it, a definition without arguments or options holding an empty array instead of an object. */
+export interface Command {
+  name: string
+  description: string
+  help: string
+  usage: string[]
+  hidden: boolean
+  definition: { arguments: Record<string, Argument> | [], options: Record<string, Option> | [] }
+}
+
+/** One console, and how its commands are run and listed. */
+export interface Console {
+  dir: string
+  run: string[]
+  list: { argv: string[], cwd: string, env: Record<string, string | undefined> }
+}
+
+export interface Entry {
+  app: Console
+  command: Command
+}
+
+const usage = `sf [command] [args...]
+sf -
+
+Picks a Symfony console command with fzf and runs it, asking for each required argument it needs. The commands last run come first, per folder, and the picker opens on the list cached from the last run while the console answers.
+The console is the nearest bin/console up to the repository root, then those of the child folders (keyed \`api/cache:clear\`). It runs in the php service of the nearest compose stack when there is one, else with the local php; the container's working directory is taken to be the app.
+\`sf -\` runs the last command again with the arguments it ran with, \`sf <command> [args...]\` runs without the picker: a name the list does not hold goes to the console as is, which resolves \`c:c\` to \`cache:clear\` itself. Without fzf or a terminal it lists the commands instead.
+The hidden flags --list, --names, --rows, --show, --record and --emit are for term, tmux and the shell completions.
+
+Exits with the code of the console, 1 when there is no bin/console here.`
+
+/** Fzf paints its rows and previews itself, so these keep their colors whatever stream they are written to. */
+const colors = paint({ isTTY: true })
+const MARKUP = /<(info|comment|question|error)>(.*?)<\/\1>/gs
+const TAGS = { info: 'green', comment: 'yellow', question: 'cyan', error: 'red' } as const
+const LINKS = /<\/?href[^>]*>/g
+
+/** Symfony's console markup, in the colors the console itself gives it. */
+export function marked(text: string): string {
+  return text.replace(MARKUP, (_, tag: keyof typeof TAGS, inner: string) => colors[TAGS[tag]](inner)).replace(LINKS, '')
+}
+
+export function argumentsOf(command: Command): Argument[] {
+  return Array.isArray(command.definition.arguments) ? [] : Object.values(command.definition.arguments)
+}
+
+function optionsOf(command: Command): Option[] {
+  return Array.isArray(command.definition.options) ? [] : Object.values(command.definition.options)
+}
+
+/** The php service by name, `php` itself before `booki-php` or `dorad_php`. */
+export function phpService(names: string[]): string | undefined {
+  return names.find(name => name === 'php') ?? names.find(name => name.includes('php'))
+}
+
+async function consoleAt(dir: string): Promise<Console> {
+  const stack = nearestStack(dir)
+  const php = stack === undefined ? undefined : phpService((await services(stack)).map(service => service.name))
+
+  if (stack !== undefined && php !== undefined)
+    return { dir, run: [...stack.run, 'exec', php, 'bin/console'], list: { ...stack.list, argv: [...stack.list.argv, 'exec', '-T', php, 'bin/console'] } }
+
+  return { dir, run: from(dir, ['php', 'bin/console']), list: { argv: ['php', 'bin/console'], cwd: resolve(dir), env: process.env } }
+}
+
+/** The console of this folder or its nearest parent, then those of the child folders. */
+async function consoles(): Promise<Console[]> {
+  const here = up('.').find(dir => existsSync(join(dir, 'bin/console')))
+  const dirs = [...(here === undefined ? [] : [here]), ...children().filter(dir => existsSync(join(dir, 'bin/console')))]
+
+  return Promise.all([...new Set(dirs)].map(consoleAt))
+}
+
+function cached(dir: string): string {
+  return join(process.env.XDG_CACHE_HOME ?? join(homedir(), '.cache'), 'sf', `${resolve(dir).replaceAll('/', '%')}.json`)
+}
+
+function fromCache(dir: string): Command[] | undefined {
+  try {
+    return existsSync(cached(dir)) ? JSON.parse(readFileSync(cached(dir), 'utf-8')) as Command[] : undefined
+  }
+  catch {
+    return undefined
+  }
+}
+
+async function live(app: Console): Promise<Command[]> {
+  const proc = Bun.spawn([...app.list.argv, 'list', '--format=json'], { cwd: app.list.cwd, env: app.list.env, stdout: 'pipe', stderr: 'pipe' })
+  const text = await new Response(proc.stdout).text()
+
+  if ((await proc.exited) !== 0)
+    return fromCache(app.dir) ?? []
+
+  const commands = (JSON.parse(text) as { commands: Command[] }).commands.filter(command => !command.hidden)
+
+  mkdirSync(dirname(cached(app.dir)), { recursive: true })
+  writeFileSync(cached(app.dir), JSON.stringify(commands))
+
+  return commands
+}
+
+async function entries(fresh: boolean): Promise<Entry[]> {
+  const found = await consoles()
+  const lists = await Promise.all(found.map(async app => (fresh ? live(app) : fromCache(app.dir) ?? live(app))))
+
+  return found.flatMap((app, index) => lists[index]!.map(command => ({ app, command })))
+}
+
+/** What names a command: `cache:clear` in this folder's console, `api/cache:clear` in a child's. */
+export function key(entry: Entry): string {
+  return entry.app.dir === '.' ? entry.command.name : `${entry.app.dir}/${entry.command.name}`
+}
+
+/** The namespace dimmed, the command standing out: `cache:` in `cache:clear`. */
+function named(name: string): string {
+  const colon = name.lastIndexOf(':')
+
+  return colon === -1 ? name : `${colors.dim(name.slice(0, colon + 1))}${name.slice(colon + 1)}`
+}
+
+/** Required arguments read as `<name>`, the others as `[name]`, a list as `name...`. */
+export function signature(command: Command): string {
+  return argumentsOf(command)
+    .map(argument => `${argument.is_required ? '<' : '['}${argument.name}${argument.is_array ? '...' : ''}${argument.is_required ? '>' : ']'}`)
+    .join(' ')
+}
+
+function rows(found: Entry[]): Row[] {
+  return byRecency(found, runs('sf'), key).map(entry => ({
+    hidden: [entry.app.dir, entry.command.name],
+    cells: [entry.app.dir === '.' ? named(entry.command.name) : `${colors.dim(`${entry.app.dir}/`)}${named(entry.command.name)}`, colors.cyan(signature(entry.command)), colors.dim(entry.command.description)],
+  }))
+}
+
+/** From the cache alone, the preview being called at every move. */
+function preview(dir: string, name: string): void {
+  const command = (fromCache(dir) ?? []).find(candidate => candidate.name === name)
+
+  if (!command)
+    return
+
+  // Laid out as `bin/console help` has it.
+  const lines = [
+    colors.bold(command.description),
+    '',
+    colors.yellow('Usage:'),
+    ...command.usage.map(line => `  ${line}`),
+    ...(argumentsOf(command).length ? ['', colors.yellow('Arguments:'), ...argumentsOf(command).map(argument => `  ${colors.green(argument.name.padEnd(20))} ${argument.description}`)] : []),
+    ...(optionsOf(command).length ? ['', colors.yellow('Options:'), ...optionsOf(command).map(option => `  ${colors.green(`--${option.name}${option.accept_value ? '=' : ''}`.padEnd(20))} ${option.description}`)] : []),
+    ...(command.help ? ['', colors.yellow('Help:'), command.help] : []),
+  ]
+
+  console.log(marked(lines.join('\n')))
+}
+
+/** The arguments given, then a prompt for each required one past them. */
+export function commandFor(entry: Entry, given: string[]): Arg[] {
+  const prompts = argumentsOf(entry.command).filter(argument => argument.is_required).slice(given.length)
+
+  return [...entry.app.run, entry.command.name, ...given.map(value => ({ given: value })), ...prompts.map(argument => ({ ask: argument.name }))]
+}
+
+/** The words of a command with every prompt answered, and the arguments a run is remembered with; undefined once a prompt is cancelled. */
+export async function answered(command: Arg[], ask: (name: string) => Promise<string | undefined>): Promise<{ argv: string[], given: string[] } | undefined> {
+  const argv: string[] = []
+  const given: string[] = []
+
+  for (const word of command) {
+    if (typeof word === 'string') {
+      argv.push(word)
+
+      continue
+    }
+
+    const value = 'given' in word ? word.given : await ask(word.ask)
+
+    if (value === undefined)
+      return undefined
+
+    argv.push(value)
+    given.push(value)
+  }
+
+  return { argv, given }
+}
+
+function interactive(): boolean {
+  return process.stdin.isTTY && process.stderr.isTTY
+}
+
+/** What `--emit` prints for tmux, or, standalone, the command run once its prompts are answered. */
+async function execute(emitting: boolean, typed: string, recorded: string, command: Arg[]): Promise<number> {
+  if (emitting) {
+    emit('run', typed, recorded, command)
+
+    return 0
+  }
+
+  if (!interactive() && command.some(word => typeof word === 'object' && 'ask' in word))
+    fail('a required argument is missing and there is no terminal to ask for it', 1)
+
+  const done = await answered(command, async name => input(`${name}:`))
+
+  if (done === undefined)
+    return 1
+
+  if (recorded !== '')
+    record('sf', { id: recorded, args: done.given })
+
+  return Bun.spawn(done.argv, { stdio: ['inherit', 'inherit', 'inherit'] }).exited
+}
+
+function listing(found: Entry[]): string {
+  const sorted = byRecency(found, runs('sf'), key)
+  const labels = sorted.map(entry => [key(entry), signature(entry.command)].filter(Boolean).join(' '))
+  const width = Math.max(...labels.map(label => label.length))
+
+  return sorted.map((entry, index) => `${labels[index]!.padEnd(width)}  ${entry.command.description}`.trimEnd()).join('\n')
+}
+
+/** The hidden flags term, tmux and the shell completions call, each printing and nothing more. */
+async function hidden(flag: string, rest: string[]): Promise<number | undefined> {
+  if (flag === '--show') {
+    preview(rest[0] ?? '.', rest[1] ?? '')
+
+    return 0
+  }
+
+  if (flag === '--record') {
+    record('sf', { id: rest[0] ?? '', args: rest.slice(1) })
+
+    return 0
+  }
+
+  // Called back by fzf once the picker is open on the cached list.
+  if (flag === '--rows') {
+    console.log(table(rows(await entries(true))).join('\n'))
+
+    return 0
+  }
+
+  if (flag !== '--list' && flag !== '--names')
+    return undefined
+
+  const refreshed = flag === '--list' && (await consoles()).some(found => fromCache(found.dir) !== undefined)
+  const found = await entries(false)
+
+  if (flag === '--names') {
+    // With the description as the one fish shows beside each name.
+    console.log(found.map(entry => `${key(entry)}\t${entry.command.description}`).join('\n'))
+
+    return 0
+  }
+
+  // From the cache, which a list run in the background brings up to date for the next time, as fzf's reload does.
+  if (refreshed)
+    Bun.spawn([process.execPath, process.argv[1]!, '--rows'], { stdio: ['ignore', 'ignore', 'ignore'] }).unref()
+
+  list(byRecency(found, runs('sf'), key).map(entry => ({
+    label: [key(entry), signature(entry.command)].filter(Boolean).join(' '),
+    hint: entry.command.description,
+    typed: key(entry),
+    preview: ['--show', entry.app.dir, entry.command.name],
+  })))
+
+  return 0
+}
+
+export async function sf(args: string[]): Promise<number> {
+  const [flag = ''] = args
+  const flagged = await hidden(flag, args.slice(1))
+
+  if (flagged !== undefined)
+    return flagged
+
+  // The protocol the tmux picker reads instead of running the command: its mode, the words typed back, and the command's words.
+  const emitting = flag === '--emit'
+  const words = emitting ? args.slice(1) : args
+  const last = words[0] === '-'
+  const parsed = parse(last ? [] : words, usage, {}, {
+    positionals: ['[command]'],
+    trailing: true,
+    replaces: 'bin/console typed in the php container, with the command names and arguments looked up by hand',
+    examples: ['sf', ['sf cache:clear', 'run it without the picker'], ['sf c:c --env=prod', 'the console resolves abbreviations itself'], ['sf -', 'the last command again, with its arguments']],
+  })
+  const [command] = parsed.positionals
+  const given = last ? words.slice(1) : parsed.rest ?? []
+  const refreshed = command === undefined && !last && (await consoles()).some(found => fromCache(found.dir) !== undefined)
+  const found = await entries(false)
+
+  if (last) {
+    const previous = runs('sf')[0]
+    const entry = previous && found.find(candidate => key(candidate) === previous.id)
+
+    if (entry === undefined)
+      fail(previous ? `${previous.id} is gone` : 'nothing run here yet', 1)
+
+    return execute(emitting, key(entry), key(entry), commandFor(entry, [...previous!.args, ...given]))
+  }
+
+  if (command !== undefined) {
+    const entry = found.find(candidate => key(candidate) === command) ?? found.find(candidate => candidate.command.name === command)
+
+    if (entry !== undefined)
+      return execute(emitting, key(entry), key(entry), commandFor(entry, given))
+
+    // Left to the console, which knows its abbreviations and suggests the nearest command itself.
+    const [first] = await consoles()
+
+    if (first === undefined)
+      fail('no bin/console here', 1)
+
+    return execute(emitting, command, '', [...first.run, command, ...given.map(value => ({ given: value }))])
+  }
+
+  if (found.length === 0)
+    fail('no bin/console here, or it listed no command', 1)
+
+  if (!interactive() || Bun.which('fzf') === null) {
+    if (emitting)
+      fail('the picker needs a terminal and fzf', 1)
+
+    if (interactive())
+      console.error('fzf is not installed, listing the commands instead')
+
+    console.log(listing(found))
+
+    return 0
+  }
+
+  const self = `${process.execPath} ${process.argv[1]}`
+  const picked = fzf(rows(found), {
+    prompt: 'sf> ',
+    searched: 1,
+    preview: `${self} --show {1} {2}`,
+    // Once the cached list is in, and only once, the reload firing load again.
+    bind: refreshed ? [`load:unbind(load)+reload-sync(${self} --rows)`] : [],
+  })
+  // Read again, the reload having maybe brought a command the cached list did not hold.
+  const entry = picked && (await entries(false)).find(candidate => candidate.app.dir === picked.hidden[0] && candidate.command.name === picked.hidden[1])
+
+  return entry === undefined ? 1 : execute(emitting, key(entry), key(entry), commandFor(entry, []))
+}

package/src/stack.ts

@@ -42,6 +42,9 @@ export interface Container {
   Service: string
   State: string
   Status: string
+  /** Empty for a container with no healthcheck. */
+  Health?: string
+  ExitCode?: number
 }
 
 const LABEL_FORMAT = ['project', 'project.config_files', 'project.environment_file', 'project.working_dir'].map(label => `{{.Label "com.docker.compose.${label}"}}`).join('\t')
@@ -52,12 +55,12 @@ const SKIPPED = new Set(['node_modules', 'vendor', 'dist', 'build', 'target', 'v
 export const ACTIONS: Action[] = ['shell', 'logs', 'restart', 'up', 'stop', 'build']
 
 /** The command behind `env -C` when it runs from another folder than this one. */
-function from(dir: string, command: string[]): string[] {
+export function from(dir: string, command: string[]): string[] {
   return dir === '.' ? command : ['env', '-C', dir, ...command]
 }
 
 /** The direct child folders, hidden and built ones aside. */
-function children(dir = '.'): string[] {
+export function children(dir = '.'): string[] {
   return readdirSync(dir, { withFileTypes: true })
     .filter(child => child.isDirectory() && !child.name.startsWith('.') && !SKIPPED.has(child.name))
     .map(child => child.name)
@@ -65,7 +68,7 @@ function children(dir = '.'): string[] {
 }
 
 /** The folder and its parents, relative to it, up to the repository root. */
-function up(dir: string): string[] {
+export function up(dir: string): string[] {
   const dirs: string[] = []
 
   for (let current = dir; ; current = join(current, '..')) {
@@ -158,10 +161,21 @@ export async function recordedNearby(): Promise<Labels[]> {
   return (await labels()).filter(stack => dirs.has(stack.workdir))
 }
 
-async function output(stack: Stack, args: string[]): Promise<string> {
+/** What compose printed, and its stderr when it exited non-zero. */
+export async function attempt(stack: Stack, args: string[]): Promise<{ text: string, error: string | undefined }> {
   const proc = Bun.spawn([...stack.list.argv, ...args], { cwd: stack.list.cwd, env: stack.list.env, stdout: 'pipe', stderr: 'pipe' })
+  const [text, stderr, code] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited])
+
+  if (code === 0)
+    return { text, error: undefined }
+
+  const last = stderr.trim().split('\n').at(-1) ?? ''
 
-  return (await proc.exited) === 0 ? new Response(proc.stdout).text() : ''
+  return { text: '', error: last === '' ? `exit ${code}` : last }
+}
+
+async function output(stack: Stack, args: string[]): Promise<string> {
+  return (await attempt(stack, args)).text
 }
 
 /** Compose prints one container per line, where older versions printed a JSON array. */

package/src/history.ts

@@ -1,48 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { dirname, join } from 'node:path'
-import process from 'node:process'
-
-export interface Run {
-  id: string
-  args: string[]
-}
-
-const REMEMBERED = 20
-
-function historyFile(): string {
-  return join(process.env.XDG_CACHE_HOME ?? join(homedir(), '.cache'), 'dx', 'history.json')
-}
-
-// Keyed by folder, a broken or missing file reading as nothing run yet.
-function history(): Record<string, Run[]> {
-  try {
-    const file = historyFile()
-
-    return existsSync(file) ? JSON.parse(readFileSync(file, 'utf-8')) as Record<string, Run[]> : {}
-  }
-  catch {
-    return {}
-  }
-}
-
-export function runs(): Run[] {
-  return history()[process.cwd()] ?? []
-}
-
-export function record(run: Run): void {
-  const all = history()
-  const file = historyFile()
-
-  all[process.cwd()] = [run, ...(all[process.cwd()] ?? []).filter(earlier => earlier.id !== run.id)].slice(0, REMEMBERED)
-  mkdirSync(dirname(file), { recursive: true })
-  writeFileSync(file, JSON.stringify(all))
-}
-
-// The ones run last come first, most recent at the top, the rest keeping their order.
-export function byRecency<T>(items: T[], previous: Run[], idOf: (item: T) => string): T[] {
-  const rank = new Map(previous.map((run, index) => [run.id, index]))
-  const recent = items.filter(item => rank.has(idOf(item))).sort((a, b) => rank.get(idOf(a))! - rank.get(idOf(b))!)
-
-  return [...recent, ...items.filter(item => !rank.has(idOf(item)))]
-}