@grayspar/cli 0.0.0-stage → 0.0.1

package/dist/commands/deploy/deploy.js

@@ -0,0 +1,366 @@
+/* Upload, then send the deploy and ask what the API returns, one question per round so a refused answer is asked
+   again at once: which service answers the address, and a path for each new one. */
+import { basename, resolve } from 'node:path';
+import { Command, Option } from 'commander';
+import { dataOrThrow, signedInClient } from '../../lib/client.js';
+import { collectRepeatedValue, commandAction } from '../../lib/command-helpers.js';
+import { CliError } from '../../lib/errors.js';
+import { awaitDeployment, reportFailure } from '../../lib/follow-deployment.js';
+import { portLines } from '../../lib/listening.js';
+import { printNote, startProgress } from '../../lib/output.js';
+import { findLink, writeLink } from '../../lib/project-link.js';
+import { askChoice, askText, isInteractive } from '../../lib/prompt.js';
+import { projectIsNamed, resolveProject, teamProjects } from '../../lib/resolve-project.js';
+import { resolveTeam } from '../../lib/resolve-team.js';
+import { servicesTable } from '../../lib/services-table.js';
+import { color, failure, receipt, table, warning } from '../../lib/ui.js';
+import { archiveOf } from './archive.js';
+import { parseDeployFlags, servicesToSend, } from './deploy-flags.js';
+import { emptyFoundVariables, variablesFor } from './env-files.js';
+import { gitStateOf } from './git-state.js';
+import { projectNameFrom } from './project-name.js';
+import { variablesToSend } from './variables-to-send.js';
+async function deploy(folder, options) {
+    const root = resolve(folder);
+    const serviceFlags = parseDeployFlags(options.flags);
+    const api = await signedInClient();
+    const destination = await destinationFor(api, root, options);
+    const inspecting = startProgress(options.format, 'Inspecting your project…');
+    const uploaded = await uploadSource(api, destination, new Blob([await archiveOf(root)])).finally(inspecting.stop);
+    const variables = new Map(await Promise.all(uploaded.services.map(async (service) => [
+        service.name,
+        options.env
+            ? await variablesFor(root, service.rootDirectory, uploaded.platformVariables, options.envFile)
+            : emptyFoundVariables(),
+    ])));
+    if (options.format === 'text')
+        printFoundServices(uploaded, variables);
+    const foundNames = uploaded.services.map((service) => service.name);
+    const deploying = servicesToSend(foundNames, serviceFlags).flatMap(({ name }) => {
+        const known = variables.get(name);
+        return known === undefined ? [] : [{ name, foundVariables: known }];
+    });
+    const toSend = destination.kind === 'project'
+        ? await variablesToSend(api, destination.project, root, deploying.map((service) => service.name), deploying.map((service) => service.foundVariables), options.preference)
+        : Object.fromEntries(deploying.map((service) => [service.name, service.foundVariables.values]));
+    const gitState = await gitStateOf(root);
+    const { project, deployment } = await submitDeploy(api, destination, options, serviceFlags, foundNames, {
+        upload: uploaded.upload,
+        variables: toSend,
+        ...(gitState === null ? {} : { git: gitState }),
+    });
+    if (destination.kind === 'new' || !destination.isLinked) {
+        await writeLink(root, { projectId: project.id });
+    }
+    if (options.format === 'text') {
+        for (const build of deployment.builds) {
+            for (const path of build.addedVolumes) {
+                process.stdout.write(`${receipt(`Added volume ${path} to ${build.service}`)}\n`);
+            }
+        }
+    }
+    const outcome = await watchDeployment(api, project, deployment.id, options.format);
+    if (options.format === 'json') {
+        process.stdout.write(`${JSON.stringify({ project: project.name, url: project.url, ...outcome }, null, 2)}\n`);
+        if (outcome.status === 'failed')
+            process.exitCode = 1;
+        return;
+    }
+    await printOutcome(api, project, outcome, { uploaded, serviceFlags });
+}
+function uploadSource(api, destination, source) {
+    const body = { source };
+    const bodySerializer = (sent) => {
+        const form = new FormData();
+        form.append('source', sent.source, 'source.tar.gz');
+        return form;
+    };
+    return dataOrThrow(destination.kind === 'project'
+        ? api.POST('/api/projects/{id}/uploads', {
+            params: { path: { id: destination.project.id } },
+            body,
+            bodySerializer,
+        })
+        : api.POST('/api/teams/{teamId}/uploads', {
+            params: { path: { teamId: destination.team.id } },
+            body,
+            bodySerializer,
+        }));
+}
+const PATH_POINTER_PATTERN = /^#\/services\/(\d+)\/pathPrefix$/;
+function askedIn(refusal, sent) {
+    if (refusal === undefined)
+        return null;
+    if (refusal.questions !== undefined)
+        return { asked: refusal.questions, detail: refusal.detail };
+    const paths = (refusal.errors ?? []).flatMap(({ detail, pointer }) => {
+        const index = PATH_POINTER_PATTERN.exec(pointer ?? '')?.[1];
+        const service = index === undefined ? undefined : sent[Number(index)]?.name;
+        return service === undefined ? [] : [{ service, suggestion: null, problem: detail }];
+    });
+    return paths.length === 0 ? null : { asked: { address: [], paths }, detail: refusal.detail };
+}
+async function sendDeploy(api, destination, body) {
+    if (destination.kind === 'project') {
+        const answer = await api.POST('/api/projects/{id}/deployments', {
+            params: { path: { id: destination.project.id } },
+            body,
+        });
+        const asked = askedIn(answer.error, body.services ?? []);
+        if (asked !== null)
+            return asked;
+        const { deployment } = await dataOrThrow(Promise.resolve(answer));
+        return { accepted: { project: destination.project, deployment } };
+    }
+    const answer = await api.POST('/api/teams/{teamId}/projects', {
+        params: { path: { teamId: destination.team.id } },
+        body: { ...body, name: destination.name },
+    });
+    const asked = askedIn(answer.error, body.services ?? []);
+    if (asked !== null)
+        return asked;
+    return { accepted: await dataOrThrow(Promise.resolve(answer)) };
+}
+function refusalFor({ asked, detail }, suggestionsTaken) {
+    const action = asked.address.length > 0
+        ? 'Choose it with --path <name>=/.'
+        : suggestionsTaken
+            ? 'Give the path with --path <name>=<path>.'
+            : 'Give each path with --path <name>=<path>, or take the suggested paths with --yes.';
+    return new CliError('needs_a_path', `${detail}\n${action}`, '--path');
+}
+function suggestionsFor(askedQuestions) {
+    const taken = new Map();
+    for (const { service, suggestion, problem } of askedQuestions.asked.paths) {
+        if (suggestion === null || problem !== null)
+            throw refusalFor(askedQuestions, true);
+        taken.set(service, suggestion);
+    }
+    if (askedQuestions.asked.address.length > 0)
+        throw refusalFor(askedQuestions, true);
+    return taken;
+}
+async function askFirstQuestion(asked, address) {
+    if (asked.address.length > 0) {
+        const root = await askChoice(`Select the service that opens at ${address}`, `Opens at ${address}`, asked.address.map((name) => ({ value: name, label: name })), '--path');
+        return [root, '/'];
+    }
+    const [question] = asked.paths;
+    if (question === undefined)
+        throw new Error('The API asked a question without naming one.');
+    if (question.problem !== null)
+        process.stdout.write(`${failure(question.problem)}\n`);
+    return [
+        question.service,
+        await askText(`Path for ${question.service}`, question.suggestion, '--path'),
+    ];
+}
+async function submitDeploy(api, destination, options, serviceFlags, foundNames, request) {
+    const canAsk = options.format === 'text' && isInteractive() && !options.yes;
+    let hasAsked = false;
+    for (;;) {
+        const sent = await sendDeploy(api, destination, {
+            ...request,
+            services: servicesToSend(foundNames, serviceFlags),
+        });
+        if ('accepted' in sent) {
+            if (hasAsked)
+                process.stdout.write('\n');
+            return sent.accepted;
+        }
+        if (!options.yes && !canAsk)
+            throw refusalFor(sent, false);
+        const given = options.yes
+            ? suggestionsFor(sent)
+            : new Map([await askFirstQuestion(sent.asked, addressOf(destination))]);
+        hasAsked ||= !options.yes;
+        for (const [name, path] of given)
+            serviceFlags.paths.set(name, path);
+    }
+}
+function addressOf(destination) {
+    return destination.kind === 'project'
+        ? new URL(destination.project.url).host
+        : "the project's address";
+}
+function printFoundServices(uploaded, variables) {
+    const count = uploaded.services.length;
+    const rows = uploaded.services.map((service) => [service.name, service.builtWith ?? '…']);
+    process.stdout.write(`${color.heading(`Found ${String(count)} ${count === 1 ? 'service' : 'services'}`)}\n\n` +
+        `${table(['SERVICE', 'BUILT WITH'], rows)}\n`);
+    const leftOut = new Set([...variables.values()].flatMap((service) => Object.entries(service.skippedPlatformVariables).map(([key, file]) => `${key} in ${file} is left out, because Grayspar sets it`)));
+    const warnings = [
+        ...leftOut,
+        ...uploaded.services.flatMap((service) => (variables.get(service.name)?.expectedButMissing ?? []).map((key) => `${service.name} expects ${key}, which has no value`)),
+        ...uploaded.leftRunning.map((name) => `${name} is no longer in this folder, and keeps running`),
+    ];
+    if (warnings.length > 0)
+        process.stdout.write(`\n${warnings.map(warning).join('\n')}\n`);
+    process.stdout.write('\n');
+}
+async function watchDeployment(api, project, deploymentId, format) {
+    const stopWatching = () => {
+        process.stderr.write(`\nThe deploy goes on without this terminal. To follow it, run\ngrayspar status --project ${project.name}\n`);
+        process.exit(130);
+    };
+    process.once('SIGINT', stopWatching);
+    try {
+        return await awaitDeployment(api, project, deploymentId, { format, label: 'Deploying…' });
+    }
+    finally {
+        process.off('SIGINT', stopWatching);
+    }
+}
+async function printOutcome(api, project, outcome, { uploaded, serviceFlags }) {
+    if (outcome.status === 'live') {
+        const live = await dataOrThrow(api.GET('/api/projects/{id}', { params: { path: { id: project.id } } }));
+        const ports = portLines(outcome.listening);
+        process.stdout.write(`${[receipt(`Deployed ${live.name}`), ...ports.receipts].join('\n')}\n\n${servicesTable(live)}\n` +
+            (ports.warnings.length === 0 ? '' : `\n${ports.warnings.join('\n')}\n`));
+        return;
+    }
+    if (outcome.status === 'pending') {
+        process.stdout.write(`Still building. To follow it, run\ngrayspar logs --build --project ${project.name}\n`);
+        return;
+    }
+    await reportFailure(api, project, outcome, dockerfileHint(uploaded, outcome, serviceFlags));
+}
+function dockerfileHint(uploaded, outcome, serviceFlags) {
+    const service = uploaded.services.find((candidate) => candidate.name === outcome.failedService);
+    if (outcome.built ||
+        service === undefined ||
+        service.builder !== 'dockerfile' ||
+        service.dockerfile !== null ||
+        serviceFlags.dockerfiles.has(service.name) ||
+        service.rootDirectory === '.') {
+        return undefined;
+    }
+    const path = `${service.rootDirectory}/Dockerfile`;
+    return [
+        `If ${path} builds from the project's root, run`,
+        `grayspar service set ${service.name} --dockerfile ${path}`,
+        'and deploy again.',
+    ];
+}
+export function destinationOptions(projects, suggestedName) {
+    const match = projects.find((project) => project.name === suggestedName);
+    const others = projects
+        .filter((project) => project !== match)
+        .map((project) => ({ kind: 'existing', project }));
+    const create = { kind: 'create' };
+    return match === undefined
+        ? [create, ...others]
+        : [{ kind: 'existing', project: match }, create, ...others];
+}
+const NAME_RULE = 'Names use lowercase letters, numbers and single hyphens, up to 58 characters.';
+function nameProblem(name, projects) {
+    if (projectNameFrom(name) !== name)
+        return NAME_RULE;
+    return projects.some((project) => project.name === name)
+        ? `This team already has a project called ${name}.`
+        : null;
+}
+function givenName(name, projects) {
+    const problem = name === null ? NAME_RULE : nameProblem(name, projects);
+    if (name === null || problem !== null) {
+        throw new CliError('needs_a_name', `${problem ?? NAME_RULE}\nName the project with --name.`, '--name');
+    }
+    return name;
+}
+async function askProjectName(projects, suggestion) {
+    let offered = suggestion;
+    for (;;) {
+        const answer = await askText('Project name', offered, '--name');
+        const problem = nameProblem(answer, projects);
+        if (problem === null)
+            return answer;
+        process.stdout.write(`${failure(problem)}\n`);
+        offered = projectNameFrom(answer);
+    }
+}
+async function destinationFor(api, root, options) {
+    if (options.name !== undefined && projectIsNamed()) {
+        throw new CliError('name_and_project', '--name creates a new project and --project names an existing one.\nGive one of them.', '--name');
+    }
+    if (projectIsNamed()) {
+        return {
+            kind: 'project',
+            project: await resolveProject(api, { followLink: false }),
+            isLinked: false,
+        };
+    }
+    const link = await findLink(root);
+    if (link !== null) {
+        const answer = await api.GET('/api/projects/{id}', {
+            params: { path: { id: link.projectId } },
+        });
+        if (answer.response.status !== 404) {
+            if (options.name !== undefined) {
+                throw new CliError('already_linked', 'This folder is already linked to a project.\nRun grayspar unlink to deploy it as a new one.', '--name');
+            }
+            return {
+                kind: 'project',
+                project: await dataOrThrow(Promise.resolve(answer)),
+                isLinked: true,
+            };
+        }
+        printNote(options.format, 'The project this folder was linked to no longer exists.');
+    }
+    const team = await resolveTeam(api, { takeDefault: options.yes, deploying: true });
+    const projects = await teamProjects(api, team.id);
+    if (options.name !== undefined) {
+        return { kind: 'new', team, name: givenName(options.name, projects) };
+    }
+    const suggestion = projectNameFrom(basename(root));
+    const destinations = destinationOptions(projects, suggestion);
+    const [suggested] = destinations;
+    if (suggested === undefined)
+        throw new Error('There is always a project to create.');
+    if (options.yes) {
+        return suggested.kind === 'existing'
+            ? { kind: 'project', project: suggested.project, isLinked: false }
+            : { kind: 'new', team, name: givenName(suggestion, projects) };
+    }
+    if (!isInteractive()) {
+        throw new CliError('needs_an_answer', 'This folder is not linked to a project yet, and there is no terminal to ask which.\nDeploy to a new project with --name, or to an existing one with --project.', '--name');
+    }
+    const picked = await askChoice('Select a project', 'Project', destinations.map((option, index) => ({
+        value: String(index),
+        label: option.kind === 'create' ? 'Create a new project' : option.project.name,
+    })), '--project');
+    const choice = destinations[Number(picked)] ?? suggested;
+    const destination = choice.kind === 'existing'
+        ? { kind: 'project', project: choice.project, isLinked: false }
+        : { kind: 'new', team, name: await askProjectName(projects, suggestion) };
+    process.stdout.write('\n');
+    return destination;
+}
+export const deployCommand = new Command('deploy')
+    .argument('[directory]', 'the project folder to deploy', '.')
+    .description('build a project folder and put it online')
+    .option('-y, --yes', 'take the plan as shown without asking')
+    .option('--name <name>', 'create a new project with this name')
+    .option('--no-env', 'deploy without reading any .env file')
+    .option('--env-file <path>', 'read variables from a specific file')
+    .addOption(new Option('--env-conflict <winner>', 'which value wins where your .env differs from a saved one').choices(['saved', 'file']))
+    .option('-s, --service <name>', 'deploy only this service, repeatable', collectRepeatedValue)
+    .option('--path <name=path>', 'where a new service answers, repeatable', collectRepeatedValue)
+    .option('--dockerfile <name=path>', 'the Dockerfile a new service builds from', collectRepeatedValue)
+    .option('--volume <name=path>', 'a folder a service keeps across deploys, repeatable', collectRepeatedValue)
+    .action(commandAction((format, command, folder) => {
+    const options = command.opts();
+    return deploy(folder, {
+        format,
+        yes: options.yes === true,
+        name: options.name,
+        env: options.env,
+        envFile: options.envFile,
+        preference: options.envConflict,
+        flags: {
+            services: options.service ?? [],
+            paths: options.path ?? [],
+            dockerfiles: options.dockerfile ?? [],
+            volumes: options.volume ?? [],
+        },
+    });
+}));

package/dist/commands/deploy/env-files.js

@@ -0,0 +1,63 @@
+/* A variable found beside the service beats one at the repository root, and an example file is read for its names
+   alone, because its values are placeholders. A variable Grayspar sets itself is left out wherever it is found. */
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parseEnv } from 'node:util';
+import { CliError } from '../../lib/errors.js';
+const ENV_FILES_IN_ORDER = ['.env', '.env.production', '.env.local'];
+const EXAMPLE_ENV_FILES = ['.env.example', '.env.sample', '.env.template'];
+export function emptyFoundVariables() {
+    return { values: {}, sourceFiles: {}, skippedPlatformVariables: {}, expectedButMissing: [] };
+}
+async function readIfPresent(folder, file) {
+    return readFile(join(folder, file), 'utf8').catch(() => null);
+}
+export async function variablesFor(root, serviceFolder, platformVariableNames, envFile) {
+    const values = {};
+    const sourceFiles = {};
+    const skippedPlatformVariables = {};
+    const expected = new Set();
+    function takeVariables(raw, origin) {
+        for (const [name, value] of Object.entries(parseEnv(raw))) {
+            if (value === undefined)
+                continue;
+            if (platformVariableNames.includes(name)) {
+                skippedPlatformVariables[name] = origin;
+                continue;
+            }
+            values[name] = value;
+            sourceFiles[name] = origin;
+        }
+    }
+    const places = serviceFolder === '.' ? ['.'] : ['.', serviceFolder];
+    for (const place of places) {
+        for (const file of ENV_FILES_IN_ORDER) {
+            const raw = await readIfPresent(join(root, place), file);
+            if (raw === null)
+                continue;
+            takeVariables(raw, place === '.' ? file : `${place}/${file}`);
+        }
+        for (const file of EXAMPLE_ENV_FILES) {
+            const raw = await readIfPresent(join(root, place), file);
+            if (raw === null)
+                continue;
+            for (const name of Object.keys(parseEnv(raw)))
+                expected.add(name);
+        }
+    }
+    if (envFile !== undefined) {
+        const raw = await readIfPresent(root, envFile);
+        if (raw === null) {
+            throw new CliError('no_env_file', `No environment file at ${envFile}.\nGive the path of an existing file with --env-file.`, '--env-file');
+        }
+        takeVariables(raw, envFile);
+    }
+    return {
+        values,
+        sourceFiles,
+        skippedPlatformVariables,
+        expectedButMissing: [...expected]
+            .filter((name) => !(name in values) && !platformVariableNames.includes(name))
+            .sort(),
+    };
+}

package/dist/commands/deploy/git-state.js

@@ -0,0 +1,22 @@
+/* A deploy uploads the files on disk and names the commit only to describe them, so a tree with
+   uncommitted or untracked files says it holds changes beyond that commit. */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const GIT_TIMEOUT_MS = 5000;
+async function runGit(folder, args) {
+    const { stdout } = await execFileAsync('git', args, { cwd: folder, timeout: GIT_TIMEOUT_MS });
+    return stdout.trim();
+}
+export async function gitStateOf(folder) {
+    try {
+        const commit = await runGit(folder, ['rev-parse', 'HEAD']);
+        const branch = await runGit(folder, ['rev-parse', '--abbrev-ref', 'HEAD']);
+        const message = await runGit(folder, ['log', '-1', '--format=%s']);
+        const changes = await runGit(folder, ['status', '--porcelain']);
+        return { branch: branch === 'HEAD' ? null : branch, commit, message, dirty: changes !== '' };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/commands/deploy/project-name.js

@@ -0,0 +1,13 @@
+/* A project's name is its address too, so it holds only what an address can carry. The API decides; this only turns a
+   folder name or a typed answer into the nearest name it would accept, to offer as the answer. */
+const NAME_LIMIT = 58;
+export function projectNameFrom(text) {
+    const name = text
+        .toLowerCase()
+        .normalize('NFKD')
+        .replace(/\p{M}+/gu, '')
+        .replace(/[^a-z0-9]+/g, '-')
+        .slice(0, NAME_LIMIT)
+        .replace(/^-+|-+$/g, '');
+    return name === '' ? null : name;
+}

package/dist/commands/deploy/variables-to-send.js

@@ -0,0 +1,69 @@
+/* The saved variables are the source of truth, so a deploy adds what the project lacks and asks
+   before a local value replaces a saved one that differs; the server answers without the values. */
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { dataOrThrow } from '../../lib/client.js';
+import { CliError } from '../../lib/errors.js';
+import { askChoice, isInteractive } from '../../lib/prompt.js';
+import { color } from '../../lib/ui.js';
+export function sendableVariables(services, variables, comparison, fileWins) {
+    return Object.fromEntries(services.map((service, index) => {
+        const values = variables[index]?.values ?? {};
+        const kept = Object.entries(values).filter(([key]) => {
+            const state = comparison[service]?.[key]?.state ?? 'new';
+            if (state === 'new')
+                return true;
+            if (state === 'same')
+                return false;
+            return fileWins({ service, key });
+        });
+        return [service, Object.fromEntries(kept)];
+    }));
+}
+function timeAgo(at) {
+    const minutes = Math.max(0, Math.floor((Date.now() - at.getTime()) / 60_000));
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    if (minutes < 60 * 24)
+        return `${Math.floor(minutes / 60)}h ago`;
+    return `${Math.floor(minutes / (60 * 24))}d ago`;
+}
+async function editedAt(root, file) {
+    if (file === undefined)
+        return null;
+    return stat(join(root, file)).then((found) => found.mtime, () => null);
+}
+export async function variablesToSend(api, project, root, services, variables, preference) {
+    const local = Object.fromEntries(services.map((service, index) => [service, variables[index]?.values ?? {}]));
+    const comparison = await dataOrThrow(api.POST('/api/projects/{id}/env/compare', {
+        params: { path: { id: project.id } },
+        body: { services: local },
+    }));
+    const conflicts = services.flatMap((service) => Object.entries(comparison[service] ?? {})
+        .filter(([, entry]) => entry.state === 'different')
+        .map(([key]) => ({ service, key })));
+    if (conflicts.length === 0 || preference !== undefined) {
+        return sendableVariables(services, variables, comparison, () => preference === 'file');
+    }
+    const names = conflicts.map(({ service, key }) => `${key} on ${service}`).join(', ');
+    if (!isInteractive()) {
+        throw new CliError('env_differs', `${names} ${conflicts.length === 1 ? 'differs from its saved value' : 'differ from their saved values'}. Pass --env-conflict saved or --env-conflict file.`, '--env-conflict');
+    }
+    const fileWinsByConflict = new Map();
+    for (const { service, key } of conflicts) {
+        const saved = comparison[service]?.[key]?.savedAt;
+        const index = services.indexOf(service);
+        const file = variables[index]?.sourceFiles[key];
+        const edited = await editedAt(root, file);
+        const savedAndEditedNote = `Saved ${saved ? timeAgo(new Date(saved)) : 'earlier'}${edited === null ? '' : `, ${file ?? '.env'} edited ${timeAgo(edited)}`}`;
+        process.stdout.write(`\n${color.heading(key)} on ${service} differs from the saved value.\n${savedAndEditedNote}.\n`);
+        const pick = await askChoice(`Select the value of ${key} for ${service}`, `${key} for ${service}`, [
+            { value: 'saved', label: 'Keep the saved value' },
+            { value: 'file', label: `Use the one in ${file ?? '.env'}` },
+        ], '--env-conflict');
+        fileWinsByConflict.set(`${service} ${key}`, pick === 'file');
+    }
+    return sendableVariables(services, variables, comparison, ({ service, key }) => fileWinsByConflict.get(`${service} ${key}`) === true);
+}

package/dist/commands/env.js

@@ -0,0 +1,70 @@
+/* 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 { appliesOnNextDeploy, 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, receipt) {
+    const saved = await dataOrThrow(api.PUT('/api/projects/{id}/services/{serviceId}/env', {
+        params: { path: { id: project.id, serviceId: service.id } },
+        body: change,
+    }));
+    await followRedeploy(api, project, saved.deployment, format, {
+        receipts: [receipt],
+        whenNothingIsLive: appliesOnNextDeploy(project),
+    });
+}
+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, `Set ${Object.keys(variables).join(', ')} 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/{id}/services/{serviceId}/env', {
+            params: { path: { id: 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, `Removed ${keys.join(', ')} 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,27 @@
+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 { 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 existed = await removeLink(process.cwd());
+    if (!existed) {
+        throw new CliError('not_linked', 'This folder is not linked to a project.');
+    }
+    printResult(format, { status: 'ok' }, () => receipt('Unlinked this 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');
+}