@grayspar/cli 0.0.0-stage → 0.0.2

package/dist/commands/env.js

@@ -0,0 +1,71 @@
+/* Saving a variable redeploys whatever is live, so a change is one call and the command waits for it
+   the way deploy does. */
+import { Command } from 'commander';
+import { dataOrThrow, signedInClient } from '../lib/client.js';
+import { commandAction, serviceNameOf, serviceOption } from '../lib/command-helpers.js';
+import { CliError } from '../lib/errors.js';
+import { followRedeploy } from '../lib/follow-deployment.js';
+import { printResult } from '../lib/output.js';
+import { resolveService, resolveServices } from '../lib/resolve-service.js';
+import { tableOrEmptyNote } from '../lib/ui.js';
+async function saveVariables(api, project, service, change, format, receipts) {
+    const saved = await dataOrThrow(api.PATCH('/api/projects/{projectId}/services/{serviceId}/env', {
+        params: { path: { projectId: project.id, serviceId: service.id } },
+        body: change,
+    }));
+    if (saved.deployment === null) {
+        printResult(format, { deployment: null }, () => `Nothing changed on ${service.name}.`);
+        return;
+    }
+    await followRedeploy(api, project, saved.deployment, format, { receipts });
+}
+async function setVariables(pairs, serviceName, format) {
+    const api = await signedInClient();
+    const { project, service } = await resolveService(api, serviceName);
+    const variables = {};
+    for (const pair of pairs) {
+        const equals = pair.indexOf('=');
+        if (equals <= 0) {
+            throw new CliError('bad_variable', `Write each variable as KEY=VALUE. Got ${pair}.`);
+        }
+        variables[pair.slice(0, equals)] = pair.slice(equals + 1);
+    }
+    await saveVariables(api, project, service, { variables }, format, Object.keys(variables).map((key) => `Set variable ${key} on ${service.name}`));
+}
+async function listVariables(serviceName, format) {
+    const api = await signedInClient();
+    const { project, services } = await resolveServices(api, serviceName);
+    const listed = await Promise.all(services.map(async (service) => ({
+        service: service.name,
+        variables: await dataOrThrow(api.GET('/api/projects/{projectId}/services/{serviceId}/env', {
+            params: { path: { projectId: project.id, serviceId: service.id } },
+        })),
+    })));
+    printResult(format, listed, () => {
+        const rows = listed.flatMap(({ service, variables }) => variables.map((variable) => [service, variable.name, variable.updatedAt.slice(0, 10)]));
+        return tableOrEmptyNote(['SERVICE', 'NAME', 'UPDATED'], rows, `${serviceName ?? project.name} has no variables.`);
+    });
+}
+async function removeVariables(keys, serviceName, format) {
+    const api = await signedInClient();
+    const { project, service } = await resolveService(api, serviceName);
+    await saveVariables(api, project, service, { remove: keys }, format, keys.map((key) => `Removed variable ${key} from ${service.name}`));
+}
+export const envCommand = new Command('env').description("set a project's environment variables");
+envCommand
+    .command('list', { isDefault: true })
+    .addOption(serviceOption('which service to read'))
+    .description("list the names of a service's variables")
+    .action(commandAction((format, command) => listVariables(serviceNameOf(command), format)));
+envCommand
+    .command('set')
+    .argument('<pairs...>', 'variables written as KEY=VALUE')
+    .addOption(serviceOption('which service to set them on'))
+    .description('add or change environment variables')
+    .action(commandAction((format, command, pairs) => setVariables(pairs, serviceNameOf(command), format)));
+envCommand
+    .command('remove')
+    .argument('<keys...>', 'the names of the variables to remove')
+    .addOption(serviceOption('which service to change'))
+    .description('remove environment variables')
+    .action(commandAction((format, command, keys) => removeVariables(keys, serviceNameOf(command), format)));

package/dist/commands/link.js

@@ -0,0 +1,28 @@
+import { Command } from 'commander';
+import { signedInClient } from '../lib/client.js';
+import { commandAction } from '../lib/command-helpers.js';
+import { CliError } from '../lib/errors.js';
+import { printResult } from '../lib/output.js';
+import { findLink, removeLink, writeLink } from '../lib/project-link.js';
+import { resolveProject } from '../lib/resolve-project.js';
+import { receipt } from '../lib/ui.js';
+async function link(format) {
+    const api = await signedInClient();
+    const project = await resolveProject(api, { followLink: false });
+    await writeLink(process.cwd(), { projectId: project.id });
+    printResult(format, { status: 'ok', project: project.name }, () => receipt(`Linked this folder to ${project.name}`));
+}
+async function unlink(format) {
+    const found = await findLink(process.cwd());
+    if (found === null) {
+        throw new CliError('not_linked', "This folder isn't linked to a project.");
+    }
+    await removeLink(found.folder);
+    printResult(format, { status: 'ok' }, () => receipt(`Unlinked ${found.folder}`));
+}
+export const linkCommand = new Command('link')
+    .description('bind this folder to a project')
+    .action(commandAction((format) => link(format)));
+export const unlinkCommand = new Command('unlink')
+    .description('unbind this folder from its project')
+    .action(commandAction((format) => unlink(format)));

package/dist/commands/login/challenge.js

@@ -0,0 +1,5 @@
+/* The browser carries this; the verifier it came from never leaves the process that made it. */
+import { createHash } from 'node:crypto';
+export function challengeFor(verifier) {
+    return createHash('sha256').update(verifier).digest('base64url');
+}

package/dist/commands/login/login.js

@@ -0,0 +1,59 @@
+import { randomBytes } from 'node:crypto';
+import { hostname } from 'node:os';
+import { Command } from 'commander';
+import { DEFAULT_API_URL, endSavedSession, publicClient } from '../../lib/client.js';
+import { commandAction } from '../../lib/command-helpers.js';
+import { writeCredentials } from '../../lib/credentials.js';
+import { CliError } from '../../lib/errors.js';
+import { printResult, startProgress } from '../../lib/output.js';
+import { color, receipt } from '../../lib/ui.js';
+import { challengeFor } from './challenge.js';
+import { openBrowser } from './open-browser.js';
+import { waitForSignInRedirect } from './sign-in-callback.js';
+const SIGN_IN_WAIT_MS = 5 * 60 * 1000;
+async function login(options) {
+    const apiUrl = process.env.GRAYSPAR_API_URL ?? DEFAULT_API_URL;
+    const verifier = randomBytes(32).toString('base64url');
+    const listener = await waitForSignInRedirect(SIGN_IN_WAIT_MS);
+    const url = new URL('/cli', apiUrl);
+    url.searchParams.set('port', String(listener.port));
+    url.searchParams.set('challenge', challengeFor(verifier));
+    process.stderr.write(`${options.format === 'text' ? `${color.heading('Grayspar login')}\n` : ''}${url.toString()}\n`);
+    try {
+        if (options.browser)
+            openBrowser(url.toString());
+        const progress = startProgress(options.format, 'Waiting for the browser…');
+        try {
+            const { code } = await listener.waitForCode;
+            if (code === null) {
+                throw new CliError('sign_in_timed_out', 'Nothing came back from the browser in time.');
+            }
+            const { data: session } = await publicClient(apiUrl).POST('/api/cli/token', {
+                body: { code, verifier, deviceName: hostname() },
+            });
+            if (session === undefined) {
+                throw new CliError('sign_in_refused', "That sign-in didn't complete. Try again.");
+            }
+            // The session these credentials replace would otherwise stay valid for months with nothing holding it.
+            await endSavedSession();
+            await writeCredentials({
+                apiUrl,
+                token: session.token,
+                email: session.email,
+            });
+            progress.stop();
+            printResult(options.format, { status: 'ok', email: session.email }, () => receipt(`Signed in as ${session.email}`));
+        }
+        catch (error) {
+            progress.stop();
+            throw error;
+        }
+    }
+    finally {
+        listener.close();
+    }
+}
+export const loginCommand = new Command('login')
+    .description('sign in to Grayspar from this machine')
+    .option('--no-browser', 'print the address instead of opening it')
+    .action(commandAction((format, command) => login({ format, browser: command.opts().browser })));

package/dist/commands/login/open-browser.js

@@ -0,0 +1,15 @@
+/* Best effort: a machine with no browser prints the address instead, to open on the same machine. Windows hands the
+   address to its URL handler directly, because `start` is a cmd built-in that reads `&` as a command break. */
+import { execFile } from 'node:child_process';
+const BROWSER_OPENERS = {
+    darwin: (url) => ['open', [url]],
+    linux: (url) => ['xdg-open', [url]],
+    win32: (url) => ['rundll32', ['url.dll,FileProtocolHandler', url]],
+};
+export function openBrowser(url) {
+    const opener = BROWSER_OPENERS[process.platform];
+    if (opener === undefined)
+        return;
+    const [command, args] = opener(url);
+    execFile(command, args, () => undefined);
+}

package/dist/commands/login/sign-in-callback.js

@@ -0,0 +1,37 @@
+/* Listens on a port the machine picks, catches exactly one redirect, and closes. The browser carries
+   a code; the verifier that makes it usable never leaves this process. */
+import { createServer } from 'node:http';
+// The terminal trades the code for its session after this page has gone out, so the page claims nothing about it.
+const SIGNED_IN_PAGE = `<!doctype html><meta charset="utf-8"><title>Grayspar CLI</title>
+<body style="font:16px/1.5 system-ui;margin:4rem auto;max-width:28rem;text-align:center">
+<h1 style="font-size:1.25rem">Back to your terminal</h1>
+<p>It finishes signing in there. You can close this window.</p>`;
+export async function waitForSignInRedirect(timeoutMs) {
+    let settle = () => undefined;
+    const waitForCode = new Promise((resolve) => {
+        settle = resolve;
+    });
+    const server = createServer((request, response) => {
+        const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+        if (url.pathname !== '/callback') {
+            response.writeHead(404).end();
+            return;
+        }
+        response.writeHead(200, { 'content-type': 'text/html; charset=utf-8' }).end(SIGNED_IN_PAGE);
+        settle({ code: url.searchParams.get('code') });
+    });
+    await new Promise((ready) => server.listen(0, '127.0.0.1', ready));
+    const timer = setTimeout(() => settle({ code: null }), timeoutMs);
+    const address = server.address();
+    if (address === null || typeof address === 'string') {
+        throw new Error('sign-in listener did not get a port');
+    }
+    return {
+        port: address.port,
+        waitForCode,
+        close: () => {
+            clearTimeout(timer);
+            server.close();
+        },
+    };
+}

package/dist/commands/logout.js

@@ -0,0 +1,18 @@
+/* Signing out ends the terminal's session on Grayspar, then forgets it here. When Grayspar cannot be reached, it is
+   forgotten here all the same, and the person is told how to end it from the dashboard. */
+import { Command } from 'commander';
+import { endSavedSession } from '../lib/client.js';
+import { commandAction } from '../lib/command-helpers.js';
+import { clearCredentials } from '../lib/credentials.js';
+import { printResult } from '../lib/output.js';
+import { receipt, warning } from '../lib/ui.js';
+async function logout(format) {
+    const ended = await endSavedSession();
+    await clearCredentials();
+    printResult(format, { status: 'ok', revoked: ended }, () => ended
+        ? receipt('Signed out')
+        : `${receipt('Signed out on this machine')}\n${warning("Grayspar couldn't be reached, so this sign-in stays valid there. Sign it out under Ways to sign in in the dashboard.")}`);
+}
+export const logoutCommand = new Command('logout')
+    .description('forget the saved sign-in on this machine')
+    .action(commandAction((format) => logout(format)));

package/dist/commands/logs.js

@@ -0,0 +1,89 @@
+/* A service's own output is what logs means, so it is the default and the build's log sits behind --build.
+   Following asks for the lines after the last one shown, every two seconds. */
+import { setTimeout as pause } from 'node:timers/promises';
+import { Command } from 'commander';
+import { dataOrThrow, signedInClient } from '../lib/client.js';
+import { commandAction, serviceOption } from '../lib/command-helpers.js';
+import { CliError } from '../lib/errors.js';
+import { resolveProject } from '../lib/resolve-project.js';
+import { resolveService } from '../lib/resolve-service.js';
+import { retryTransient } from '../lib/retry-transient.js';
+import { color } from '../lib/ui.js';
+const FOLLOW_INTERVAL_MS = 2_000;
+async function logs(options, format) {
+    const api = await signedInClient();
+    if (options.build)
+        return printBuildLogs(api, format);
+    const { project, service } = await resolveService(api, options.service);
+    const readLogs = (after, signal) => dataOrThrow(api.GET('/api/projects/{projectId}/services/{serviceId}/logs', {
+        params: {
+            path: { projectId: project.id, serviceId: service.id },
+            query: after === undefined ? {} : { after },
+        },
+        signal,
+    }));
+    const first = await readLogs();
+    if (!options.follow && format === 'text' && first.lines.length === 0) {
+        process.stdout.write(`${service.name} has printed nothing yet.\n`);
+        return;
+    }
+    printLogLines(first.lines, format);
+    if (!options.follow)
+        return;
+    let after = first.lines.at(-1)?.id;
+    for (;;) {
+        await pause(FOLLOW_INTERVAL_MS);
+        const next = await retryTransient((signal) => readLogs(after, signal));
+        printLogLines(next.lines, format);
+        after = next.lines.at(-1)?.id ?? after;
+    }
+}
+function printLogLines(lines, format) {
+    for (const line of lines) {
+        process.stdout.write(format === 'json'
+            ? `${JSON.stringify(line)}\n`
+            : `${color.dim(new Date(line.at).toLocaleTimeString())}  ${line.text}\n`);
+    }
+}
+async function printBuildLogs(api, format) {
+    const project = await resolveProject(api);
+    const { deployments } = await dataOrThrow(api.GET('/api/projects/{projectId}/deployments', {
+        params: { path: { projectId: project.id } },
+    }));
+    const latest = deployments[0];
+    if (latest === undefined) {
+        throw new CliError('never_deployed', `${project.name} hasn't been deployed yet.`);
+    }
+    const builds = await Promise.all(latest.revisions.map(async (revision) => ({
+        service: revision.service,
+        status: revision.build.status,
+        log: await dataOrThrow(api.GET('/api/projects/{projectId}/builds/{buildId}/logs', {
+            params: { path: { projectId: project.id, buildId: revision.build.id } },
+            parseAs: 'text',
+        })),
+    })));
+    if (format === 'json') {
+        for (const { service, log } of builds) {
+            for (const text of log.split('\n').filter((line) => line !== '')) {
+                process.stdout.write(`${JSON.stringify({ service, text })}\n`);
+            }
+        }
+        return;
+    }
+    for (const build of builds) {
+        process.stdout.write(`${color.heading(build.service)}  ${build.status}\n\n${build.log}\n`);
+    }
+}
+export const logsCommand = new Command('logs')
+    .description('show what a service printed while running, or with --build the last build log')
+    .addOption(serviceOption('which service to read'))
+    .option('--build', 'show the log from the last build instead')
+    .option('-f, --follow', 'keep printing new lines as they arrive')
+    .action(commandAction((format, command) => {
+    const options = command.opts();
+    return logs({
+        service: options.service,
+        build: options.build === true,
+        follow: options.follow === true,
+    }, format);
+}));

package/dist/commands/open-path.js

@@ -0,0 +1,45 @@
+/* An open path skips sign-in entirely, so whatever arrives there carries no identity and the app
+   behind it checks the sender itself, the way a Stripe or GitHub webhook handler already does. */
+import { Command } from 'commander';
+import { dataOrThrow, signedInClient } from '../lib/client.js';
+import { commandAction } from '../lib/command-helpers.js';
+import { printResult } from '../lib/output.js';
+import { resolveProject } from '../lib/resolve-project.js';
+import { receipt, tableOrEmptyNote } from '../lib/ui.js';
+async function listOpenPaths(format) {
+    const api = await signedInClient();
+    const project = await resolveProject(api);
+    printResult(format, project.openPaths, () => tableOrEmptyNote(['PATH'], project.openPaths.map((path) => [path]), `Every path of ${project.name} asks for sign-in.`));
+}
+async function addOpenPath(path, format) {
+    const api = await signedInClient();
+    const project = await resolveProject(api);
+    await dataOrThrow(api.POST('/api/projects/{projectId}/open-paths', {
+        params: { path: { projectId: project.id } },
+        body: { path },
+    }));
+    printResult(format, { status: 'ok', path }, () => `${receipt(`Added open path ${path} to ${project.name}`)}\nAnyone can reach it without signing in.`);
+}
+async function removeOpenPath(path, format) {
+    const api = await signedInClient();
+    const project = await resolveProject(api);
+    await dataOrThrow(api.DELETE('/api/projects/{projectId}/open-paths', {
+        params: { path: { projectId: project.id }, query: { path } },
+    }));
+    printResult(format, { status: 'ok', path }, () => receipt(`Removed open path ${path} from ${project.name}`));
+}
+export const openPathCommand = new Command('open-path').description('paths anyone can reach without signing in, such as webhooks');
+openPathCommand
+    .command('list', { isDefault: true })
+    .description("list a project's open paths")
+    .action(commandAction((format) => listOpenPaths(format)));
+openPathCommand
+    .command('add')
+    .argument('<path>', 'a path such as /webhooks')
+    .description('let anyone reach a path and everything below it')
+    .action(commandAction((format, _command, path) => addOpenPath(path, format)));
+openPathCommand
+    .command('remove')
+    .argument('<path>', 'an open path such as /webhooks')
+    .description('make a path ask for sign-in again')
+    .action(commandAction((format, _command, path) => removeOpenPath(path, format)));

package/dist/commands/project.js

@@ -0,0 +1,22 @@
+/* Every team's projects are one table with the team as its first column; --team narrows it to that team's rows. */
+import { Command } from 'commander';
+import { dataOrThrow, signedInClient } from '../lib/client.js';
+import { commandAction } from '../lib/command-helpers.js';
+import { printResult } from '../lib/output.js';
+import { teamProjects } from '../lib/resolve-project.js';
+import { resolveTeam, teamIsNamed } from '../lib/resolve-team.js';
+import { color, tableOrEmptyNote } from '../lib/ui.js';
+async function listProjects(format) {
+    const api = await signedInClient();
+    const teams = teamIsNamed() ? [await resolveTeam(api)] : await dataOrThrow(api.GET('/api/teams'));
+    const groups = await Promise.all(teams.map(async (team) => ({ team, projects: await teamProjects(api, team.id) })));
+    printResult(format, groups, () => {
+        const rows = groups.flatMap(({ team, projects }) => projects.map((project) => [team.name, project.name, project.url]));
+        return tableOrEmptyNote(['TEAM', 'PROJECT', 'URL'], rows, 'No projects yet. Run grayspar deploy in a project folder.', (cell, column) => (column === 2 ? color.link(cell) : cell));
+    });
+}
+export const projectCommand = new Command('project').description('work with your projects');
+projectCommand
+    .command('list', { isDefault: true })
+    .description('list the projects in your teams')
+    .action(commandAction((format) => listProjects(format)));

package/dist/commands/restart.js

@@ -0,0 +1,21 @@
+/* A restart runs the same container again in place, so the service keeps its volume and its address,
+   and nothing is built. The worker does it moments after the API accepts it. */
+import { Command } from 'commander';
+import { dataOrThrow, signedInClient } from '../lib/client.js';
+import { commandAction, serviceNameOf, serviceOption } from '../lib/command-helpers.js';
+import { printResult } from '../lib/output.js';
+import { commandFor } from '../lib/resolve-project.js';
+import { resolveService } from '../lib/resolve-service.js';
+async function restart(serviceName, format) {
+    const api = await signedInClient();
+    const { project, service } = await resolveService(api, serviceName);
+    await dataOrThrow(api.POST('/api/projects/{projectId}/services/{serviceId}/restart', {
+        params: { path: { projectId: project.id, serviceId: service.id } },
+    }));
+    const follow = await commandFor(project, 'grayspar status');
+    printResult(format, { status: 'restarting', project: project.name, service: service.name }, () => `Restarting ${service.name}.\nTo follow it, run\n${follow}`);
+}
+export const restartCommand = new Command('restart')
+    .description('run a service again in place, keeping its volume')
+    .addOption(serviceOption('which service to restart'))
+    .action(commandAction((format, command) => restart(serviceNameOf(command), format)));

package/dist/commands/service.js

@@ -0,0 +1,63 @@
+/* A path or a name is read on every request and a Dockerfile at the next build, so a change redeploys nothing. */
+import { Command } from 'commander';
+import { dataOrThrow, signedInClient } from '../lib/client.js';
+import { commandAction } from '../lib/command-helpers.js';
+import { CliError } from '../lib/errors.js';
+import { printResult } from '../lib/output.js';
+import { resolveService } from '../lib/resolve-service.js';
+import { receipt } from '../lib/ui.js';
+function receiptsFor(service, change) {
+    return [
+        change.pathPrefix === undefined
+            ? null
+            : change.pathPrefix === null
+                ? `Removed path of ${service}`
+                : `Set path of ${service} to ${change.pathPrefix}`,
+        change.name === undefined ? null : `Set name of ${service} to ${change.name}`,
+        change.dockerfile === undefined
+            ? null
+            : change.dockerfile === null
+                ? `Removed Dockerfile of ${service}`
+                : `Set Dockerfile of ${service} to ${change.dockerfile}`,
+    ].filter((line) => line !== null);
+}
+async function setService(serviceName, change, format) {
+    if (Object.keys(change).length === 0) {
+        throw new CliError('nothing_to_change', 'Name a change, such as a path or a name.', '--path');
+    }
+    const api = await signedInClient();
+    const { project, service } = await resolveService(api, serviceName, '<name>');
+    await dataOrThrow(api.PATCH('/api/projects/{projectId}/services/{serviceId}', {
+        params: { path: { projectId: project.id, serviceId: service.id } },
+        body: change,
+    }));
+    const lines = [
+        ...receiptsFor(service.name, change).map(receipt),
+        ...(change.pathPrefix === null ? ["Only the project's other services reach it."] : []),
+        ...(change.dockerfile === undefined ? [] : ['The next deploy builds with it.']),
+    ];
+    printResult(format, { status: 'ok' }, () => lines.join('\n'));
+}
+export const serviceCommand = new Command('service').description('change where a service answers and how it is built');
+serviceCommand
+    .command('set')
+    .argument('[name]', 'the service to change, left out when the project has one')
+    .option('--path <path>', 'where the service answers at the project address')
+    .option('--no-path', "reach the service only from the project's other services")
+    .option('--name <name>', 'a new name for the service')
+    .option('--dockerfile <path>', 'build from this Dockerfile, from the root of the project')
+    .option('--no-dockerfile', 'build the way Grayspar found the service again')
+    .description("change a service's path, name or Dockerfile")
+    .action(commandAction((format, command, name) => {
+    const options = command.opts();
+    const change = {
+        ...(options.path === undefined
+            ? {}
+            : { pathPrefix: options.path === false ? null : options.path }),
+        ...(options.name === undefined ? {} : { name: options.name }),
+        ...(options.dockerfile === undefined
+            ? {}
+            : { dockerfile: options.dockerfile === false ? null : options.dockerfile }),
+    };
+    return setService(name, change, format);
+}));

package/dist/commands/status.js

@@ -0,0 +1,15 @@
+import { Command } from 'commander';
+import { signedInClient } from '../lib/client.js';
+import { commandAction } from '../lib/command-helpers.js';
+import { printResult } from '../lib/output.js';
+import { resolveProject } from '../lib/resolve-project.js';
+import { servicesTable } from '../lib/services-table.js';
+import { color } from '../lib/ui.js';
+async function status(format) {
+    const api = await signedInClient();
+    const project = await resolveProject(api);
+    printResult(format, project, () => `${color.heading(project.name)}\n\n${servicesTable(project)}`);
+}
+export const statusCommand = new Command('status')
+    .description('show what a project is doing')
+    .action(commandAction((format) => status(format)));

package/dist/commands/volume.js

@@ -0,0 +1,87 @@
+/* A volume keeps one folder of a service across deploys, and a service keeps one volume. It starts at 1 GB and grows
+   by itself while the plan has room; adding or removing one redeploys whatever is live so it takes effect at once. */
+import { Command } from 'commander';
+import { dataOrThrow, signedInClient } from '../lib/client.js';
+import { commandAction, serviceNameOf, serviceOption } from '../lib/command-helpers.js';
+import { CliError } from '../lib/errors.js';
+import { followRedeploy, nextDeployNote } from '../lib/follow-deployment.js';
+import { printResult } from '../lib/output.js';
+import { askYesNo } from '../lib/prompt.js';
+import { resolveService, resolveServices } from '../lib/resolve-service.js';
+import { tableOrEmptyNote } from '../lib/ui.js';
+const BYTES_PER_GIBIBYTE = 1024 ** 3;
+function readableSize(bytes) {
+    return bytes >= BYTES_PER_GIBIBYTE
+        ? `${(bytes / BYTES_PER_GIBIBYTE).toFixed(1)} GB`
+        : `${Math.round(bytes / 1024 ** 2)} MB`;
+}
+async function listVolumes(serviceName, format) {
+    const api = await signedInClient();
+    const { project, services } = await resolveServices(api, serviceName);
+    const listed = services.map((service) => ({ service: service.name, volume: service.volume }));
+    printResult(format, listed, () => {
+        const rows = listed.flatMap(({ service, volume }) => volume === null
+            ? []
+            : [
+                [
+                    service,
+                    volume.mountPath,
+                    `${readableSize(volume.usedBytes)} of ${readableSize(volume.appliedSizeBytes ?? volume.sizeBytes)}${volume.appliedSizeBytes !== null && volume.appliedSizeBytes < volume.sizeBytes
+                        ? `, growing to ${readableSize(volume.sizeBytes)}`
+                        : ''}`,
+                ],
+            ]);
+        return tableOrEmptyNote(['SERVICE', 'PATH', 'USED'], rows, serviceName === undefined
+            ? `${project.name} has no volumes.`
+            : `${serviceName} has no volume.`);
+    });
+}
+async function addVolume(mountPath, serviceName, format) {
+    const api = await signedInClient();
+    const { project, service } = await resolveService(api, serviceName);
+    const added = await dataOrThrow(api.POST('/api/projects/{projectId}/services/{serviceId}/volumes', {
+        params: { path: { projectId: project.id, serviceId: service.id } },
+        body: { mountPath },
+    }));
+    await followRedeploy(api, project, added.deployment, format, {
+        receipts: [`Added volume ${mountPath} to ${service.name}`],
+        whenNothingIsLive: nextDeployNote(project),
+    });
+}
+export async function removeVolume(mountPath, serviceName, skipAsking, format) {
+    const api = await signedInClient();
+    const { project, service } = await resolveService(api, serviceName);
+    const { volume } = service;
+    if (volume?.mountPath !== mountPath) {
+        throw new CliError('no_such_volume', `${service.name} has no volume at ${mountPath}.`);
+    }
+    if (!skipAsking &&
+        !(await askYesNo(`Remove volume ${mountPath} from ${service.name}? Its data is deleted and ${service.name} restarts.`, false, '--yes'))) {
+        return;
+    }
+    const removed = await dataOrThrow(api.DELETE('/api/projects/{projectId}/services/{serviceId}/volumes/{volumeId}', {
+        params: { path: { projectId: project.id, serviceId: service.id, volumeId: volume.id } },
+    }));
+    await followRedeploy(api, project, removed.deployment, format, {
+        receipts: [`Removed volume ${mountPath} from ${service.name} and deleted its data`],
+    });
+}
+export const volumeCommand = new Command('volume').description('keep a folder across deploys');
+volumeCommand
+    .command('list', { isDefault: true })
+    .addOption(serviceOption('which service to read'))
+    .description('list the folders a service keeps')
+    .action(commandAction((format, command) => listVolumes(serviceNameOf(command), format)));
+volumeCommand
+    .command('add')
+    .argument('<path>', 'the folder inside the service to keep, such as /app/data')
+    .addOption(serviceOption('which service keeps it'))
+    .description('keep a folder across deploys')
+    .action(commandAction((format, command, path) => addVolume(path, serviceNameOf(command), format)));
+volumeCommand
+    .command('remove')
+    .argument('<path>', 'a folder the service keeps')
+    .addOption(serviceOption('which service keeps it'))
+    .option('-y, --yes', 'remove it without asking')
+    .description('stop keeping a folder, and throw its data away')
+    .action(commandAction((format, command, path) => removeVolume(path, serviceNameOf(command), command.opts().yes === true, format)));

package/dist/commands/whoami.js

@@ -0,0 +1,16 @@
+import { Command } from 'commander';
+import { dataOrThrow, signedInClient } from '../lib/client.js';
+import { commandAction } from '../lib/command-helpers.js';
+import { printResult } from '../lib/output.js';
+import { table } from '../lib/ui.js';
+async function whoami(format) {
+    const api = await signedInClient();
+    const [profile, teams] = await Promise.all([
+        dataOrThrow(api.GET('/api/me')),
+        dataOrThrow(api.GET('/api/teams')),
+    ]);
+    printResult(format, { ...profile, teams }, () => `Signed in as ${profile.email}\n\n${table(['TEAM', 'SLUG'], teams.map((team) => [team.name, team.slug]))}`);
+}
+export const whoamiCommand = new Command('whoami')
+    .description('show who this machine is signed in as')
+    .action(commandAction((format) => whoami(format)));