@grayspar/cli 0.0.0-stage → 0.0.1

package/dist/commands/login/login.js

@@ -0,0 +1,56 @@
+import { randomBytes } from 'node:crypto';
+import { Command } from 'commander';
+import { DEFAULT_API_URL, 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, printText, 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('/api/cli/authorize', apiUrl);
+    url.searchParams.set('port', String(listener.port));
+    url.searchParams.set('challenge', challengeFor(verifier));
+    printText(options.format, `${color.heading('Grayspar login')}\n${url.toString()}`);
+    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 },
+            });
+            if (session === undefined) {
+                throw new CliError('sign_in_refused', 'That sign-in did not complete. Try again.');
+            }
+            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, which is also the SSH path. 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,36 @@
+/* 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';
+const SIGNED_IN_PAGE = `<!doctype html><meta charset="utf-8"><title>Signed in</title>
+<body style="font:16px/1.5 system-ui;margin:4rem auto;max-width:28rem;text-align:center">
+<h1 style="font-size:1.25rem">You are signed in</h1>
+<p>You can close this window and go back to your terminal.</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('The 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,30 @@
+/* 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 it stays valid there until six months pass unused. */
+import { Command } from 'commander';
+import { signedInClient } from '../lib/client.js';
+import { commandAction } from '../lib/command-helpers.js';
+import { clearCredentials, readCredentials } from '../lib/credentials.js';
+import { printResult } from '../lib/output.js';
+import { receipt, warning } from '../lib/ui.js';
+async function endSessionOnGrayspar() {
+    if ((await readCredentials()) === null)
+        return true;
+    try {
+        const api = await signedInClient();
+        const { response } = await api.DELETE('/api/cli/session');
+        return response.ok || response.status === 401;
+    }
+    catch {
+        return false;
+    }
+}
+async function logout(format) {
+    const ended = await endSessionOnGrayspar();
+    await clearCredentials();
+    printResult(format, { status: 'ok', revoked: ended }, () => ended
+        ? receipt('Signed out')
+        : `${receipt('Signed out on this machine')}\n${warning('Grayspar could not be reached, so this sign-in stays valid there until it goes unused for six months.')}`);
+}
+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,84 @@
+/* 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 { 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) => dataOrThrow(api.GET('/api/projects/{id}/services/{serviceId}/logs', {
+        params: {
+            path: { id: project.id, serviceId: service.id },
+            query: after === undefined ? {} : { after },
+        },
+    }));
+    const first = await readLogs();
+    if (!options.follow) {
+        if (format === 'json')
+            process.stdout.write(`${JSON.stringify(first, null, 2)}\n`);
+        else if (first.lines.length === 0)
+            process.stdout.write(`${service.name} has printed nothing yet.\n`);
+        else
+            printLogLines(first.lines, format);
+        return;
+    }
+    printLogLines(first.lines, format);
+    let after = first.lines.at(-1)?.id;
+    for (;;) {
+        await pause(FOLLOW_INTERVAL_MS);
+        const next = await readLogs(after);
+        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/{id}/deployments', { params: { path: { id: project.id } } }));
+    const latest = deployments[0];
+    if (latest === undefined) {
+        throw new CliError('never_deployed', `${project.name} has not been deployed yet.`);
+    }
+    const builds = await Promise.all(latest.builds.map(async (build) => ({
+        service: build.service,
+        status: build.status,
+        log: await dataOrThrow(api.GET('/api/projects/{id}/deployments/{deployId}/builds/{buildId}/logs', {
+            params: { path: { id: project.id, deployId: latest.id, buildId: build.id } },
+            parseAs: 'text',
+        })),
+    })));
+    if (format === 'json') {
+        process.stdout.write(`${JSON.stringify({ deployment: latest.id, builds }, null, 2)}\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/{id}/open-paths', {
+        params: { path: { id: 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/{id}/open-paths', {
+        params: { path: { id: 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,19 @@
+/* A restart runs the same container again in place, so the service keeps its volumes 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 { 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/{id}/services/{serviceId}/restart', {
+        params: { path: { id: project.id, serviceId: service.id } },
+    }));
+    printResult(format, { status: 'restarting', project: project.name, service: service.name }, () => `Restarting ${service.name}.\nTo follow it, run\ngrayspar status --project ${project.name}`);
+}
+export const restartCommand = new Command('restart')
+    .description('run a service again in place, keeping its volumes')
+    .addOption(serviceOption('which service to restart'))
+    .action(commandAction((format, command) => restart(serviceNameOf(command), format)));

package/dist/commands/service.js

@@ -0,0 +1,72 @@
+/* A new port redeploys whatever is live. A path or a name is read on every request and a Dockerfile at the next
+   build, so changing those 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 { appliesOnNextDeploy, followRedeploy } from '../lib/follow-deployment.js';
+import { resolveService } from '../lib/resolve-service.js';
+function receiptsFor(service, change) {
+    return [
+        change.port === undefined ? null : `Set port of ${service} to ${change.port}`,
+        change.pathPrefix === undefined
+            ? null
+            : change.pathPrefix === null
+                ? `Removed path of ${service}, so only the project's other services reach it`
+                : `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((receipt) => receipt !== null);
+}
+function appliesNoteFor(project, change) {
+    if (change.port !== undefined)
+        return appliesOnNextDeploy(project);
+    return change.dockerfile === undefined ? undefined : 'The next deploy builds with it.';
+}
+async function setService(serviceName, change, format) {
+    if (Object.keys(change).length === 0) {
+        throw new CliError('nothing_to_change', 'Name a change, such as a port or a path.', '--path');
+    }
+    if (change.port !== undefined && !Number.isInteger(change.port)) {
+        throw new CliError('bad_port', 'Give the port as a whole number, like 3000.', '--port');
+    }
+    const api = await signedInClient();
+    const { project, service } = await resolveService(api, serviceName, '<name>');
+    const saved = await dataOrThrow(api.PATCH('/api/projects/{id}/services/{serviceId}', {
+        params: { path: { id: project.id, serviceId: service.id } },
+        body: change,
+    }));
+    await followRedeploy(api, project, saved.deployment, format, {
+        receipts: receiptsFor(service.name, change),
+        whenNothingIsLive: appliesNoteFor(project, change),
+    });
+}
+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('--port <port>', 'the port the service listens on')
+    .option('--path <path>', 'where the service answers at the project address')
+    .option('--no-path', 'reach the service only from the project\u2019s 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\u2019s port, path, name or Dockerfile')
+    .action(commandAction((format, command, name) => {
+    const options = command.opts();
+    const change = {
+        ...(options.port === undefined ? {} : { port: Number(options.port) }),
+        ...(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,73 @@
+/* A volume keeps one folder of a service across deploys. It starts at 1 GB and grows by itself while the
+   plan has room; adding or removing one redeploys whatever is live so the change 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 { 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';
+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, volumes: service.volumes }));
+    printResult(format, listed, () => {
+        const rows = listed.flatMap(({ service, volumes }) => volumes.map((volume) => [
+            service,
+            volume.mountPath,
+            `${readableSize(volume.usedBytes)} of ${readableSize(volume.sizeBytes)}`,
+        ]));
+        return tableOrEmptyNote(['SERVICE', 'PATH', 'USED'], rows, `${serviceName ?? project.name} has no volumes.`);
+    });
+}
+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/{id}/services/{serviceId}/volumes', {
+        params: { path: { id: project.id, serviceId: service.id } },
+        body: { mountPath },
+    }));
+    await followRedeploy(api, project, added.deployment, format, {
+        receipts: [`Added volume ${mountPath} to ${service.name}`],
+        whenNothingIsLive: appliesOnNextDeploy(project),
+    });
+}
+async function removeVolume(mountPath, serviceName, format) {
+    const api = await signedInClient();
+    const { project, service } = await resolveService(api, serviceName);
+    const volume = service.volumes.find((candidate) => candidate.mountPath === mountPath);
+    if (volume === undefined) {
+        throw new CliError('no_such_volume', `${service.name} has no volume at ${mountPath}.`);
+    }
+    const removed = await dataOrThrow(api.DELETE('/api/projects/{id}/services/{serviceId}/volumes/{volumeId}', {
+        params: { path: { id: 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'))
+    .description('stop keeping a folder, and throw its data away')
+    .action(commandAction((format, command, path) => removeVolume(path, serviceNameOf(command), 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)));

package/dist/index.js

@@ -0,0 +1,53 @@
+#!/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 { setNamedProject } from './lib/resolve-project.js';
+import { setNamedTeam } from './lib/resolve-team.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')
+    .hook('preAction', (_program, command) => {
+    const { team, project } = command.optsWithGlobals();
+    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);
+}
+await program.parseAsync(process.argv);

package/dist/lib/client.js

@@ -0,0 +1,45 @@
+/* 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';
+export async function signedInClient() {
+    const credentials = await readCredentials();
+    if (credentials === null) {
+        throw new CliError('not_signed_in', 'You are not signed in. Run grayspar login.');
+    }
+    return clientAt(process.env.GRAYSPAR_API_URL ?? credentials.apiUrl, {
+        authorization: `Bearer ${credentials.token}`,
+    });
+}
+export function publicClient(baseUrl) {
+    return clientAt(baseUrl, {});
+}
+function clientAt(baseUrl, headers) {
+    const client = createClient({
+        baseUrl,
+        headers: { ...headers, 'x-grayspar-cli': cliVersion },
+    });
+    client.use({
+        onError: () => new CliError('unreachable', `Grayspar could not be reached 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;
+    throw new CliError('refused', typeof error === 'object' &&
+        error !== null &&
+        'detail' in error &&
+        typeof error.detail === 'string'
+        ? error.detail
+        : `The server answered ${String(status)}.`);
+}

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);
+        }
+    };
+}