@kaynooo/cli-docker 0.1.0 → 0.3.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@kaynooo/cli-docker",
   "type": "module",
-  "version": "0.1.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.3.0",
+  "description": "dc, dx 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, 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,8 @@
   },
   "bin": {
     "dc": "./dist/dc-cli.js",
-    "dx": "./dist/dx-cli.js"
+    "dx": "./dist/dx-cli.js",
+    "sf": "./dist/sf-cli.js"
   },
   "files": ["dist", "src"],
   "engines": {
@@ -28,9 +29,10 @@
     "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/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"
+    "dx": "$npm_execpath src/dx-cli.ts",
+    "sf": "$npm_execpath src/sf-cli.ts"
   },
   "devDependencies": {
     "@kaynooo/cli-kit": "0.20.0"

package/src/dx.ts

@@ -1,12 +1,16 @@
 import type { Action, Service } from './stack'
 import process from 'node:process'
 import { closest, fail, jsonOption, paint, parse, printJson } from '@kaynooo/cli-kit'
-import { ACTIONS, allServices, commandFor, defaultAction, key } from './stack'
+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'
 
 const usage = `dx [service] [action]
+dx -
 
-Without a service, lists the compose services here: the stack of this folder or its nearest parent, the ones of the child folders (keyed \`api/php\`), and stacks found only through their containers (keyed \`<project>:php\`).
-With one, acts on it: \`shell\` (the default for a running service, bash when the container has it), \`logs\` (follows the last 200 lines), \`restart\`, \`up\`, \`stop\` or \`build\` (up with a rebuild). A stopped service has no shell, so it is brought up instead.
+Without a service, picks one with fzf when it is installed and a terminal is attached: enter opens its shell (or brings a stopped service up), ctrl-l follows its logs, ctrl-r restarts, ctrl-x stops and ctrl-b rebuilds it. The services last acted on come first, per folder. Without fzf or a terminal it lists them instead.
+\`dx -\` does the last action again, \`dx <service> [action]\` acts without the picker: \`shell\` (bash when the container has it), \`logs\` (follows the last 200 lines), \`restart\`, \`up\`, \`stop\` or \`build\` (up with a rebuild).
+The services are the stack of this folder or its nearest parent, the ones of the child folders (keyed \`api/php\`), and stacks found only through their containers (keyed \`<project>:php\`).
 
 Exits with the code of the command it ran, 1 when there is no compose service here or none by that name.`
 
@@ -14,17 +18,6 @@ const options = {
   json: jsonOption('[{ key, project, name, state, status, ports, image }]'),
 } as const
 
-// Up in green, down in red, never created dimmed, anything on its way, restarting or paused, in yellow.
-function stateColor(state: string): 'green' | 'red' | 'dim' | 'yellow' {
-  if (state === 'running')
-    return 'green'
-
-  if (state === 'exited' || state === 'dead')
-    return 'red'
-
-  return state === 'none' ? 'dim' : 'yellow'
-}
-
 function table(services: Service[]): string {
   const colors = paint(process.stdout)
   const keys = services.map(key)
@@ -51,29 +44,129 @@ function find(services: Service[], named: string): Service {
   return fail(`no service named ${named}${nearest === undefined ? '' : `, did you mean ${nearest}?`}`, 1)
 }
 
+// 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('dx'), key).map(service => ({
+    label: key(service),
+    hint: [service.state, service.ports, service.image].filter(Boolean).join(' · '),
+    typed: key(service),
+    preview: ['--show', service.stack.dir, service.name, service.stack.project ?? ''],
+    actions: Object.entries(KEYS).map(([pressed, action]) => ({ label: KEY_LABELS[pressed] ?? action, key: pressed, typed: `${key(service)} ${action}` })),
+  }))
+}
+
+// The hidden flags term and the shell completions call, each printing and nothing more.
+async function hidden(flag: string, rest: string[], services: Service[]): Promise<number | undefined> {
+  if (flag === '--list') {
+    console.log(JSON.stringify(listed(services)))
+
+    return 0
+  }
+
+  // With the state as the description fish shows beside each name.
+  if (flag === '--names') {
+    console.log(services.map(service => `${key(service)}\t${service.state}`).join('\n'))
+
+    return 0
+  }
+
+  if (flag === '--show') {
+    const [dir = '.', name = '', project = ''] = rest
+    const service = await serviceNamed(dir, name, project)
+
+    if (service === undefined)
+      return 0
+
+    const colors = paint(process.stdout)
+
+    console.log(`${colors[stateColor(service.state)](service.status || service.state)}  ${colors.dim(service.image)}${service.ports ? `  ${colors.cyan(service.ports)}` : ''}\n`)
+    console.log(await logsOf(service.stack, name))
+
+    return 0
+  }
+
+  return undefined
+}
+
 export async function dx(args: string[]): Promise<number> {
-  const parsed = parse(args, usage, options, { replaces: 'docker compose exec <service> bash, logs -f and restart typed per service', examples: ['dx', ['dx php', 'a shell in php, or php brought up when stopped'], ['dx php logs', 'follow its logs']] })
+  const [flag = ''] = args
+
+  if (flag === '--show' || flag === '--list' || flag === '--names') {
+    const services = flag === '--show' ? [] : await allServices()
+
+    if (services.length === 0 && flag !== '--show')
+      fail('no compose service here', 1)
+
+    return await hidden(flag, args.slice(1), services) ?? 0
+  }
+
+  // The protocol the tmux picker reads instead of running the command: its mode, the words typed back, and the command's words.
+  const emit = flag === '--emit'
+  const parsed = parse(emit ? args.slice(1) : args, usage, options, { replaces: 'docker compose exec <service> bash, logs -f and restart typed per service', examples: ['dx', ['dx php', 'a shell in php, or php brought up when stopped'], ['dx php logs', 'follow its logs'], ['dx -', 'the last action again']] })
   const [named, asked] = parsed.positionals
   const services = await allServices()
 
   if (services.length === 0)
     fail('no compose service here', 1)
 
+  let service: Service | undefined
+  let action: Action | undefined
+
   if (named === undefined) {
-    if (parsed.values.json === true)
-      printJson(services.map(service => ({ key: key(service), project: service.project, name: service.name, state: service.state, status: service.status, ports: service.ports, image: service.image })))
-    else
-      console.log(table(services))
+    const interactive = process.stdin.isTTY && process.stderr.isTTY && parsed.values.json !== true
 
-    return 0
+    if (!interactive || Bun.which('fzf') === null) {
+      if (emit)
+        fail('the picker needs a terminal and fzf', 1)
+
+      if (interactive)
+        console.error('fzf is not installed, listing the services instead')
+
+      if (parsed.values.json === true)
+        printJson(services.map(each => ({ key: key(each), project: each.project, name: each.name, state: each.state, status: each.status, ports: each.ports, image: each.image })))
+      else
+        console.log(table(services))
+
+      return 0
+    }
+
+    const picked = pickService(byRecency(services, runs('dx'), key))
+
+    if (picked === undefined)
+      return 1
+
+    service = picked.service
+    action = KEYS[picked.key]
+  }
+  else if (named === '-') {
+    const last = runs('dx')[0]
+
+    service = last && services.find(candidate => key(candidate) === last.id)
+
+    if (service === undefined)
+      fail(last ? `${last.id} is gone` : 'nothing done here yet', 1)
+
+    action = last!.args[0] as Action | undefined
   }
+  else {
+    service = find(services, named)
 
-  const service = find(services, named)
+    if (asked !== undefined && !ACTIONS.includes(asked as Action))
+      fail(`no action ${asked}, one of ${ACTIONS.join(', ')}`)
 
-  if (asked !== undefined && !ACTIONS.includes(asked as Action))
-    fail(`no action ${asked}, one of ${ACTIONS.join(', ')}`)
+    action = asked as Action | undefined
+  }
 
-  const command = await commandFor(service, (asked as Action | undefined) ?? defaultAction(service))
+  const chosen = action ?? defaultAction(service)
+  const command = await commandFor(service, 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'))
+
+    return 0
+  }
 
   return Bun.spawn(command, { stdio: ['inherit', 'inherit', 'inherit'] }).exited
 }

package/src/picker.ts

@@ -0,0 +1,37 @@
+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 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
+  const name = project === undefined ? service.name : `${colors.dim(`${project}:`)}${service.name}`
+
+  return {
+    hidden: [dir, service.name, key(service), project ?? ''],
+    cells: [dir === '.' ? name : `${colors.dim(`${dir}/`)}${name}`, colors[stateColor(service.state)](service.state), colors.cyan(service.ports), colors.dim(service.image)],
+  }
+}
+
+// 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 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 })

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

@@ -52,12 +52,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 +65,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, '..')) {
@@ -239,3 +239,27 @@ export async function commandFor(service: Service, action: Action): Promise<stri
 export function defaultAction(service: Service): Action {
   return service.state === 'running' ? 'shell' : 'up'
 }
+
+// Up in green, down in red, never created dimmed, anything on its way, restarting or paused, in yellow.
+export function stateColor(state: string): 'green' | 'red' | 'dim' | 'yellow' {
+  if (state === 'running')
+    return 'green'
+
+  if (state === 'exited' || state === 'dead')
+    return 'red'
+
+  return state === 'none' ? 'dim' : 'yellow'
+}
+
+// A service looked up again from the folder, project and name the picker's preview was given.
+export async function serviceNamed(dir: string, name: string, project: string): Promise<Service | undefined> {
+  const [recorded] = project === '' ? [] : await labels(project)
+  const stack = recorded === undefined ? stackAt(dir) : labelledStack(dir, recorded)
+
+  return (await services(stack)).find(candidate => candidate.name === name)
+}
+
+// Compose's own words for its output of one service, the last lines of its logs.
+export async function logsOf(stack: Stack, name: string): Promise<string> {
+  return output(stack, ['logs', '--tail=30', '--no-log-prefix', name])
+}