@wpelevator/tug 0.12.0 → 0.13.0

package/dist/commands/control.js

@@ -1,7 +1,8 @@
-import { spawnSync } from 'node:child_process';
+import { withProgress } from "../cli-progress.js";
+import { runProcess } from "../cli-process.js";
 import { canPrompt, confirm } from "../cli-prompt.js";
 import { CONTROL_CONTAINER, defaultControlUrl, shellQuote as sh } from "../cli-install.js";
-import { resolveImage } from "../image.js";
+import { assertImagePublished, resolveImage } from "../image.js";
 import { decodeCredential, writeFileDurable } from "../pki.js";
 import { loadTemplate } from "../util.js";
 import { collect, loadCfg, print, request, runLocal, templatesDir } from "./context.js";
@@ -36,6 +37,7 @@ function addSetup(parent, description) {
             o.installDocker = await confirm(`Docker with the Compose plugin is not installed on ${sshTarget}. Install it now (needs root)?`);
         }
         const image = resolveImage(o.image, o.buildLocalImage);
+        assertImagePublished(image);
         console.error([
             'Control plan',
             `  host:        ${sshTarget}`,
@@ -47,45 +49,56 @@ function addSetup(parent, description) {
         ].join('\n'));
         if (interactive && !o.yes && !(await confirm('Install the control plane?')))
             throw new Error('cancelled; nothing was changed');
-        if (o.installDocker)
-            await bootstrapDocker(sshTarget, true);
-        preflightRemote(sshTarget, { ports: [Number(o.port)], minDiskMb: 2048, compose: true });
-        if (o.buildLocalImage)
-            await transferTugImage(sshTarget, image);
-        const yamlValue = (value) => JSON.stringify(value);
-        const compose = await loadTemplate(templatesDir, 'control-compose.yml', {
-            IMAGE: yamlValue(image),
-            CONTROL_URL: yamlValue(new URL(controlUrl).origin),
-            EXTRA_SANS: yamlValue(o.extraSan.join(',')),
-            PORT: o.port,
-        });
-        const remote = await loadTemplate(templatesDir, 'control-install.sh', {
-            COMPOSE: compose,
-            CONTAINER_SH: sh(CONTROL_CONTAINER),
-        });
-        runLocal('ssh', ['--', sshTarget, remote]);
-        // Upgrades never reissue root: fresh installs create it, `--recover-root` replaces its key. Output goes straight to files.
-        const issue = `docker exec ${sh(CONTROL_CONTAINER)} node dist/main.js control issue-credential --name root --role admin${o.recoverRoot ? ' --replace' : ''}`;
-        const out = spawnSync('ssh', ['--', sshTarget, issue], { encoding: 'utf8' });
-        if (out.status !== 0) {
-            if (!o.recoverRoot && /already used/.test(String(out.stderr)))
-                console.error('control already has a root credential; upgrade complete (pass --recover-root to replace it)');
-            else
-                throw new Error(`issuing the root credential failed: ${String(out.stderr).trim()}`);
-        }
-        else {
-            const text = `${String(out.stdout).trim()}\n`;
-            decodeCredential(text);
-            if (o.credentialOut) {
-                await writeFileDurable(o.credentialOut, text, 0o600);
-                console.error(`root credential written to ${o.credentialOut}`);
+        return withProgress(`Preparing control on ${sshTarget}`, async (progress) => {
+            if (o.installDocker) {
+                progress.stage(`Installing Docker on ${sshTarget}`);
+                await bootstrapDocker(sshTarget, true);
             }
-            if (o.import) {
-                const { controlUrl: connectUrl, project } = command.optsWithGlobals();
-                await importCredential(cfg, text, { controlUrl: connectUrl, project });
+            progress.stage(`Checking control host ${sshTarget}`);
+            await preflightRemote(sshTarget, {
+                ports: [Number(o.port)],
+                minDiskMb: 2048,
+                compose: true,
+            });
+            if (o.buildLocalImage)
+                await transferTugImage(sshTarget, image, progress.stage);
+            const yamlValue = (value) => JSON.stringify(value);
+            const compose = await loadTemplate(templatesDir, 'control-compose.yml', {
+                IMAGE: yamlValue(image),
+                CONTROL_URL: yamlValue(new URL(controlUrl).origin),
+                EXTRA_SANS: yamlValue(o.extraSan.join(',')),
+                PORT: o.port,
+            });
+            const remote = await loadTemplate(templatesDir, 'control-install.sh', {
+                COMPOSE: compose,
+                CONTAINER_SH: sh(CONTROL_CONTAINER),
+            });
+            progress.stage(`Installing control on ${sshTarget}`);
+            await runLocal('ssh', ['--', sshTarget, remote]);
+            // Upgrades never reissue root: fresh installs create it, `--recover-root` replaces its key. Output goes straight to files.
+            const issue = `docker exec ${sh(CONTROL_CONTAINER)} node dist/main.js control issue-credential --name root --role admin${o.recoverRoot ? ' --replace' : ''}`;
+            progress.stage(`Issuing root credential on ${sshTarget}`);
+            const out = await runProcess('ssh', ['--', sshTarget, issue], { capture: true });
+            if (out.status !== 0) {
+                if (!o.recoverRoot && /already used/.test(String(out.stderr)))
+                    console.error('control already has a root credential; upgrade complete (pass --recover-root to replace it)');
+                else
+                    throw new Error(`issuing the root credential failed: ${String(out.stderr).trim()}`);
             }
-        }
-        print({ ok: true, sshTarget, url: controlUrl });
+            else {
+                const text = `${String(out.stdout).trim()}\n`;
+                decodeCredential(text);
+                if (o.credentialOut) {
+                    await writeFileDurable(o.credentialOut, text, 0o600);
+                    console.error(`root credential written to ${o.credentialOut}`);
+                }
+                if (o.import) {
+                    const { controlUrl: connectUrl, project } = command.optsWithGlobals();
+                    await importCredential(cfg, text, { controlUrl: connectUrl, project });
+                }
+            }
+            print({ ok: true, sshTarget, url: controlUrl });
+        });
     });
 }
 export function registerControl(program) {
@@ -99,13 +112,13 @@ export function registerControl(program) {
         .command('backup')
         .description('create a control-plane backup (state, PKI, master key and retained image archives; not workload volumes)')
         .option('--no-images', 'leave the retained build archives out (deploy again to rebuild them)')
-        .action(async (o) => print(await request('POST', '/api/v1/control/backups/run', { images: o.images })));
+        .action(async (o) => withProgress('Creating control-plane backup', async () => print(await request('POST', '/api/v1/control/backups/run', { images: o.images }))));
     control
         .command('restore <artifactRef>')
         .description('restore a control-plane backup on the control-plane host; requires a control restart')
         .option('--confirm')
-        .action(async (artifactRef, o) => print(await request('POST', '/api/v1/control/restore', {
+        .action(async (artifactRef, o) => withProgress('Restoring control-plane backup', async () => print(await request('POST', '/api/v1/control/restore', {
         artifactRef,
         confirm: Boolean(o.confirm),
-    })));
+    }))));
 }

package/dist/commands/credential.js

@@ -1,3 +1,5 @@
+import { selectMany } from "../cli-selection.js";
+import { selectResource } from "./selection.js";
 import { Option } from 'commander';
 import { ROLES } from "../credentials.js";
 import { print, request } from "./context.js";
@@ -14,8 +16,25 @@ export function registerCredential(program) {
         .addOption(new Option('--project <name>', 'limit a read or deploy credential to this project; repeat for several')
         .default([], 'all projects')
         .argParser((value, previous) => [...previous, value]))
+        .option('--select-projects', 'choose existing projects for the credential scope')
         .option('--expires-in-days <n>', 'expire the credential after this many days (default and maximum: 365)')
         .action(async (name, o) => {
+        if (o.selectProjects) {
+            if (o.role === 'admin' || o.project.length)
+                throw new Error('--select-projects requires read/deploy role and no --project');
+            o.project = await selectMany('Select projects (choose all projects alone for unrestricted access)', async () => {
+                const { projects } = await request('GET', '/api/v1/projects');
+                return [
+                    { value: '*', label: 'All projects, including future projects' },
+                    ...projects.map((project) => ({ value: project.name, label: project.name })),
+                ];
+            });
+            if (o.project.includes('*')) {
+                if (o.project.length !== 1)
+                    throw new Error('all projects must be selected alone');
+                o.project = [];
+            }
+        }
         const created = await request('POST', '/api/v1/credentials', {
             name,
             role: o.role,
@@ -30,7 +49,7 @@ export function registerCredential(program) {
         .description('list operator credentials with role, projects, expiry and last use; secrets are never shown')
         .action(async () => print(await request('GET', '/api/v1/credentials')));
     credential
-        .command('revoke <name>')
+        .command('revoke [name]')
         .description('revoke an operator credential immediately; its name stays reserved for the audit trail')
-        .action(async (name) => print(await request('DELETE', `/api/v1/credentials/${encodeURIComponent(name)}`)));
+        .action(async (name) => print(await request('DELETE', `/api/v1/credentials/${encodeURIComponent(await selectResource(name, 'credentials'))}`)));
 }

package/dist/commands/deploy.js

@@ -1,8 +1,10 @@
+import { selectDeployment, selectService } from "./selection.js";
 import { existsSync, openAsBlob } from 'node:fs';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { createLocalBuildSnapshot, createSourceArchive, prepareLocalImages } from "../cli-build.js";
+import { createProgress, withProgress } from "../cli-progress.js";
 import { canPrompt } from "../cli-prompt.js";
 import { findMissingSecrets, promptForSecrets } from "../cli-secrets.js";
 import { composeHash } from "../compose.js";
@@ -46,77 +48,92 @@ export function registerDeploy(program) {
         .option('--json', 'print the full result, including the desired state, as JSON')
         .option('--move <service>', 'acknowledge that a service placed on another node starts empty (its data does not move); the services that write to it are held until you restore it or run `tug hold release` (repeatable)', collect, [])
         .action(async (o) => {
-        const cfg = await loadCfg();
-        const project = o.project || cfg.project || 'site';
-        // Control secrets are interpolated as sentinels; the agent substitutes the node's released values.
-        const { secrets } = await request('GET', `/api/v1/secrets?project=${encodeURIComponent(project)}`);
-        const secretNames = secrets.map((secret) => secret.name);
-        const missing = await findMissingSecrets(o.file, secretNames);
-        if (missing.length) {
-            if (!canPrompt())
-                throw new Error(`${o.file} needs values that are not set: ${missing.join(', ')}; create each with tug secret set <name> (or run tug deploy in a terminal to be prompted)`);
-            console.error(`Missing secrets for project ${project}: ${missing.join(', ')}`);
-            // Only names that do not exist yet are stored, so an existing secret is never overwritten.
-            for (const [name, value] of Object.entries(await promptForSecrets(missing))) {
-                await request('POST', '/api/v1/secrets', { project, name, value });
-                secretNames.push(name);
+        const progress = createProgress();
+        try {
+            progress.stage('Preparing deployment');
+            const cfg = await loadCfg();
+            const project = o.project || cfg.project || 'site';
+            // Control secrets are interpolated as sentinels; the agent substitutes the node's released values.
+            const { secrets } = await request('GET', `/api/v1/secrets?project=${encodeURIComponent(project)}`);
+            const secretNames = secrets.map((secret) => secret.name);
+            const missing = await findMissingSecrets(o.file, secretNames);
+            if (missing.length) {
+                if (!canPrompt())
+                    throw new Error(`${o.file} needs values that are not set: ${missing.join(', ')}; create each with tug secret set <name> (or run tug deploy in a terminal to be prompted)`);
+                console.error(`Missing secrets for project ${project}: ${missing.join(', ')}`);
+                // Only names that do not exist yet are stored, so an existing secret is never overwritten.
+                for (const [name, value] of Object.entries(await promptForSecrets(missing))) {
+                    await request('POST', '/api/v1/secrets', { project, name, value });
+                    secretNames.push(name);
+                }
             }
-        }
-        const movePayload = o.move.length ? { moves: o.move } : {};
-        const declared = await composeName(o.file);
-        if (declared && declared !== project)
-            console.error(`warning: ${o.file} is named ${declared} but the Tug project is ${project}; secrets, backups and restores are scoped to the Tug project (set project: ${declared} in tug.yml, or pass --project)`);
-        const compose = await normalizeCompose(o.file, secretNames, { project });
-        const version = o.version || `git-${composeHash(compose)}`;
-        let response;
-        if (o.buildLocal) {
-            const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'tug-local-build-'));
-            try {
-                const form = new FormData();
-                const source = Object.values(compose.services).some((service) => service.build)
-                    ? await createLocalBuildSnapshot(process.cwd(), directory, [
-                        cfg.file,
-                        cfg.localFile,
-                        ...(cfg.credentialFile ? [cfg.credentialFile] : []),
-                    ])
-                    : process.cwd();
-                const localImages = await prepareLocalImages(compose, source, directory);
-                for (const { field } of localImages)
-                    form.append(field, await openAsBlob(path.join(directory, `${field}.tar.gz`)), `${field}.tar.gz`);
-                form.append('payload', JSON.stringify({ project, version, compose, localImages, ...movePayload }));
-                response = await request('POST', '/api/v1/deployments', form, true);
+            const movePayload = o.move.length ? { moves: o.move } : {};
+            const declared = await composeName(o.file);
+            if (declared && declared !== project)
+                console.error(`warning: ${o.file} is named ${declared} but the Tug project is ${project}; secrets, backups and restores are scoped to the Tug project (set project: ${declared} in tug.yml, or pass --project)`);
+            const compose = await normalizeCompose(o.file, secretNames, { project });
+            const version = o.version || `git-${composeHash(compose)}`;
+            let response;
+            if (o.buildLocal) {
+                const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'tug-local-build-'));
+                try {
+                    const form = new FormData();
+                    progress.stage('Preparing local build snapshot');
+                    const source = Object.values(compose.services).some((service) => service.build)
+                        ? await createLocalBuildSnapshot(process.cwd(), directory, [
+                            cfg.file,
+                            cfg.localFile,
+                            ...(cfg.credentialFile ? [cfg.credentialFile] : []),
+                        ])
+                        : process.cwd();
+                    const localImages = await prepareLocalImages(compose, source, directory, undefined, progress.stage);
+                    for (const { field } of localImages)
+                        form.append(field, await openAsBlob(path.join(directory, `${field}.tar.gz`)), `${field}.tar.gz`);
+                    form.append('payload', JSON.stringify({ project, version, compose, localImages, ...movePayload }));
+                    progress.stage('Uploading images and preparing deployment on control');
+                    response = await request('POST', '/api/v1/deployments', form, true);
+                }
+                finally {
+                    await fs.rm(directory, { recursive: true, force: true });
+                }
             }
-            finally {
-                await fs.rm(directory, { recursive: true, force: true });
+            else if (Object.values(compose.services).some((service) => service.build)) {
+                progress.stage('Archiving source for remote build');
+                const tarball = await makeContext();
+                try {
+                    const form = new FormData();
+                    form.append('payload', JSON.stringify({ project, version, compose, ...movePayload }));
+                    form.append('context', await openAsBlob(tarball), 'context.tgz');
+                    progress.stage('Uploading source and building images on control');
+                    response = await request('POST', '/api/v1/deployments', form, true);
+                }
+                finally {
+                    await fs.rm(tarball, { force: true });
+                }
             }
-        }
-        else if (Object.values(compose.services).some((service) => service.build)) {
-            const tarball = await makeContext();
-            try {
-                const form = new FormData();
-                form.append('payload', JSON.stringify({ project, version, compose, ...movePayload }));
-                form.append('context', await openAsBlob(tarball), 'context.tgz');
-                response = await request('POST', '/api/v1/deployments', form, true);
+            else {
+                progress.stage('Resolving images and preparing deployment on control');
+                response = await request('POST', '/api/v1/deployments', {
+                    project,
+                    version,
+                    compose,
+                    ...movePayload,
+                });
             }
-            finally {
-                await fs.rm(tarball, { force: true });
+            if (o.wait) {
+                progress.stage(`Deployment ${response.deployment.id}: ${response.deployment.state}`);
+                response.deployment = await waitForDeployment(response.deployment.id, Number(o.timeout), (deployment) => progress.stage(`Deployment ${deployment.id}: ${deployment.state}`));
             }
+            printResult(o.json, response, formatDeployment);
+        }
+        finally {
+            progress.stop();
         }
-        else
-            response = await request('POST', '/api/v1/deployments', {
-                project,
-                version,
-                compose,
-                ...movePayload,
-            });
-        if (o.wait)
-            response.deployment = await waitForDeployment(response.deployment.id, Number(o.timeout));
-        printResult(o.json, response, formatDeployment);
     });
     deploy
-        .command('cancel <id>')
+        .command('cancel [id]')
         .description('cancel a deployment that has not finished')
-        .action(async (id) => print(await request('POST', `/api/v1/deployments/${encodeURIComponent(id)}/cancel`, {})));
+        .action(async (id) => print(await request('POST', `/api/v1/deployments/${encodeURIComponent(await selectDeployment(id))}/cancel`, {})));
     program
         .command('rollback')
         .description('activate the previous successful deployment')
@@ -125,31 +142,41 @@ export function registerDeploy(program) {
         .option('--timeout <seconds>', 'wait timeout', '300')
         .option('--json', 'print the full result, including the desired state, as JSON')
         .action(async (o) => {
-        const response = await request('POST', '/api/v1/rollback', {
-            project: await projectOf(o),
-            force: Boolean(o.force),
+        return withProgress('Preparing rollback on control', async (progress) => {
+            const response = await request('POST', '/api/v1/rollback', {
+                project: await projectOf(o),
+                force: Boolean(o.force),
+            });
+            if (o.wait) {
+                progress.stage(`Deployment ${response.deployment.id}: ${response.deployment.state}`);
+                response.deployment = await waitForDeployment(response.deployment.id, Number(o.timeout), (deployment) => progress.stage(`Deployment ${deployment.id}: ${deployment.state}`));
+            }
+            printResult(o.json, response, formatDeployment);
         });
-        if (o.wait)
-            response.deployment = await waitForDeployment(response.deployment.id, Number(o.timeout));
-        printResult(o.json, response, formatDeployment);
     });
     program
-        .command('scale <service> <replicas>')
+        .command('scale [service] [replicas]')
+        .option('--replicas <n>', 'replica count when choosing a service interactively')
         .description('scale a service to N replicas across matching nodes')
         .option('--json', 'print the full result as JSON')
         .action(async (service, replicas, o) => {
+        if (o.replicas && replicas)
+            throw new Error('pass replicas positionally or with --replicas, not both');
+        replicas = replicas || o.replicas || '';
         const project = await projectOf(o);
         if (!/^[1-9]\d*$/.test(replicas))
             throw new Error('replicas must be a positive integer');
+        service = await selectService(service);
         const result = await request('POST', '/api/v1/scale', { project, service, replicas: Number(replicas) });
         printResult(o.json, result, (r) => `${r.service} scaled to ${r.replicas} replica${r.replicas === 1 ? '' : 's'} on ${r.nodes.join(', ')}`);
     });
     program
-        .command('restart <service>')
+        .command('restart [service]')
         .description('restart a service on every node that runs it')
         .option('--timeout <seconds>', 'wait timeout', '60')
         .action(async (svc, o) => {
         const project = await projectOf(o);
+        svc = await selectService(svc);
         const created = await request('POST', '/api/v1/restart', { project, service: svc });
         const cmd = await waitForCommand(created.commandId, Number(o.timeout));
         if (cmd.state === 'failed')

package/dist/commands/hold.js

@@ -1,3 +1,4 @@
+import { selectHolds } from "./selection.js";
 import { print, projectOf, request } from "./context.js";
 export function registerHold(program) {
     const hold = program
@@ -6,8 +7,15 @@ export function registerHold(program) {
     hold
         .command('release [services...]')
         .description('start the services that `tug deploy --move` held, without restoring (all of them when none is named); a restore releases its own holds')
-        .action(async (services, o) => print(await request('POST', '/api/v1/holds/release', {
-        project: await projectOf(o),
-        services,
-    })));
+        .option('--select', 'choose one or more move holds instead of releasing all')
+        .action(async (services, o) => {
+        if (o.select && services.length)
+            throw new Error('--select cannot be combined with explicit services');
+        if (o.select)
+            services = await selectHolds();
+        return print(await request('POST', '/api/v1/holds/release', {
+            project: await projectOf(o),
+            services,
+        }));
+    });
 }

package/dist/commands/host.d.ts

@@ -5,8 +5,8 @@ export declare function preflightRemote(target: string, { controlUrl, ports, min
     minDiskMb?: number;
     /** Requires the Compose plugin; only the control host runs Compose, nodes need the Docker Engine alone. */
     compose?: boolean;
-}): void;
-export declare function transferTugImage(target: string, imageTag: string): Promise<void>;
+}): Promise<void>;
+export declare function transferTugImage(target: string, imageTag: string, stage: (label: string) => void): Promise<void>;
 export declare function dockerBootstrap(): Promise<string>;
 /** Installs Docker over SSH; `compose` also installs the Compose plugin, which only the control host needs. */
 export declare function bootstrapDocker(target: string, compose?: boolean): Promise<void>;

package/dist/commands/host.js

@@ -6,7 +6,7 @@ import { saveImageArchive } from "../artifacts.js";
 import { controlPortCheck, localImageBuildArgs, shellQuote as sh } from "../cli-install.js";
 import { LIST_ADDRESSES_COMMAND, parseAddressCandidates, sortCandidates, } from "../cli-onboarding.js";
 import { runCapture, runLocal, templatesDir } from "./context.js";
-export function preflightRemote(target, { controlUrl, ports = [], minDiskMb = 1024, compose = false, } = {}) {
+export async function preflightRemote(target, { controlUrl, ports = [], minDiskMb = 1024, compose = false, } = {}) {
     const checks = [
         [
             'docker.version',
@@ -50,18 +50,23 @@ export function preflightRemote(target, { controlUrl, ports = [], minDiskMb = 10
     const script = `set -e
 ${checks.map(([name, cmd, fix]) => `echo "preflight: ${name}"; (${cmd}) || { echo "FAILED ${name}: ${fix}" >&2; exit 20; }`).join('\n')}
 `;
-    runLocal('ssh', ['--', target, script]);
+    await runLocal('ssh', ['--', target, script]);
 }
-export async function transferTugImage(target, imageTag) {
+export async function transferTugImage(target, imageTag, stage) {
+    stage(`Checking architecture on ${target}`);
     const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'tug-runtime-'));
     const archive = path.join(directory, 'image.tar.gz');
     const remote = `/tmp/${path.basename(directory)}.tar.gz`;
     try {
-        const uname = runCapture('ssh', ['--', target, 'uname -m']);
-        runLocal('docker', localImageBuildArgs(imageTag, uname));
+        const uname = await runCapture('ssh', ['--', target, 'uname -m']);
+        stage(`Building Tug image ${imageTag}`);
+        await runLocal('docker', localImageBuildArgs(imageTag, uname));
+        stage(`Exporting Tug image ${imageTag}`);
         await saveImageArchive(imageTag, archive);
-        runLocal('scp', ['--', archive, `${target}:${remote}`]);
-        runLocal('ssh', [
+        stage(`Transferring Tug image to ${target}`);
+        await runLocal('scp', ['--', archive, `${target}:${remote}`]);
+        stage(`Loading Tug image on ${target}`);
+        await runLocal('ssh', [
             '--',
             target,
             `set -eu\ntrap ${sh(`rm -f ${sh(remote)}`)} EXIT\ndocker load --input ${sh(remote)}`,
@@ -76,7 +81,7 @@ export async function dockerBootstrap() {
 }
 /** Installs Docker over SSH; `compose` also installs the Compose plugin, which only the control host needs. */
 export async function bootstrapDocker(target, compose = false) {
-    runLocal('ssh', [
+    await runLocal('ssh', [
         '--',
         target,
         `${compose ? 'TUG_INSTALL_COMPOSE=1 ' : ''}sh -eu -c ${sh(await dockerBootstrap())}`,

package/dist/commands/node.d.ts

@@ -9,6 +9,7 @@ export interface NodeIdentityOpts extends InstallOpts {
     label: string[];
     agentControlUrl?: string;
     all?: boolean;
+    select?: boolean;
     wait: boolean;
     ingress?: boolean;
     yes?: boolean;