@kaynooo/cli-docker 0.1.0 → 0.2.0

package/README.md

@@ -12,7 +12,8 @@ bun install -g @kaynooo/cli-docker
 | --- | --- |
 | `dc <compose args>` | `docker compose` on the nearest compose file (or `.env` setting `COMPOSE_FILE`) up to the repository root |
 | `dc <project> <compose args>` | the same on a stack that came up from other files (`-f docker-compose.prod.yaml --env-file .env.prod`), found through the labels compose put on its containers |
-| `dx` | lists the services here with their state, ports and image (`--json` for the full record) |
+| `dx` | picks a service with fzf: enter opens its shell (or brings it up), ctrl-l follows its logs, ctrl-r restarts, ctrl-x stops, ctrl-b rebuilds; the ones acted on last come first. Without fzf or a terminal it lists them with their state, ports and image (`--json` for the full record) |
+| `dx -` | the last action again |
 | `dx <service> [action]` | `shell` (the default, `up` for a stopped service), `logs`, `restart`, `up`, `stop` or `build` |
 
 `dc` takes no option of its own, every word reaches compose as typed. With several stacks that only have containers here and no name, it asks with `pick` when that is installed and a terminal is attached, and otherwise lists the projects. When it picked the stack through its containers it prints the compose command it stands for on stderr.

package/dist/dc-cli.js

@@ -745,7 +745,7 @@ var {Glob } = globalThis.Bun;
 var SESSION_FILES = new Glob("*.json");
 var ACCOUNT_DIRS = new Glob("*/sessions");
 // package.json
-var version = "0.1.0";
+var version = "0.2.0";
 
 // src/dc.ts
 import process8 from "process";
@@ -890,6 +890,21 @@ async function commandFor(service, action) {
 function defaultAction(service) {
   return service.state === "running" ? "shell" : "up";
 }
+function stateColor(state) {
+  if (state === "running")
+    return "green";
+  if (state === "exited" || state === "dead")
+    return "red";
+  return state === "none" ? "dim" : "yellow";
+}
+async function serviceNamed(dir, name, project) {
+  const [recorded] = project === "" ? [] : await labels(project);
+  const stack = recorded === undefined ? stackAt(dir) : labelledStack(dir, recorded);
+  return (await services(stack)).find((candidate) => candidate.name === name);
+}
+async function logsOf(stack, name) {
+  return output(stack, ["logs", "--tail=30", "--no-log-prefix", name]);
+}
 
 // src/dc.ts
 var COMMANDS = new Set(["alpha", "attach", "bridge", "build", "commit", "config", "cp", "create", "down", "events", "exec", "export", "help", "images", "kill", "logs", "ls", "pause", "port", "ps", "publish", "pull", "push", "restart", "rm", "run", "scale", "start", "stats", "stop", "top", "unpause", "up", "version", "volumes", "wait", "watch"]);

package/dist/dx-cli.js

@@ -2,7 +2,7 @@
 // @bun
 
 // src/dx-cli.ts
-import process9 from "process";
+import process11 from "process";
 
 // ../kit/src/args.ts
 import process4 from "process";
@@ -745,14 +745,50 @@ var {Glob } = globalThis.Bun;
 var SESSION_FILES = new Glob("*.json");
 var ACCOUNT_DIRS = new Glob("*/sessions");
 // package.json
-var version = "0.1.0";
+var version = "0.2.0";
 
 // src/dx.ts
+import process10 from "process";
+
+// src/history.ts
+import { existsSync, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join2 } from "path";
 import process8 from "process";
+var REMEMBERED = 20;
+function historyFile() {
+  return join2(process8.env.XDG_CACHE_HOME ?? join2(homedir2(), ".cache"), "dx", "history.json");
+}
+function history() {
+  try {
+    const file = historyFile();
+    return existsSync(file) ? JSON.parse(readFileSync(file, "utf-8")) : {};
+  } catch {
+    return {};
+  }
+}
+function runs() {
+  return history()[process8.cwd()] ?? [];
+}
+function record(run) {
+  const all = history();
+  const file = historyFile();
+  all[process8.cwd()] = [run, ...(all[process8.cwd()] ?? []).filter((earlier) => earlier.id !== run.id)].slice(0, REMEMBERED);
+  mkdirSync2(dirname2(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(all));
+}
+function byRecency(items, previous, idOf) {
+  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)))];
+}
+
+// src/picker.ts
+import process9 from "process";
 
 // src/stack.ts
-import { existsSync, readdirSync, readFileSync } from "fs";
-import { dirname as dirname2, join as join2, relative, resolve } from "path";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname3, join as join3, relative, resolve } from "path";
 var LABEL_FORMAT = ["project", "project.config_files", "project.environment_file", "project.working_dir"].map((label) => `{{.Label "com.docker.compose.${label}"}}`).join("\t");
 var COMPOSE_FILE_VAR = /^\s*(?:export\s+)?COMPOSE_FILE\s*=\s*\S/m;
 var COMPOSE_FILES = ["compose.yaml", "compose.yml", "docker-compose.yaml", "docker-compose.yml"];
@@ -766,10 +802,10 @@ function children(dir = ".") {
 }
 function up(dir) {
   const dirs = [];
-  for (let current = dir;; current = join2(current, "..")) {
+  for (let current = dir;; current = join3(current, "..")) {
     dirs.push(current);
     const absolute = resolve(current);
-    if (existsSync(join2(current, ".git")) || dirname2(absolute) === absolute)
+    if (existsSync2(join3(current, ".git")) || dirname3(absolute) === absolute)
       return dirs;
   }
 }
@@ -777,10 +813,10 @@ function stackAt(dir) {
   return { dir, run: from(dir, ["docker", "compose"]), list: { argv: ["docker", "compose"], cwd: resolve(dir), env: process.env } };
 }
 function holdsStack(dir) {
-  if (COMPOSE_FILES.some((name) => existsSync(join2(dir, name))))
+  if (COMPOSE_FILES.some((name) => existsSync2(join3(dir, name))))
     return true;
   try {
-    return COMPOSE_FILE_VAR.test(readFileSync(join2(dir, ".env"), "utf-8"));
+    return COMPOSE_FILE_VAR.test(readFileSync2(join3(dir, ".env"), "utf-8"));
   } catch {
     return false;
   }
@@ -809,7 +845,7 @@ async function labels(project) {
   const proc = Bun.spawn(["docker", "ps", "--all", ...filter, "--format", LABEL_FORMAT], { stdout: "pipe", stderr: "ignore" });
   if (await proc.exited !== 0)
     return [];
-  return labelled(await new Response(proc.stdout).text()).filter((stack) => [...stack.files, ...stack.envFiles].every((file) => existsSync(file)));
+  return labelled(await new Response(proc.stdout).text()).filter((stack) => [...stack.files, ...stack.envFiles].every((file) => existsSync2(file)));
 }
 function labelledStack(dir, { project, files, envFiles, workdir }) {
   const options = (paths) => ["-p", project, ...files.flatMap((file) => ["-f", paths(file)]), ...envFiles.flatMap((file) => ["--env-file", paths(file)])];
@@ -890,26 +926,92 @@ async function commandFor(service, action) {
 function defaultAction(service) {
   return service.state === "running" ? "shell" : "up";
 }
+function stateColor(state) {
+  if (state === "running")
+    return "green";
+  if (state === "exited" || state === "dead")
+    return "red";
+  return state === "none" ? "dim" : "yellow";
+}
+async function serviceNamed(dir, name, project) {
+  const [recorded] = project === "" ? [] : await labels(project);
+  const stack = recorded === undefined ? stackAt(dir) : labelledStack(dir, recorded);
+  return (await services(stack)).find((candidate) => candidate.name === name);
+}
+async function logsOf(stack, name) {
+  return output(stack, ["logs", "--tail=30", "--no-log-prefix", name]);
+}
+
+// src/picker.ts
+var KEYS = { "ctrl-l": "logs", "ctrl-r": "restart", "ctrl-x": "stop", "ctrl-b": "build" };
+var KEY_LABELS = { "ctrl-l": "Logs", "ctrl-r": "Restart", "ctrl-x": "Stop", "ctrl-b": "Rebuild" };
+function row(service) {
+  const colors = paint(process9.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)]
+  };
+}
+function table(rows) {
+  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(`
+`);
+}
+function pickService(services) {
+  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",
+    `${process9.execPath} ${process9.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(`
+`);
+  const keyed = line?.split("\t")[2];
+  const service = services.find((candidate) => key(candidate) === keyed);
+  return service === undefined ? undefined : { service, key: pressed };
+}
 
 // src/dx.ts
 var usage2 = `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.`;
 var options = {
   json: jsonOption("[{ key, project, name, state, status, ports, image }]")
 };
-function stateColor(state) {
-  if (state === "running")
-    return "green";
-  if (state === "exited" || state === "dead")
-    return "red";
-  return state === "none" ? "dim" : "yellow";
-}
-function table(services) {
-  const colors = paint(process8.stdout);
+function table2(services) {
+  const colors = paint(process10.stdout);
   const keys = services.map(key);
   const width = Math.max(...keys.map((name) => name.length));
   const states = Math.max(...services.map((service) => service.state.length));
@@ -928,25 +1030,94 @@ function find(services, named) {
   const nearest = closest(named, services.map(key));
   return fail(`no service named ${named}${nearest === undefined ? "" : `, did you mean ${nearest}?`}`, 1);
 }
+function listed2(services) {
+  return byRecency(services, runs(), key).map((service) => ({
+    label: key(service),
+    hint: [service.state, service.ports, service.image].filter(Boolean).join(" \xB7 "),
+    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}` }))
+  }));
+}
+async function hidden(flag, rest, services) {
+  if (flag === "--list") {
+    console.log(JSON.stringify(listed2(services)));
+    return 0;
+  }
+  if (flag === "--names") {
+    console.log(services.map((service) => `${key(service)}	${service.state}`).join(`
+`));
+    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(process10.stdout);
+    console.log(`${colors[stateColor(service.state)](service.status || service.state)}  ${colors.dim(service.image)}${service.ports ? `  ${colors.cyan(service.ports)}` : ""}
+`);
+    console.log(await logsOf(service.stack, name));
+    return 0;
+  }
+  return;
+}
 async function dx(args) {
-  const parsed = parse(args, usage2, 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;
+  }
+  const emit = flag === "--emit";
+  const parsed = parse(emit ? args.slice(1) : args, usage2, 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;
+  let action;
   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 = process10.stdin.isTTY && process10.stderr.isTTY && parsed.values.json !== true;
+    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(table2(services));
+      return 0;
+    }
+    const picked = pickService(byRecency(services, runs(), key));
+    if (picked === undefined)
+      return 1;
+    service = picked.service;
+    action = KEYS[picked.key];
+  } else if (named === "-") {
+    const last = runs()[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];
+  } else {
+    service = find(services, named);
+    if (asked !== undefined && !ACTIONS.includes(asked))
+      fail(`no action ${asked}, one of ${ACTIONS.join(", ")}`);
+    action = asked;
+  }
+  const chosen = action ?? defaultAction(service);
+  const command = await commandFor(service, chosen);
+  record({ id: key(service), args: [chosen] });
+  if (emit) {
+    console.log(["run", action === undefined ? key(service) : `${key(service)} ${action}`, "", ...command.map((word) => `=${word}`)].join(`
+`));
     return 0;
   }
-  const service = find(services, named);
-  if (asked !== undefined && !ACTIONS.includes(asked))
-    fail(`no action ${asked}, one of ${ACTIONS.join(", ")}`);
-  const command = await commandFor(service, asked ?? defaultAction(service));
   return Bun.spawn(command, { stdio: ["inherit", "inherit", "inherit"] }).exited;
 }
 
 // src/dx-cli.ts
-process9.exitCode = await runMain({ name: "dx", version, run: dx });
+process11.exitCode = await runMain({ name: "dx", version, run: dx });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kaynooo/cli-docker",
   "type": "module",
-  "version": "0.1.0",
+  "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.",
   "author": "Kaynooo <contact@kaynooo.fr>",
   "license": "MIT",

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 './history'
+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(), 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(), key))
+
+    if (picked === undefined)
+      return 1
+
+    service = picked.service
+    action = KEYS[picked.key]
+  }
+  else if (named === '-') {
+    const last = runs()[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({ 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/history.ts

@@ -0,0 +1,48 @@
+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)))]
+}

package/src/picker.ts

@@ -0,0 +1,67 @@
+import type { Action, Service } from './stack'
+import process from 'node:process'
+import { paint } from '@kaynooo/cli-kit'
+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[] } {
+  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)],
+  }
+}
+
+// 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 }
+}

package/src/stack.ts

@@ -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])
+}