@grayspar/cli 0.0.0-stage → 0.0.2

package/dist/index.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/* Every command is a singular noun and one of four verbs, or a single flat verb. `.claude/rules/cli.md` holds the
+   grammar, and each command's own file holds its flags; here are only the flags they all share. */
+import { Command } from 'commander';
+import { accessCommand } from './commands/access.js';
+import { deployCommand } from './commands/deploy/deploy.js';
+import { envCommand } from './commands/env.js';
+import { linkCommand, unlinkCommand } from './commands/link.js';
+import { loginCommand } from './commands/login/login.js';
+import { logoutCommand } from './commands/logout.js';
+import { logsCommand } from './commands/logs.js';
+import { openPathCommand } from './commands/open-path.js';
+import { projectCommand } from './commands/project.js';
+import { restartCommand } from './commands/restart.js';
+import { serviceCommand } from './commands/service.js';
+import { statusCommand } from './commands/status.js';
+import { volumeCommand } from './commands/volume.js';
+import { whoamiCommand } from './commands/whoami.js';
+import { setJsonOutput } from './lib/prompt.js';
+import { setNamedProject } from './lib/resolve-project.js';
+import { setNamedTeam } from './lib/resolve-team.js';
+import { routeUsageErrors } from './lib/usage-errors.js';
+import { cliVersion } from './lib/version.js';
+const program = new Command()
+    .name('grayspar')
+    .description('deploy your applications and share them with exactly the people you choose')
+    .version(cliVersion, '--version', 'show the version')
+    .option('--json', 'answer in JSON, for scripts and agents')
+    .option('--team <slug>', 'which of your teams to work in')
+    .option('--project <name>', 'which project to act on, instead of the linked one')
+    .option('--no-color', 'print without colour')
+    .hook('preAction', (_program, command) => {
+    const { json, team, project } = command.optsWithGlobals();
+    setJsonOutput(json === true);
+    setNamedTeam(team);
+    setNamedProject(project);
+});
+for (const command of [
+    loginCommand,
+    logoutCommand,
+    whoamiCommand,
+    deployCommand,
+    projectCommand,
+    accessCommand,
+    openPathCommand,
+    envCommand,
+    volumeCommand,
+    serviceCommand,
+    linkCommand,
+    unlinkCommand,
+    statusCommand,
+    logsCommand,
+    restartCommand,
+]) {
+    program.addCommand(command);
+}
+routeUsageErrors(program);
+await program.parseAsync(process.argv);

package/dist/lib/client.js

@@ -0,0 +1,71 @@
+/* A 401 always means the same thing here, and so does a request that never reached Grayspar, so each is turned into
+   the sentence that fixes it rather than a status code or a network error the person has to look up. */
+import createClient from 'openapi-fetch';
+import { readCredentials } from './credentials.js';
+import { CliError } from './errors.js';
+import { cliVersion } from './version.js';
+export const DEFAULT_API_URL = 'https://app.grayspar.com';
+const API_TIMEOUT_MS = 2 * 60 * 1000;
+export async function signedInClient() {
+    const credentials = await readCredentials();
+    if (credentials === null) {
+        throw new CliError('not_signed_in', "You aren't signed in. Run grayspar login.");
+    }
+    const override = process.env.GRAYSPAR_API_URL;
+    if (override !== undefined && override !== credentials.apiUrl) {
+        throw new CliError('signed_in_elsewhere', `You're signed in to ${credentials.apiUrl}, not ${override}.\nRun grayspar login to sign in there.`);
+    }
+    return clientAt(credentials.apiUrl, { authorization: `Bearer ${credentials.token}` });
+}
+// It ends the saved session on the Grayspar that issued it, and says whether that Grayspar no longer honours it.
+export async function endSavedSession() {
+    const credentials = await readCredentials();
+    if (credentials === null)
+        return true;
+    try {
+        const api = clientAt(credentials.apiUrl, { authorization: `Bearer ${credentials.token}` });
+        const { response } = await api.DELETE('/api/cli/session');
+        return response.ok || response.status === 401;
+    }
+    catch {
+        return false;
+    }
+}
+export function publicClient(baseUrl) {
+    return clientAt(baseUrl, {});
+}
+function clientAt(baseUrl, headers) {
+    const client = createClient({
+        baseUrl,
+        headers: { ...headers, 'x-grayspar-cli': cliVersion },
+        fetch: (request) => fetch(request, {
+            signal: AbortSignal.any([request.signal, AbortSignal.timeout(API_TIMEOUT_MS)]),
+        }),
+    });
+    client.use({
+        onError: () => new CliError('unreachable', `Can't reach Grayspar at ${baseUrl}.\nCheck your connection, then run the command again.`),
+    });
+    return client;
+}
+export async function dataOrThrow(pending) {
+    const answer = await pending;
+    if (!('error' in answer))
+        return answer.data;
+    const { status } = answer.response;
+    if (status === 401) {
+        throw new CliError('not_signed_in', 'Your sign-in is no longer valid. Run grayspar login.');
+    }
+    const { error } = answer;
+    const detail = typeof error === 'object' &&
+        error !== null &&
+        'detail' in error &&
+        typeof error.detail === 'string'
+        ? error.detail
+        : null;
+    if (status >= 500) {
+        throw detail === null
+            ? new CliError('unavailable', "Grayspar didn't answer. Try again in a moment.")
+            : new CliError('server_error', detail);
+    }
+    throw new CliError('refused', detail ?? "Grayspar didn't accept that request.");
+}

package/dist/lib/command-helpers.js

@@ -0,0 +1,25 @@
+/* What every command's definition shares: the output format the global --json picks, the --service flag, a flag that
+   repeats, and the one place a failure is caught and printed in that format. */
+import { Option } from 'commander';
+import { exitWithError } from './output.js';
+export function formatOf(command) {
+    return command.optsWithGlobals().json === true ? 'json' : 'text';
+}
+export const serviceOption = (purpose) => new Option('-s, --service <name>', purpose);
+export function serviceNameOf(command) {
+    return command.opts().service;
+}
+export function collectRepeatedValue(value, previous) {
+    return [...(previous ?? []), value];
+}
+export function commandAction(work) {
+    return async function action(...args) {
+        const format = formatOf(this);
+        try {
+            await work(format, this, ...args);
+        }
+        catch (error) {
+            exitWithError(format, error);
+        }
+    };
+}

package/dist/lib/credentials.js

@@ -0,0 +1,49 @@
+/* The file holds a session token, so the directory and the file are readable only by their owner and
+   the token is never printed, not even by whoami. */
+import { chmod, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+export function credentialsPath() {
+    const base = process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config');
+    return join(base, 'grayspar', 'credentials.json');
+}
+export async function readCredentials() {
+    try {
+        const raw = await readFile(credentialsPath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        return isCredentials(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeCredentials(credentials) {
+    const path = credentialsPath();
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await chmod(dirname(path), 0o700);
+    const pending = `${path}.${String(process.pid)}.tmp`;
+    await rm(pending, { force: true });
+    try {
+        await writeFile(pending, `${JSON.stringify(credentials, null, 2)}\n`, {
+            mode: 0o600,
+            flag: 'wx',
+        });
+        await rename(pending, path);
+    }
+    finally {
+        await rm(pending, { force: true });
+    }
+}
+export async function clearCredentials() {
+    await rm(credentialsPath(), { force: true });
+}
+function isCredentials(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'token' in value &&
+        typeof value.token === 'string' &&
+        'apiUrl' in value &&
+        typeof value.apiUrl === 'string' &&
+        'email' in value &&
+        typeof value.email === 'string');
+}

package/dist/lib/errors.js

@@ -0,0 +1,12 @@
+/* Every refusal names the flag that would have answered it, so an agent reading the JSON knows what
+   to add rather than guessing at the shape of the thing that was missing. */
+export class CliError extends Error {
+    code;
+    supplyWith;
+    constructor(code, message, supplyWith) {
+        super(message);
+        this.name = 'CliError';
+        this.code = code;
+        this.supplyWith = supplyWith;
+    }
+}

package/dist/lib/follow-deployment.js

@@ -0,0 +1,127 @@
+import { dataOrThrow } from './client.js';
+import { CliError } from './errors.js';
+import { printResult, startProgress } from './output.js';
+import { commandFor } from './resolve-project.js';
+import { isTransient, realClock, retryTransient } from './retry-transient.js';
+import { color, failure, receipt } from './ui.js';
+const POLL_INTERVAL_MS = 2000;
+const FAILURE_TAIL_LINES = 12;
+export function outcomeOf(deployment) {
+    if (deployment.finishedAt === null)
+        return null;
+    switch (deployment.status) {
+        case 'succeeded':
+            return { status: 'live', deployment: deployment.id };
+        case 'failed': {
+            const failed = deployment.revisions.find((revision) => revision.status === 'failed');
+            if (failed === undefined) {
+                throw new Error(`API reports deployment ${deployment.id} failed without a failed revision`);
+            }
+            return {
+                status: 'failed',
+                deployment: deployment.id,
+                failedService: failed.service,
+                failedServiceId: failed.serviceId,
+                failedRevision: failed.id,
+                failedBuild: failed.build.id,
+                buildFailed: failed.build.status === 'failed',
+            };
+        }
+        case 'cancelled':
+            return { status: 'cancelled', deployment: deployment.id };
+        case 'queued':
+        case 'in-progress':
+            return null;
+    }
+}
+export async function awaitDeployment(api, project, deploymentId, { format, label }, clock = realClock) {
+    const progress = startProgress(format, label);
+    try {
+        for (;;) {
+            const current = await retryTransient((signal) => dataOrThrow(api.GET('/api/projects/{projectId}/deployments/{deploymentId}', {
+                params: { path: { projectId: project.id, deploymentId } },
+                signal,
+            })), clock).catch(async (error) => {
+                if (!isTransient(error) && !(error instanceof CliError && error.code === 'server_error')) {
+                    throw error;
+                }
+                const follow = await commandFor(project, 'grayspar status');
+                throw new CliError(error.code, `${error.code === 'unreachable'
+                    ? "Can't reach Grayspar"
+                    : 'Grayspar stopped answering because of an internal error'}, so this terminal can't follow the deployment.\nIt goes on without this terminal. To follow it, run\n${follow}`);
+            });
+            const outcome = outcomeOf(current);
+            if (outcome !== null) {
+                progress.stop();
+                return outcome;
+            }
+            progress.update(current.status === 'queued' ? `${label} (queued)` : label);
+            await clock.sleep(POLL_INTERVAL_MS);
+        }
+    }
+    catch (error) {
+        progress.stop();
+        throw error;
+    }
+}
+async function buildLogTail(api, project, buildId) {
+    const log = await dataOrThrow(api.GET('/api/projects/{projectId}/builds/{buildId}/logs', {
+        params: { path: { projectId: project.id, buildId } },
+        parseAs: 'text',
+    }));
+    return log
+        .split('\n')
+        .filter((line) => line.trim() !== '')
+        .slice(-FAILURE_TAIL_LINES)
+        .map((line) => color.dim(line));
+}
+export async function printDeployFailure(api, project, outcome) {
+    if (outcome.buildFailed) {
+        const tail = await buildLogTail(api, project, outcome.failedBuild);
+        const command = await commandFor(project, 'grayspar logs --build');
+        process.stdout.write(`${failure(`${outcome.failedService} failed to build`)}\n${tail.join('\n')}\n\n` +
+            `To read the whole log, run\n${command}\n`);
+    }
+    else {
+        const command = await commandFor(project, `grayspar logs --service ${outcome.failedService}`);
+        process.stdout.write(`${failure(`${outcome.failedService} failed to start`)}\nTo see why, run\n${command}\n`);
+    }
+    process.exitCode = 1;
+}
+export async function printReplacedDeploy(project) {
+    const command = await commandFor(project, 'grayspar status');
+    process.stdout.write(`${failure(`A newer deploy of ${project.name} replaced this one`)}\nTo follow it, run\n${command}\n`);
+    process.exitCode = 1;
+}
+export function nextDeployNote(project) {
+    return `It applies the next time ${project.name} deploys.`;
+}
+export async function followRedeploy(api, project, deployment, format, change) {
+    const receipts = change.receipts.map(receipt);
+    if (deployment === null) {
+        printResult(format, { deployment: null }, () => [
+            ...receipts,
+            ...(change.whenNothingIsLive === undefined ? [] : [change.whenNothingIsLive]),
+        ].join('\n'));
+        return;
+    }
+    const outcome = await awaitDeployment(api, project, deployment.id, {
+        format,
+        label: `Redeploying ${project.name}…`,
+    });
+    if (format === 'json') {
+        process.stdout.write(`${JSON.stringify({ deployment: outcome }, null, 2)}\n`);
+        if (outcome.status === 'failed' || outcome.status === 'cancelled')
+            process.exitCode = 1;
+        return;
+    }
+    if (outcome.status === 'failed') {
+        await printDeployFailure(api, project, outcome);
+        return;
+    }
+    if (outcome.status === 'cancelled') {
+        await printReplacedDeploy(project);
+        return;
+    }
+    process.stdout.write(`${[...receipts, receipt(`Redeployed ${project.name}`)].join('\n')}\n`);
+}

package/dist/lib/output.js

@@ -0,0 +1,40 @@
+/* Results go to standard output and diagnostics to standard error, so `--json` output stays machine
+   readable even while something is being explained to the person watching. */
+import { CliError } from './errors.js';
+import { isInteractive } from './prompt.js';
+import { failure, spinner } from './ui.js';
+const INTERNAL_FAILURE = 'The command stopped because of an internal error. Run it again.';
+export function printText(format, text) {
+    if (format === 'text')
+        process.stdout.write(`${text}\n`);
+}
+export function printResult(format, value, text) {
+    process.stdout.write(format === 'json' ? `${JSON.stringify(value, null, 2)}\n` : `${text()}\n`);
+}
+export function printNote(format, text) {
+    if (format === 'text')
+        process.stderr.write(`${text}\n`);
+}
+export function startProgress(format, text) {
+    return format === 'text' && isInteractive()
+        ? spinner(text)
+        : { update: () => undefined, stop: () => undefined };
+}
+export function exitWithError(format, error) {
+    const known = error instanceof CliError ? error : null;
+    if (format === 'json') {
+        process.stdout.write(`${JSON.stringify({
+            status: 'error',
+            error: known?.code ?? 'unexpected',
+            message: known?.message ?? INTERNAL_FAILURE,
+            ...(known === null
+                ? { cause: error instanceof Error ? error.message : String(error) }
+                : {}),
+            ...(known?.supplyWith === undefined ? {} : { supply_with: known.supplyWith }),
+        }, null, 2)}\n`);
+    }
+    else {
+        process.stderr.write(`${failure(known?.message ?? INTERNAL_FAILURE)}\n`);
+    }
+    process.exit(1);
+}

package/dist/lib/project-link.js

@@ -0,0 +1,42 @@
+/* The link binds a folder to a project by id, so renaming the folder never retargets a deploy. It
+   lives in .grayspar and ignores itself, so it stays out of the user's commits. */
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+const LINK_FOLDER = '.grayspar';
+const LINK_FILE = 'project.json';
+export async function findLink(startFolder) {
+    let folder = resolve(startFolder);
+    for (;;) {
+        const found = await readLinkAt(join(folder, LINK_FOLDER, LINK_FILE));
+        if (found !== null)
+            return { ...found, folder };
+        const parent = dirname(folder);
+        if (parent === folder)
+            return null;
+        folder = parent;
+    }
+}
+export async function writeLink(folder, link) {
+    const linkFolder = join(folder, LINK_FOLDER);
+    await mkdir(linkFolder, { recursive: true });
+    await writeFile(join(linkFolder, LINK_FILE), `${JSON.stringify(link, null, 2)}\n`);
+    await writeFile(join(linkFolder, '.gitignore'), '*\n');
+}
+export async function removeLink(folder) {
+    await rm(join(folder, LINK_FOLDER), { recursive: true, force: true });
+}
+async function readLinkAt(path) {
+    try {
+        const parsed = JSON.parse(await readFile(path, 'utf8'));
+        return isLink(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isLink(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'projectId' in value &&
+        typeof value.projectId === 'string');
+}

package/dist/lib/prompt.js

@@ -0,0 +1,103 @@
+/* Without a terminal there is nobody to answer, so a question becomes an error naming the flag that would have carried
+   the answer. A typed question arrives with its suggestion on the line as the answer, and settles into `Label: answer`. */
+import { createPrompt, isEnterKey, useEffect, useKeypress, useState } from '@inquirer/core';
+import select from '@inquirer/select';
+import { CliError } from './errors.js';
+import { color } from './ui.js';
+let jsonOutput = false;
+export function setJsonOutput(isJson) {
+    jsonOutput = isJson;
+}
+export function isInteractive() {
+    return !jsonOutput && Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function refuseWithoutTerminal(message, flag) {
+    throw new CliError('needs_an_answer', `There is no terminal to answer "${message}".\nGive the answer with ${flag}.`, flag);
+}
+export const CTRL_C_EXIT_CODE = 130;
+export async function exitOnCtrlC(work) {
+    try {
+        return await work();
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'ExitPromptError') {
+            process.exit(CTRL_C_EXIT_CODE);
+        }
+        throw error;
+    }
+}
+export async function askChoice(message, label, options, flag) {
+    if (!isInteractive())
+        refuseWithoutTerminal(message, flag);
+    const choices = options.map((option) => ({ name: option.label, value: option.value }));
+    const theme = {
+        prefix: '',
+        icon: { cursor: '>' },
+        style: {
+            message: (text, status) => status === 'done' ? `${label}:` : color.heading(`${text}:`),
+            answer: (text) => text,
+        },
+    };
+    return exitOnCtrlC(() => select({ message, choices, theme }));
+}
+const textPrompt = createPrompt((config, done) => {
+    const [answered, setAnswered] = useState(false);
+    const [value, setValue] = useState(config.suggestion ?? '');
+    useEffect((rl) => {
+        if (config.suggestion !== null)
+            rl.write(config.suggestion);
+    }, [config.suggestion]);
+    useKeypress((key, rl) => {
+        if (answered)
+            return;
+        if (!isEnterKey(key)) {
+            setValue(rl.line);
+            return;
+        }
+        const answer = value.trim();
+        setValue(answer);
+        if (answer === '')
+            return;
+        setAnswered(true);
+        done(answer);
+    });
+    return answered ? `${config.label}: ${value}` : `${color.heading(`${config.label}:`)} ${value}`;
+});
+const yesNoPrompt = createPrompt((config, done) => {
+    const [answer, setAnswer] = useState(null);
+    const [value, setValue] = useState('');
+    useKeypress((key, rl) => {
+        if (answer !== null)
+            return;
+        if (!isEnterKey(key)) {
+            setValue(rl.line);
+            return;
+        }
+        const typed = value.trim().toLowerCase();
+        const given = typed === ''
+            ? config.answerByDefault
+            : ['y', 'yes'].includes(typed)
+                ? true
+                : ['n', 'no'].includes(typed)
+                    ? false
+                    : null;
+        setValue('');
+        if (given === null)
+            return;
+        setAnswer(given);
+        done(given);
+    });
+    if (answer !== null)
+        return `${config.message} ${answer ? 'Yes' : 'No'}`;
+    return `${color.heading(config.message)} ${config.answerByDefault ? '(Y/n)' : '(y/N)'} ${value}`;
+});
+export async function askYesNo(message, answerByDefault, flag) {
+    if (!isInteractive())
+        refuseWithoutTerminal(message, flag);
+    return exitOnCtrlC(() => yesNoPrompt({ message, answerByDefault }));
+}
+export async function askText(label, suggestion, flag) {
+    if (!isInteractive())
+        refuseWithoutTerminal(label, flag);
+    return exitOnCtrlC(() => textPrompt({ label, suggestion }));
+}

package/dist/lib/resolve-project.js

@@ -0,0 +1,60 @@
+import { dataOrThrow } from './client.js';
+import { CliError } from './errors.js';
+import { findLink } from './project-link.js';
+import { askChoice } from './prompt.js';
+import { resolveTeam, teamIsNamed } from './resolve-team.js';
+let namedProject;
+export function setNamedProject(slug) {
+    namedProject = slug;
+}
+export function projectIsNamed() {
+    return namedProject !== undefined;
+}
+export function teamProjects(api, teamId) {
+    return dataOrThrow(api.GET('/api/teams/{teamId}/projects', { params: { path: { teamId } } }));
+}
+export async function commandFor(project, command) {
+    const link = await findLink(process.cwd());
+    return link?.projectId === project.id ? command : `${command} --project ${project.name}`;
+}
+export async function resolveProject(api, { followLink = true } = {}) {
+    if (namedProject !== undefined)
+        return projectNamed(api, namedProject);
+    const link = followLink ? await findLink(process.cwd()) : null;
+    if (link !== null) {
+        const answer = await api.GET('/api/projects/{projectId}', {
+            params: { path: { projectId: link.projectId } },
+        });
+        if (answer.response.status === 404) {
+            throw new CliError('link_outdated', 'The project this folder is linked to no longer exists. Run grayspar link.', '--project');
+        }
+        return dataOrThrow(Promise.resolve(answer));
+    }
+    return selectProject(api, await resolveTeam(api));
+}
+async function selectProject(api, team) {
+    const projects = await teamProjects(api, team.id);
+    const [first] = projects;
+    if (first === undefined) {
+        throw new CliError('no_projects', `${team.name} has no projects yet. Deploy one first.`);
+    }
+    const id = await askChoice('Select a project', 'Project', projects.map((project) => ({ value: project.id, label: project.name })), '--project');
+    return projects.find((project) => project.id === id) ?? first;
+}
+async function projectNamed(api, given) {
+    const teams = teamIsNamed() ? [await resolveTeam(api)] : await dataOrThrow(api.GET('/api/teams'));
+    const matches = [];
+    for (const team of teams) {
+        const project = (await teamProjects(api, team.id)).find((candidate) => candidate.name === given);
+        if (project !== undefined)
+            matches.push({ team, project });
+    }
+    const [only] = matches;
+    if (only === undefined) {
+        throw new CliError('no_such_project', `You have no project called ${given}.\nRun grayspar project to see your projects.`, '--project');
+    }
+    if (matches.length === 1)
+        return only.project;
+    const team = await resolveTeam(api, { among: matches.map((match) => match.team) });
+    return matches.find((match) => match.team.id === team.id)?.project ?? only.project;
+}

package/dist/lib/resolve-service.js

@@ -0,0 +1,29 @@
+import { CliError } from './errors.js';
+import { askChoice } from './prompt.js';
+import { resolveProject } from './resolve-project.js';
+export async function resolveService(api, serviceName, answeredBy = '--service') {
+    const project = await resolveProject(api);
+    const [first] = project.services;
+    if (first === undefined) {
+        throw new CliError('never_deployed', `${project.name} has no services yet. Deploy it first.`);
+    }
+    if (serviceName !== undefined) {
+        const service = project.services.find((candidate) => candidate.name === serviceName);
+        if (service === undefined) {
+            throw new CliError('no_such_service', `${project.name} has no service called ${serviceName}.\nRun grayspar status to see its services.`, answeredBy);
+        }
+        return { project, service };
+    }
+    if (project.services.length === 1)
+        return { project, service: first };
+    const id = await askChoice('Select a service', 'Service', project.services.map((service) => ({ value: service.id, label: service.name })), answeredBy);
+    return { project, service: project.services.find((service) => service.id === id) ?? first };
+}
+export async function resolveServices(api, serviceName) {
+    if (serviceName === undefined) {
+        const project = await resolveProject(api);
+        return { project, services: project.services };
+    }
+    const { project, service } = await resolveService(api, serviceName);
+    return { project, services: [service] };
+}

package/dist/lib/resolve-team.js

@@ -0,0 +1,31 @@
+import { dataOrThrow } from './client.js';
+import { CliError } from './errors.js';
+import { askChoice } from './prompt.js';
+let namedTeam;
+export function setNamedTeam(slug) {
+    namedTeam = slug;
+}
+export function teamIsNamed() {
+    return namedTeam !== undefined;
+}
+export async function resolveTeam(api, options = {}) {
+    const all = options.among ?? (await dataOrThrow(api.GET('/api/teams')));
+    const teams = options.deploying === true ? all.filter((team) => team.can.deploy) : all;
+    if (namedTeam !== undefined) {
+        const team = all.find((candidate) => candidate.slug === namedTeam);
+        if (team === undefined) {
+            throw new CliError('no_such_team', `You aren't in a team called ${namedTeam}.`, '--team');
+        }
+        return team;
+    }
+    const [first] = teams;
+    if (first === undefined) {
+        throw all.length === 0
+            ? new CliError('no_team', 'This account belongs to no team.')
+            : new CliError('view_only', 'You can only view the projects in your teams, so none can take a deploy.');
+    }
+    if (teams.length === 1 || options.takeDefault === true)
+        return first;
+    const id = await askChoice('Select a team', 'Team', teams.map((team) => ({ value: team.id, label: team.name })), '--team');
+    return teams.find((team) => team.id === id) ?? first;
+}