@kaynooo/cli-docker 0.1.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # docker
 
-Two docker compose helpers: `dc` runs compose on the stack found here, `dx` lists a stack's services and opens a shell in one, follows its logs, restarts, stops or rebuilds it.
+Three helpers: `dc` runs compose on the stack found here, `dx` lists a stack's services and opens a shell in one, follows its logs, restarts, stops or rebuilds it, `sf` picks a Symfony console command and runs it.
 
 ```sh
 bun install -g @kaynooo/cli-docker
@@ -12,8 +12,14 @@ 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` |
+| `sf` | picks a Symfony console command with fzf and runs it, asking for each required argument; the commands run last come first, and the picker opens on the list cached from the last run. It runs in the php service of the nearest compose stack, else with the local php. Without fzf or a terminal it lists the commands |
+| `sf -` | 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 |
+
+`sf` finds the nearest `bin/console` up to the repository root, then those of the child folders (keyed `api/cache:clear`).
 
 `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.3.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,115 @@ 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.3.0";
 
 // src/dx.ts
+import process10 from "process";
+
+// ../kit/src/fzf.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 table(rows) {
+  const widths = rows[0]?.cells.map((_, index) => Math.max(...rows.map((row) => Bun.stringWidth(row.cells[index])))) ?? [];
+  return rows.map((row) => [
+    ...row.hidden,
+    ...row.cells.map((cell, index) => index === row.cells.length - 1 ? cell.trimEnd() : `${cell}${" ".repeat(widths[index] + 1 - Bun.stringWidth(cell))}`)
+  ].join("\t"));
+}
+function fzf(rows, options) {
+  const hidden = options.hidden ?? rows[0]?.hidden.length ?? 0;
+  const proc = Bun.spawnSync([
+    "fzf",
+    "--prompt",
+    options.prompt,
+    ...options.header === undefined ? [] : ["--header", options.header],
+    ...(options.expect ?? []).length > 0 ? ["--expect", (options.expect ?? []).join(",")] : [],
+    "--ansi",
+    "--reverse",
+    "--height",
+    options.height ?? "100%",
+    "--delimiter",
+    "\t",
+    "--with-nth",
+    `${hidden + 1}..`,
+    "--nth",
+    `1..${options.searched}`,
+    "--tabstop",
+    "1",
+    "--tiebreak",
+    "chunk,index",
+    ...options.preview === undefined ? [] : ["--preview", options.preview, "--preview-window", "down,40%"],
+    ...(options.bind ?? []).flatMap((bind) => ["--bind", bind]),
+    ...options.query === true ? ["--print-query"] : []
+  ], {
+    stdin: new TextEncoder().encode(table(rows).join(`
+`)),
+    stdout: "pipe",
+    stderr: "inherit"
+  });
+  return picked(proc.stdout.toString(), hidden, options);
+}
+function picked(output, hidden, options) {
+  const lines = output.split(`
+`);
+  const query = options.query === true ? lines.shift() : "";
+  const [key, line] = (options.expect ?? []).length > 0 ? [lines[0], lines[1]] : ["", lines[0]];
+  if (line !== undefined && line !== "")
+    return { key, hidden: line.split("\t").slice(0, hidden), query };
+  return options.query === true && key !== "" ? { key, hidden: [], query } : undefined;
+}
+function heightFor(count) {
+  return String(Math.max(15, Math.ceil((count + 4) / 0.6)));
+}
+function historyFile(name) {
+  return join2(process8.env.XDG_CACHE_HOME ?? join2(homedir2(), ".cache"), name, "history.json");
+}
+function history(name) {
+  try {
+    const file = historyFile(name);
+    return existsSync(file) ? JSON.parse(readFileSync(file, "utf-8")) : {};
+  } catch {
+    return {};
+  }
+}
+function runs(name) {
+  return history(name)[process8.cwd()] ?? [];
+}
+function record(name, run) {
+  const all = history(name);
+  const file = historyFile(name);
+  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)))];
+}
+function word(arg) {
+  if (typeof arg === "string")
+    return `=${arg}`;
+  return "given" in arg ? `+${arg.given}` : `?${arg.ask}`;
+}
+function emit(mode, typed, recorded, command) {
+  const words = command.map(word);
+  console.log([mode, typed, recorded, ...words].join(`
+`));
+}
+function list(rows) {
+  console.log(JSON.stringify(rows));
+}
+
+// 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 +867,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 +878,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 +910,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 +991,62 @@ 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 pickService(services) {
+  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: `${process9.execPath} ${process9.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 };
+}
 
 // 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 +1065,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("dx"), 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("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];
+  } 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("dx", { 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 });