@wpelevator/tug 0.11.0 → 0.13.0

package/dist/commands/node.js

@@ -1,13 +1,15 @@
+import { selectNodes, selectNode } from "./selection.js";
+import { withProgress } from "../cli-progress.js";
 import { applyConfigDefaults, normalizeControlUrl, nodeSettings } from "../cli-config.js";
 import { formatNodes } from "../cli-status.js";
 import { dockerRunSnippet, enrollmentCloudInit, shellQuote as sh, HOST_NETWORK_FLAG, } from "../cli-install.js";
 import { formatNodePlan, inferNodeName, isValidNodeName } from "../cli-onboarding.js";
 import { ask, canPrompt, choose, confirm } from "../cli-prompt.js";
 import { isNodeHost } from "../node-address.js";
-import { resolveImage } from "../image.js";
+import { assertImagePublished, resolveImage } from "../image.js";
 import { errMessage, loadTemplate } from "../util.js";
 import { collect, loadCfg, print, readStdin, request, runCapture, runLocal, templatesDir, transportFor, } from "./context.js";
-import { bootstrapDocker, discoverAddresses, remoteHostname, dockerBootstrap, hostHasDocker, preflightRemote, transferTugImage, } from "./host.js";
+import { bootstrapDocker, discoverAddresses, remoteHostname, dockerBootstrap, hostHasDocker, preflightRemote, teardownScript, transferTugImage, } from "./host.js";
 import fs from 'node:fs/promises';
 const AGENT_STATE = '/var/lib/tug';
 function addNodeIdentityOptions(command) {
@@ -28,61 +30,70 @@ function addNodeIdentityOptions(command) {
 async function installNodeIdentity(sshTarget, name, mode, o, repair = false, 
 /** False in batch mode, where only the final per-node results are printed. */
 printResult = true) {
-    const cfg = await loadCfg();
-    const connectUrl = o.agentControlUrl ? normalizeControlUrl(o.agentControlUrl) : undefined;
-    await transportFor(cfg).then((t) => t.close()); // fail before touching the host when there is no credential
-    if (o.installDocker)
-        await bootstrapDocker(sshTarget);
-    preflightRemote(sshTarget, {
-        controlUrl: connectUrl ?? cfg.credential?.url,
-    });
-    const image = resolveImage(o.image, o.buildLocalImage);
-    if (o.buildLocalImage)
-        await transferTugImage(sshTarget, image);
-    const started = new Date().toISOString();
-    if (repair)
-        runLocal('ssh', [
-            '--',
-            sshTarget,
-            `mkdir -p ${AGENT_STATE} && cd ${AGENT_STATE} && for f in agent.json agent-pending.json; do [ -e "$f" ] && mv "$f" "$f.corrupt-$(date +%s)"; done; true`,
-        ]);
-    const agent = (command, interactive = false) => `mkdir -p ${AGENT_STATE} && docker run --rm ${interactive ? '-i ' : ''}-v ${AGENT_STATE}:${AGENT_STATE} ${sh(image)} agent ${command}`;
-    const csr = runCapture('ssh', ['--', sshTarget, agent('identity')]);
-    const response = await request('POST', `/api/v1/nodes/${encodeURIComponent(name)}/identity`, { csr, mode, address: o.address, labels: o.label });
-    runCapture('ssh', ['--', sshTarget, agent('install-cert', true)], {
-        input: JSON.stringify(response),
-    });
-    const env = await loadTemplate(templatesDir, 'agent.env', {
-        CONTROL_URL_LINE: connectUrl ? `TUG_CONTROL_URL=${connectUrl}\n` : '',
-        NODE_NAME: name,
-    });
-    const remote = await loadTemplate(templatesDir, 'node-install.sh', {
-        ENV: env,
-        IMAGE_SH: sh(image),
-        RUN_FLAGS: `${HOST_NETWORK_FLAG} `,
-    });
-    runLocal('ssh', ['--', sshTarget, remote]);
-    if (o.ingress)
-        await request('POST', `/api/v1/nodes/${encodeURIComponent(name)}/ingress`, { enabled: true });
-    const result = { ok: true, node: response.node, ...(o.ingress ? { ingress: true } : {}) };
-    let reporting = !o.wait;
-    if (o.wait) {
-        // A report from the new identity: wait for a report after the install began, not a replaced node's stale status.
-        for (let i = 0; i < 30; i++) {
-            const { nodes } = await request('GET', '/api/v1/nodes');
-            const seen = nodes.find((n) => n.name === name)?.last_seen_at;
-            if (seen && seen > started) {
-                reporting = true;
-                break;
+    return withProgress(`Preparing node ${name}`, async (progress) => {
+        const cfg = await loadCfg();
+        const connectUrl = o.agentControlUrl ? normalizeControlUrl(o.agentControlUrl) : undefined;
+        await transportFor(cfg).then((t) => t.close()); // fail before touching the host when there is no credential
+        assertImagePublished(resolveImage(o.image, o.buildLocalImage));
+        if (o.installDocker) {
+            progress.stage(`Installing Docker on node ${name}`);
+            await bootstrapDocker(sshTarget);
+        }
+        progress.stage(`Checking host ${name}`);
+        await preflightRemote(sshTarget, {
+            controlUrl: connectUrl ?? cfg.credential?.url,
+        });
+        const image = resolveImage(o.image, o.buildLocalImage);
+        if (o.buildLocalImage)
+            await transferTugImage(sshTarget, image, progress.stage);
+        const started = new Date().toISOString();
+        if (repair)
+            await runLocal('ssh', [
+                '--',
+                sshTarget,
+                `mkdir -p ${AGENT_STATE} && cd ${AGENT_STATE} && for f in agent.json agent-pending.json; do [ -e "$f" ] && mv "$f" "$f.corrupt-$(date +%s)"; done; true`,
+            ]);
+        const agent = (command, interactive = false) => `mkdir -p ${AGENT_STATE} && docker run --rm ${interactive ? '-i ' : ''}-v ${AGENT_STATE}:${AGENT_STATE} ${sh(image)} agent ${command}`;
+        progress.stage(`Creating identity for node ${name}`);
+        const csr = await runCapture('ssh', ['--', sshTarget, agent('identity')]);
+        const response = await request('POST', `/api/v1/nodes/${encodeURIComponent(name)}/identity`, { csr, mode, address: o.address, labels: o.label });
+        await runCapture('ssh', ['--', sshTarget, agent('install-cert', true)], {
+            input: JSON.stringify(response),
+        });
+        const env = await loadTemplate(templatesDir, 'agent.env', {
+            CONTROL_URL_LINE: connectUrl ? `TUG_CONTROL_URL=${connectUrl}\n` : '',
+            NODE_NAME: name,
+        });
+        progress.stage(`Installing agent on node ${name}`);
+        const remote = await loadTemplate(templatesDir, 'node-install.sh', {
+            ENV: env,
+            IMAGE_SH: sh(image),
+            RUN_FLAGS: `${HOST_NETWORK_FLAG} `,
+        });
+        await runLocal('ssh', ['--', sshTarget, remote]);
+        if (o.ingress)
+            await request('POST', `/api/v1/nodes/${encodeURIComponent(name)}/ingress`, { enabled: true });
+        const result = { ok: true, node: response.node, ...(o.ingress ? { ingress: true } : {}) };
+        let reporting = !o.wait;
+        if (o.wait) {
+            progress.stage(`Waiting for node ${name} to report`);
+            // A report from the new identity: wait for a report after the install began, not a replaced node's stale status.
+            for (let i = 0; i < 30; i++) {
+                const { nodes } = await request('GET', '/api/v1/nodes');
+                const seen = nodes.find((n) => n.name === name)?.last_seen_at;
+                if (seen && seen > started) {
+                    reporting = true;
+                    break;
+                }
+                await new Promise((r) => setTimeout(r, 2000));
             }
-            await new Promise((r) => setTimeout(r, 2000));
+            if (!reporting)
+                console.error(`node ${name} has not reported yet; check \`docker logs tug-agent\` on the host`);
         }
-        if (!reporting)
-            console.error(`node ${name} has not reported yet; check \`docker logs tug-agent\` on the host`);
-    }
-    if (printResult)
-        print(o.wait ? { ...result, reporting } : result);
-    return reporting;
+        if (printResult)
+            print(o.wait ? { ...result, reporting } : result);
+        return reporting;
+    });
 }
 const realPlanDeps = () => ({
     interactive: canPrompt(),
@@ -147,11 +158,17 @@ async function promptNodeName(sshTarget) {
 async function runNodeIdentity(positional, o, mode, command, repair = false) {
     const cfg = await loadCfg();
     const verb = repair ? 'node repair' : mode === 'create' ? 'node add' : 'node replace';
-    if (o.all) {
+    if (o.select && o.all)
+        throw new Error('--select and --all cannot be combined');
+    if (o.all || o.select) {
         if (positional.name || positional.ssh)
-            throw new Error(`${verb} --all walks every configured node; do not name one`);
+            throw new Error(`${verb} --all/--select cannot be combined with a node or SSH target`);
         const results = [];
-        for (const [name, settings] of Object.entries(cfg.nodes)) {
+        const names = o.select
+            ? await selectNodes(Object.keys(cfg.nodes).filter((name) => cfg.nodes[name].ssh))
+            : Object.keys(cfg.nodes);
+        for (const name of names) {
+            const settings = cfg.nodes[name];
             const target = settings.ssh;
             if (!target)
                 continue;
@@ -171,17 +188,17 @@ async function runNodeIdentity(positional, o, mode, command, repair = false) {
         return;
     }
     let name = positional.name ?? (positional.ssh ? inferNodeName(positional.ssh) : undefined);
+    if (!name && mode === 'replace')
+        name = await selectNode();
     if (!name && mode === 'create')
         name = await promptNodeName(positional.ssh);
     if (!name)
         throw new Error(mode === 'create'
             ? `${verb} needs --name${positional.ssh ? ' (an IP address does not suggest one; in a terminal it asks)' : ''}`
             : `${verb} needs the node name`);
-    if (mode === 'create') {
-        // The name may have come from the SSH host, after the config defaults were applied without one.
-        o.name = name;
-        applyConfigDefaults(command, o, nodeSettings(cfg, name));
-    }
+    // Selection or SSH inference may supply the name after the root hook applied defaults.
+    o.name = name;
+    applyConfigDefaults(command, o, nodeSettings(cfg, name));
     const sshTarget = positional.ssh ?? nodeSettings(cfg, name).ssh;
     if (!sshTarget)
         throw new Error(`${verb} needs an SSH target: pass <ssh-target> or set nodes.${name}.ssh in ${cfg.file}`);
@@ -216,7 +233,9 @@ export function registerNode(program) {
     ]) {
         addNodeIdentityOptions(node
             .command(`${verb} [name] [sshTarget]`)
-            .description(`${description} (the SSH target defaults to nodes.<name>.ssh in the config file; --all walks every configured node)`)).action(async (name, ssh, o, command) => runNodeIdentity({ name, ssh }, o, 'replace', command, repair));
+            .description(`${description} (the SSH target defaults to nodes.<name>.ssh in the config file; --all walks every configured node)`))
+            .option('--select', 'choose registered nodes with configured SSH targets')
+            .action(async (name, ssh, o, command) => runNodeIdentity({ name, ssh }, o, 'replace', command, repair));
     }
     node
         .command('list')
@@ -298,23 +317,70 @@ export function registerNode(program) {
         print(await request('POST', `/api/v1/nodes/${encodeURIComponent(name)}/identity`, { csr, mode: o.mode, address: o.address, labels: o.label }));
     });
     node
-        .command('address <name> <address>')
+        .command('address [name] [address]')
+        .option('--to <address>', 'new address when choosing a node interactively')
         .description("update a node's inter-node address")
-        .action(async (name, address) => print(await request('POST', `/api/v1/nodes/${encodeURIComponent(name)}/address`, { address })));
+        .action(async (name, address, o) => {
+        if (address && o.to)
+            throw new Error('pass the address positionally or with --to, not both');
+        address = address || o.to || '';
+        if (!address)
+            throw new Error('node address needs an address; use --to when selecting a node');
+        name = await selectNode(name);
+        return print(await request('POST', `/api/v1/nodes/${encodeURIComponent(name)}/address`, { address }));
+    });
     node
-        .command('disable <name>')
+        .command('disable [name]')
         .description("block a node's key immediately without deleting its metadata or placement (no SSH needed); bring it back with node replace")
-        .action(async (name) => print(await request('POST', `/api/v1/nodes/${encodeURIComponent(name)}/disable`, {})));
+        .action(async (name) => print(await request('POST', `/api/v1/nodes/${encodeURIComponent(await selectNode(name))}/disable`, {})));
     node
-        .command('remove <name>')
-        .description('remove a retired node from the control plane (its identity, statuses and queued commands); stop its agent and remove its containers on the host yourself')
+        .command('remove [name] [sshTarget]')
+        .description('remove a retired node from the control plane (its identity, statuses and queued commands); with --teardown also stop its agent and delete its containers and agent state over SSH')
         .option('--force', 'remove even if the node is still reporting')
-        .action(async (name, o) => print(await request('DELETE', `/api/v1/nodes/${encodeURIComponent(name)}${o.force ? '?force=true' : ''}`)));
+        .option('--teardown', 'also clean the host over SSH (the SSH target defaults to nodes.<name>.ssh in the config file)')
+        .option('--delete-data', 'with --teardown, also delete project volumes and ingress certificates')
+        .option('-y, --yes', 'with --teardown, do not ask for confirmation')
+        .action(async (name, ssh, o) => {
+        if (!o.teardown) {
+            if (ssh || o.deleteData || o.yes)
+                throw new Error('an SSH target, --delete-data and --yes need --teardown');
+            name = await selectNode(name);
+            return print(await request('DELETE', `/api/v1/nodes/${encodeURIComponent(name)}${o.force ? '?force=true' : ''}`));
+        }
+        name = await selectNode(name);
+        const cfg = await loadCfg();
+        const sshTarget = ssh ?? nodeSettings(cfg, name).ssh;
+        if (!sshTarget)
+            throw new Error(`--teardown needs an SSH target: pass <ssh-target> or set nodes.${name}.ssh in ${cfg.file}`);
+        if (!o.yes) {
+            if (!canPrompt())
+                throw new Error('--teardown deletes data on the host; pass -y to confirm without a terminal');
+            console.error(`This will stop the Tug agent on ${sshTarget}, remove its Tug containers and networks and delete /etc/tug and /var/lib/tug${o.deleteData
+                ? ', and DELETE every project volume and the ingress certificates'
+                : ' (project volumes are kept)'}.`);
+            if (!(await confirm('Continue?', false)))
+                throw new Error('cancelled');
+        }
+        // The control record goes first: it refuses a node that is still placed in a current deployment before any
+        // host is touched. A node control no longer knows is cleaned anyway, so a failed cleanup can be retried.
+        let removed = { ok: true, node: name, alreadyRemoved: true };
+        try {
+            removed = await request('DELETE', `/api/v1/nodes/${encodeURIComponent(name)}?force=true`);
+        }
+        catch (error) {
+            if (!/node not found/.test(errMessage(error)))
+                throw error;
+        }
+        await withProgress(`Cleaning node host ${sshTarget}`, async () => {
+            await runLocal('ssh', ['--', sshTarget, teardownScript(Boolean(o.deleteData))]);
+        });
+        print({ ...removed, teardown: sshTarget, deleteData: Boolean(o.deleteData) });
+    });
     node
-        .command('ingress <name>')
+        .command('ingress [name]')
         .description('mark a node as an ingress node (managed Caddy on ports 80/443), or remove the role with --disable')
         .option('--disable', 'stop acting as an ingress node')
-        .action(async (name, o) => print(await request('POST', `/api/v1/nodes/${encodeURIComponent(name)}/ingress`, {
+        .action(async (name, o) => print(await request('POST', `/api/v1/nodes/${encodeURIComponent(await selectNode(name))}/ingress`, {
         enabled: !o.disable,
     })));
 }

package/dist/commands/observe.js

@@ -1,3 +1,4 @@
+import { selectNode } from "./selection.js";
 import { errMessage } from "../util.js";
 import { formatStatus } from "../cli-status.js";
 import { loadCfg, print, request, runCapture, waitForCommand } from "./context.js";
@@ -27,9 +28,13 @@ export function registerObserve(program) {
         .command('doctor')
         .description('check this machine and the control plane: certificate expiry, node connectivity and clock skew')
         .option('--nodes', 'also run host diagnostics on every node through its agent and wait')
-        .option('--node <name>', 'run host diagnostics on one node through its agent and wait')
+        .option('--node [name]', 'run host diagnostics on one node through its agent and wait')
         .option('--timeout <seconds>', 'wait timeout for node diagnostics', '60')
         .action(async (o) => {
+        if (o.nodes && o.node)
+            throw new Error('--nodes and --node cannot be combined');
+        if (o.node === true)
+            o.node = await selectNode();
         const local = [];
         for (const [name, cmd, args] of [
             ['node', 'node', ['--version']],
@@ -37,7 +42,7 @@ export function registerObserve(program) {
             ['docker_compose', 'docker', ['compose', 'version']],
         ]) {
             try {
-                local.push({ name, ok: true, output: runCapture(cmd, args).trim() });
+                local.push({ name, ok: true, output: (await runCapture(cmd, args)).trim() });
             }
             catch (e) {
                 local.push({ name, ok: false, error: errMessage(e) });

package/dist/commands/restore.js

@@ -1,11 +1,16 @@
+import { selectMany } from "../cli-selection.js";
+import { selectBackup, selectRestore, selectSnapshot, serviceChoices } from "./selection.js";
+import { withProgress } from "../cli-progress.js";
 import { collect, loadCfg, request } from "./context.js";
 export function registerRestore(program) {
     const restore = program
         .command('restore')
         .description('restore services and volumes from backups');
     restore
-        .command('run <target>')
+        .command('run [target]')
         .description('restore a service or volume from a backup. Without --confirm it only prints the plan. An in-place restore locks the project, stops the services that write to the target, takes a safety backup, restores, then starts them again')
+        .option('--select-snapshot', 'choose a successful backup from the catalog')
+        .option('--select-writers', 'choose services to stop instead of discovering writers')
         .option('--from <id>', 'backup run id, restic snapshot id, or latest', 'latest')
         .option('--scratch', 'restore a volume into a new volume next to the live one, touching nothing live')
         .option('--no-safety-backup', 'skip the backup of the current data taken before an in-place restore')
@@ -13,55 +18,71 @@ export function registerRestore(program) {
         .option('--no-writers', 'restore without stopping any service')
         .option('--confirm', 'perform the restore')
         .option('--timeout <seconds>', 'give up waiting after this many seconds', '3600')
-        .action(async (target, o) => {
-        const project = (await loadCfg()).project || 'site';
-        const explicit = Array.isArray(o.writers) && o.writers.length > 0 ? o.writers : undefined;
-        const result = await request('POST', '/api/v1/restores', {
-            project,
-            target,
-            from: o.from,
-            scratch: o.scratch === true,
-            safetyBackup: o.safetyBackup,
-            writers: explicit,
-            noWriters: o.writers === false,
-            confirm: o.confirm === true,
-        });
-        const plan = result.plan;
-        console.log(`target:   ${plan.target} on ${plan.node}`);
-        console.log(`snapshot: ${plan.snapshotId}${plan.snapshotTime ? ` (${plan.snapshotTime})` : ''}`);
-        console.log(`mode:     ${plan.mode}${plan.scratchVolume ? ` into new volume ${plan.scratchVolume}` : ''}`);
-        if (plan.mode === 'in-place') {
-            console.log(`stops:    ${plan.writers.length ? plan.writers.join(', ') : 'nothing'}`);
-            console.log(`safety:   ${plan.safetyBackup ? 'a backup of the current data is taken first' : 'none (--no-safety-backup)'}`);
-        }
-        if (!result.confirmed) {
-            console.log('\nNothing was changed. Run again with --confirm to restore.');
-            return;
-        }
-        const deadline = Date.now() + Number(o.timeout) * 1000;
-        for (;;) {
-            await new Promise((resolve) => setTimeout(resolve, 2000));
-            const { restores } = await request('GET', `/api/v1/restores?project=${encodeURIComponent(project)}`);
-            const record = restores.find((item) => item.id === result.restoreId);
-            if (record?.state === 'succeeded') {
-                if (record.error)
-                    console.error(`warning: ${record.error}`);
-                console.log(`restore ${record.id} completed${record.scratch_volume ? `; files are in volume ${record.scratch_volume}` : ''}`);
-                return;
+        .action(async (target, o, command) => {
+        if (o.selectSnapshot && command.getOptionValueSource('from') === 'cli')
+            throw new Error('--select-snapshot cannot be combined with --from');
+        if (o.selectWriters && (o.writers === false || o.writers.length))
+            throw new Error('--select-writers cannot be combined with --writers or --no-writers');
+        if (o.scratch && o.selectWriters)
+            throw new Error('--select-writers does not apply to scratch restores');
+        target = await selectBackup(target);
+        if (o.selectSnapshot)
+            o.from = await selectSnapshot(target);
+        if (o.selectWriters)
+            o.writers = await selectMany('Select services to stop for the restore', serviceChoices);
+        return withProgress(`Preparing restore for ${target}`, async (progress) => {
+            const project = (await loadCfg()).project || 'site';
+            const explicit = Array.isArray(o.writers) && o.writers.length > 0 ? o.writers : undefined;
+            const result = await request('POST', '/api/v1/restores', {
+                project,
+                target,
+                from: o.from,
+                scratch: o.scratch === true,
+                safetyBackup: o.safetyBackup,
+                writers: explicit,
+                noWriters: o.writers === false,
+                confirm: o.confirm === true,
+            });
+            const plan = result.plan;
+            console.log(`target:   ${plan.target} on ${plan.node}`);
+            console.log(`snapshot: ${plan.snapshotId}${plan.snapshotTime ? ` (${plan.snapshotTime})` : ''}`);
+            console.log(`mode:     ${plan.mode}${plan.scratchVolume ? ` into new volume ${plan.scratchVolume}` : ''}`);
+            if (plan.mode === 'in-place') {
+                console.log(`stops:    ${plan.writers.length ? plan.writers.join(', ') : 'nothing'}`);
+                console.log(`safety:   ${plan.safetyBackup ? 'a backup of the current data is taken first' : 'none (--no-safety-backup)'}`);
             }
-            if (record && ['failed', 'interrupted', 'released'].includes(record.state)) {
-                console.error(`restore ${record.id} ${record.state}: ${record.error ?? ''}`);
-                if (record.state === 'interrupted')
-                    console.error(`the services stay stopped; run tug restore resume ${record.id} to try again or tug restore release ${record.id} to start them (data may be partly restored)`);
-                process.exitCode = 1;
+            if (!result.confirmed) {
+                console.log('\nNothing was changed. Run again with --confirm to restore.');
                 return;
             }
-            if (Date.now() > deadline) {
-                console.error(`timed out waiting; restore ${result.restoreId} continues on control (tug restore list)`);
-                process.exitCode = 1;
-                return;
+            progress.stage(`Restore ${result.restoreId}: queued`);
+            const deadline = Date.now() + Number(o.timeout) * 1000;
+            for (;;) {
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+                const { restores } = await request('GET', `/api/v1/restores?project=${encodeURIComponent(project)}`);
+                const record = restores.find((item) => item.id === result.restoreId);
+                if (record)
+                    progress.stage(`Restore ${record.id}: ${record.state}`);
+                if (record?.state === 'succeeded') {
+                    if (record.error)
+                        console.error(`warning: ${record.error}`);
+                    console.log(`restore ${record.id} completed${record.scratch_volume ? `; files are in volume ${record.scratch_volume}` : ''}`);
+                    return;
+                }
+                if (record && ['failed', 'interrupted', 'released'].includes(record.state)) {
+                    console.error(`restore ${record.id} ${record.state}: ${record.error ?? ''}`);
+                    if (record.state === 'interrupted')
+                        console.error(`the services stay stopped; run tug restore resume ${record.id} to try again or tug restore release ${record.id} to start them (data may be partly restored)`);
+                    process.exitCode = 1;
+                    return;
+                }
+                if (Date.now() > deadline) {
+                    console.error(`timed out waiting; restore ${result.restoreId} continues on control (tug restore list)`);
+                    process.exitCode = 1;
+                    return;
+                }
             }
-        }
+        });
     });
     restore
         .command('list')
@@ -75,11 +96,11 @@ export function registerRestore(program) {
             console.log(`${r.started_at}\t${r.id}\t${r.target}\t${r.mode}\t${r.state}\t${r.snapshot_id.slice(0, 8)}${r.error ? `\t${r.error}` : ''}`);
     });
     restore
-        .command('resume <id>')
+        .command('resume [id]')
         .description('run an interrupted restore again; the stopped services stay stopped meanwhile')
-        .action(async (id) => console.log(JSON.stringify(await request('POST', `/api/v1/restores/${encodeURIComponent(id)}/resume`))));
+        .action(async (id) => console.log(JSON.stringify(await request('POST', `/api/v1/restores/${encodeURIComponent(await selectRestore(id))}/resume`))));
     restore
-        .command('release <id>')
+        .command('release [id]')
         .description('start the services an interrupted restore stopped and unlock the project; the data may be partly restored')
-        .action(async (id) => console.log(JSON.stringify(await request('POST', `/api/v1/restores/${encodeURIComponent(id)}/release`))));
+        .action(async (id) => console.log(JSON.stringify(await request('POST', `/api/v1/restores/${encodeURIComponent(await selectRestore(id))}/release`))));
 }

package/dist/commands/secret.js

@@ -1,3 +1,4 @@
+import { selectResource } from "./selection.js";
 import { print, projectOf, request } from "./context.js";
 export function registerSecret(program) {
     const secret = program
@@ -11,7 +12,11 @@ export function registerSecret(program) {
         const value = o.value ??
             (await new Promise((resolve) => {
                 process.stdout.write(`${name}: `);
-                process.stdin.once('data', (d) => resolve(String(d).trim()));
+                process.stdin.once('data', (d) => {
+                    // This command needs no more input; an open stdin can otherwise keep Node alive.
+                    process.stdin.destroy();
+                    resolve(String(d).trim());
+                });
             }));
         print(await request('POST', '/api/v1/secrets', { project: await projectOf(o), name, value }));
     });
@@ -20,7 +25,7 @@ export function registerSecret(program) {
         .description('list secret names and versions, never values')
         .action(async (o) => print(await request('GET', `/api/v1/secrets?project=${encodeURIComponent(await projectOf(o))}`)));
     secret
-        .command('remove <name>')
+        .command('remove [name]')
         .description('delete a secret')
-        .action(async (name, o) => print(await request('DELETE', `/api/v1/secrets/${encodeURIComponent(name)}?project=${encodeURIComponent(await projectOf(o))}`)));
+        .action(async (name, o) => print(await request('DELETE', `/api/v1/secrets/${encodeURIComponent(await selectResource(name, 'secrets'))}?project=${encodeURIComponent(await projectOf(o))}`)));
 }

package/dist/commands/selection.d.ts

@@ -0,0 +1,22 @@
+import type { Choice } from '../cli-selection.ts';
+export declare const projectQuery: () => Promise<string>;
+export interface ServiceChoice {
+    name: string;
+    nodes: {
+        name: string;
+        status: string;
+    }[];
+}
+export declare function services(): Promise<ServiceChoice[]>;
+export declare const serviceChoices: () => Promise<Choice[]>;
+export declare const selectService: (name?: string) => Promise<string>;
+export declare const selectNode: (name?: string) => Promise<string>;
+export declare const selectResource: (name: string | undefined, resource: "secrets" | "volumes" | "credentials") => Promise<string>;
+export declare const selectDeployment: (id?: string) => Promise<string>;
+export declare const selectRestore: (id?: string) => Promise<string>;
+export declare const backupChoices: () => Promise<Choice[]>;
+export declare const selectBackup: (target?: string) => Promise<string>;
+export declare const selectBackups: () => Promise<string[]>;
+export declare const selectSnapshot: (target: string) => Promise<string>;
+export declare const selectHolds: () => Promise<string[]>;
+export declare const selectNodes: (configured: string[]) => Promise<string[]>;

package/dist/commands/selection.js

@@ -0,0 +1,90 @@
+import { selectMany, selectOne } from "../cli-selection.js";
+import { projectOf, request } from "./context.js";
+export const projectQuery = async () => `project=${encodeURIComponent(await projectOf({}))}`;
+export async function services() {
+    return (await request('GET', `/api/v1/services?${await projectQuery()}`)).services;
+}
+export const serviceChoices = async () => (await services()).map((service) => ({
+    value: service.name,
+    label: `${service.name} (${service.nodes.map((node) => `${node.name}: ${node.status}`).join(', ') || 'no nodes'})`,
+}));
+export const selectService = (name) => selectOne(name, 'Select a service', serviceChoices);
+export const selectNode = (name) => selectOne(name, 'Select a node', async () => {
+    const { nodes } = await request('GET', '/api/v1/nodes');
+    return nodes.map((node) => ({
+        value: node.name,
+        label: `${node.name} (${node.disabled_at ? 'disabled' : node.status}, ${node.address || 'no address'}${node.ingress ? ', ingress' : ''}${node.labels.length ? `, ${node.labels.join(', ')}` : ''})`,
+    }));
+});
+export const selectResource = (name, resource) => selectOne(name, `Select a ${resource.slice(0, -1)}`, async () => {
+    const listing = await request('GET', `/api/v1/${resource}${resource === 'credentials' ? '' : `?${await projectQuery()}`}`);
+    return listing[resource]
+        .filter((row) => !row.revokedAt && !row.usedBy?.length)
+        .map((row) => {
+        const details = [
+            row.version !== undefined ? `version ${row.version}` : '',
+            row.node || row.node_id,
+            row.type,
+            row.persistent ? 'persistent; needs --delete-data' : '',
+            row.role,
+            row.lastUsedAt ? `last used ${row.lastUsedAt}` : '',
+            row.projects === null ? 'all projects' : row.projects?.join(', '),
+            row.expiresAt ? `expires ${row.expiresAt}` : '',
+        ]
+            .filter(Boolean)
+            .join(', ');
+        return { value: row.name, label: details ? `${row.name} (${details})` : row.name };
+    });
+});
+export const selectDeployment = (id) => selectOne(id, 'Select an active deployment to cancel', async () => {
+    const { deployments } = await request('GET', `/api/v1/deployments?${await projectQuery()}`);
+    return deployments.map((row) => ({
+        value: row.id,
+        label: `${row.version} (${row.state}, ${row.created_at}, ${row.id})`,
+    }));
+});
+export const selectRestore = (id) => selectOne(id, 'Select an interrupted restore', async () => {
+    const { restores } = await request('GET', `/api/v1/restores?${await projectQuery()}&state=interrupted`);
+    return restores
+        .filter((row) => row.state === 'interrupted')
+        .map((row) => ({
+        value: row.id,
+        label: `${row.target} (${row.started_at}, snapshot ${row.snapshot_id}, ${row.id}${row.error ? `, ${row.error}` : ''})`,
+    }));
+});
+export const backupChoices = async () => {
+    const { targets } = await request('GET', `/api/v1/backups?${await projectQuery()}`);
+    return targets
+        .filter((row) => row.enabled)
+        .map((row) => ({
+        value: row.target,
+        label: `${row.target} (${row.node || 'no node'}, last success ${row.lastSuccessAt || 'never'})`,
+    }));
+};
+export const selectBackup = (target) => selectOne(target, 'Select a backup target', backupChoices);
+export const selectBackups = () => selectMany('Select backup targets', backupChoices);
+export const selectSnapshot = (target) => selectOne(undefined, 'Select a backup snapshot', async () => {
+    // Resolve short target names the same way as the restore endpoint, but reject ambiguity.
+    const targets = await backupChoices();
+    const matching = targets.filter((row) => row.value === target || row.value.split(':').slice(1).join(':') === target);
+    if (matching.length !== 1)
+        throw new Error(`use a full backup target such as service:${target} or volume:${target}`);
+    const { snapshots } = await request('GET', `/api/v1/backup/snapshots?${await projectQuery()}&target=${encodeURIComponent(matching[0].value)}`);
+    return snapshots.map((row) => ({
+        value: row.id,
+        label: `${row.finished_at} (${row.snapshot_id}, ${row.size_bytes ?? '?'} bytes, ${row.trigger}, ${row.id})`,
+    }));
+});
+export const selectHolds = () => selectMany('Select move holds to release', async () => {
+    const { holds } = await request('GET', `/api/v1/holds?${await projectQuery()}`);
+    return holds.map((row) => ({
+        value: row.service,
+        label: `${row.service} (${row.reason}, ${row.created_at})`,
+    }));
+});
+export const selectNodes = (configured) => selectMany('Select nodes to replace or repair', async () => {
+    const { nodes } = await request('GET', '/api/v1/nodes');
+    return nodes
+        .filter((node) => configured.includes(node.name))
+        .map((node) => ({ value: node.name, label: `${node.name} (${node.status})` }));
+});