@grayspar/cli 0.0.3 → 0.0.5

package/dist/commands/access.js

@@ -87,17 +87,17 @@ accessCommand
 accessCommand
     .command('add')
     .argument('<targets...>', 'email addresses, or @company.example for everyone at a company')
-    .description('let named people or a whole company open a project')
+    .description('let people or a whole company open a project')
     .action(commandAction((format, _command, targets) => addAccess(targets, format)));
 accessCommand
     .command('remove')
     .argument('<target>', 'an email address, or @company.example')
-    .description('take someone or a company off a project')
+    .description("remove a person or company from a project's list")
     .action(commandAction((format, _command, target) => removeAccess(target, format)));
 accessCommand
     .command('set')
     .addOption(new Option('--mode <mode>', 'restricted lets in the people and companies on the list, open lets in anyone with the link')
     .choices(['restricted', 'open'])
     .makeOptionMandatory())
-    .description('choose whether the list decides who can open a project')
+    .description('choose whether only the list or anyone with the link can open a project')
     .action(commandAction((format, command) => setGeneralAccess(command.opts().mode, format)));

package/dist/commands/deploy/deploy.js

@@ -159,7 +159,7 @@ async function watchDeployment(api, project, deploymentId, format) {
     };
     process.once('SIGINT', stopWatching);
     try {
-        return await awaitDeployment(api, project, deploymentId, { format, label: 'Deploying…' });
+        return await awaitDeployment(api, project, deploymentId, { format, label: 'Queued…' });
     }
     finally {
         process.off('SIGINT', stopWatching);
@@ -179,7 +179,7 @@ async function printOutcome(api, project, outcome) {
 }
 export const deployCommand = new Command('deploy')
     .argument('[folder]', 'deploy only the files under this folder of the project', '.')
-    .description('build a project folder and put it online')
+    .description('build a folder and put it online as a project')
     .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')

package/dist/commands/env.js

@@ -61,11 +61,11 @@ envCommand
     .command('set')
     .argument('<pairs...>', 'variables written as KEY=VALUE')
     .addOption(serviceOption('which service to set them on'))
-    .description('add or change environment variables')
+    .description('set variables on a service')
     .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')
+    .description('remove variables from a service')
     .action(commandAction((format, command, keys) => removeVariables(keys, serviceNameOf(command), format)));

package/dist/commands/link.js

@@ -21,8 +21,8 @@ async function unlink(format) {
     printResult(format, { status: 'ok' }, () => receipt(`Unlinked ${found.folder}`));
 }
 export const linkCommand = new Command('link')
-    .description('bind this folder to a project')
+    .description('link this folder to a project')
     .action(commandAction((format) => link(format)));
 export const unlinkCommand = new Command('unlink')
-    .description('unbind this folder from its project')
+    .description('unlink this folder from its project')
     .action(commandAction((format) => unlink(format)));

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

@@ -1,6 +1,5 @@
-/* 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. The browser hears nothing until
-   the CLI has traded the code, so what its page says is true. */
+/* Listens on a port the machine picks for one redirect, then closes. The verifier that makes the browser's code usable
+   never leaves this process, and the browser hears nothing until the code is traded, so its page tells the truth. */
 import { createServer } from 'node:http';
 function browserPage(mark, markColor, title, detail) {
     return `<!doctype html><meta charset="utf-8"><meta name="color-scheme" content="light dark">

package/dist/commands/logout.js

@@ -14,5 +14,5 @@ async function logout(format) {
         : `${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')
+    .description('sign out on this machine')
     .action(commandAction((format) => logout(format)));

package/dist/commands/logs.js

@@ -1,19 +1,21 @@
 /* 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. */
+   Following asks for what came after the position the last answer named, every two seconds. */
 import { setTimeout as pause } from 'node:timers/promises';
 import { Command } from 'commander';
+import { buildLogFollower, wholeBuildLog } from '../lib/build-logs.js';
 import { dataOrThrow, signedInClient } from '../lib/client.js';
 import { commandAction, serviceOption } from '../lib/command-helpers.js';
 import { CliError } from '../lib/errors.js';
+import { printNote } from '../lib/output.js';
 import { resolveProject } from '../lib/resolve-project.js';
 import { resolveService } from '../lib/resolve-service.js';
-import { retryTransient } from '../lib/retry-transient.js';
+import { isTransient, realClock, 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);
+        return printBuildLogs(api, format, options.follow);
     const { project, service } = await resolveService(api, options.service);
     const readLogs = (after, signal) => dataOrThrow(api.GET('/api/projects/{projectId}/services/{serviceId}/logs', {
         params: {
@@ -22,7 +24,11 @@ async function logs(options, format) {
         },
         signal,
     }));
-    const first = await readLogs();
+    const noteTheDelay = () => printNote(format, 'Logs are delayed. Trying again.');
+    const read = (after) => (options.follow
+        ? retryTransient((signal) => readLogs(after, signal), realClock, noteTheDelay)
+        : readLogs(after)).catch(refuseAsDelayed);
+    const first = await read();
     if (!options.follow && format === 'text' && first.lines.length === 0) {
         process.stdout.write(`${service.name} has printed nothing yet.\n`);
         return;
@@ -30,14 +36,19 @@ async function logs(options, format) {
     printLogLines(first.lines, format);
     if (!options.follow)
         return;
-    let after = first.lines.at(-1)?.id;
+    let after = first.next ?? undefined;
     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;
+        const page = await read(after);
+        printLogLines(page.lines, format);
+        after = page.next ?? undefined;
     }
 }
+function refuseAsDelayed(error) {
+    throw isTransient(error)
+        ? new CliError(error.code, 'Logs are delayed. Try again in a moment.')
+        : error;
+}
 function printLogLines(lines, format) {
     for (const line of lines) {
         process.stdout.write(format === 'json'
@@ -45,7 +56,7 @@ function printLogLines(lines, format) {
             : `${color.dim(new Date(line.at).toLocaleTimeString())}  ${line.text}\n`);
     }
 }
-async function printBuildLogs(api, format) {
+async function printBuildLogs(api, format, follow) {
     const project = await resolveProject(api);
     const { deployments } = await dataOrThrow(api.GET('/api/projects/{projectId}/deployments', {
         params: { path: { projectId: project.id } },
@@ -54,13 +65,25 @@ async function printBuildLogs(api, format) {
     if (latest === undefined) {
         throw new CliError('never_deployed', `${project.name} hasn't been deployed yet.`);
     }
+    if (follow) {
+        const readNewLines = buildLogFollower(api, project.id, (service, text) => {
+            process.stdout.write(format === 'json' ? `${JSON.stringify({ service, text })}\n` : `${service}  ${text}\n`);
+        });
+        for (;;) {
+            const current = await retryTransient((signal) => dataOrThrow(api.GET('/api/projects/{projectId}/deployments/{deploymentId}', {
+                params: { path: { projectId: project.id, deploymentId: latest.id } },
+                signal,
+            })));
+            await retryTransient(() => readNewLines(current.revisions));
+            if (current.revisions.every((revision) => revision.build.finishedAt !== null))
+                return;
+            await pause(FOLLOW_INTERVAL_MS);
+        }
+    }
     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',
-        })),
+        log: await wholeBuildLog(api, project.id, revision.build.id),
     })));
     if (format === 'json') {
         for (const { service, log } of builds) {
@@ -75,15 +98,15 @@ async function printBuildLogs(api, format) {
     }
 }
 export const logsCommand = new Command('logs')
-    .description('show what a service printed while running, or with --build the last build log')
+    .description("show a service's logs, or with --build its 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')
+    .option('-f', '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,
+        follow: options.f === true,
     }, format);
 }));

package/dist/commands/project.js

@@ -2,10 +2,13 @@
 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 { teamProjects } from '../lib/resolve-project.js';
+import { findLink, removeLink } from '../lib/project-link.js';
+import { askText } from '../lib/prompt.js';
+import { resolveProject, teamProjects } from '../lib/resolve-project.js';
 import { resolveTeam, teamIsNamed } from '../lib/resolve-team.js';
-import { color, tableOrEmptyNote } from '../lib/ui.js';
+import { color, receipt, 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'));
@@ -15,8 +18,28 @@ async function listProjects(format) {
         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 async function removeProject(skipAsking, format) {
+    const api = await signedInClient();
+    const project = await resolveProject(api);
+    if (!skipAsking) {
+        const typed = await askText(`Type ${project.name} to remove it and everything in it`, null, '--yes');
+        if (typed !== project.name) {
+            throw new CliError('name_mismatch', `That isn't ${project.name}. The project stays.`);
+        }
+    }
+    await dataOrThrow(api.DELETE('/api/projects/{projectId}', { params: { path: { projectId: project.id } } }));
+    const link = await findLink(process.cwd());
+    if (link?.projectId === project.id)
+        await removeLink(link.folder);
+    printResult(format, { status: 'removed', project: project.name }, () => receipt(`Removed project ${project.name}`));
+}
 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)));
+projectCommand
+    .command('remove')
+    .option('-y, --yes', 'remove it without asking')
+    .description('remove a project with its services, volumes, variables and deployments')
+    .action(commandAction((format, command) => removeProject(command.opts().yes === true, format)));

package/dist/commands/restart.js

@@ -16,6 +16,6 @@ async function restart(serviceName, format) {
     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')
+    .description("start a fresh copy of a service's running version")
     .addOption(serviceOption('which service to restart'))
     .action(commandAction((format, command) => restart(serviceNameOf(command), format)));

package/dist/commands/service.js

@@ -4,6 +4,7 @@ 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 { askText } from '../lib/prompt.js';
 import { resolveService } from '../lib/resolve-service.js';
 import { receipt } from '../lib/ui.js';
 function receiptsFor(service, change) {
@@ -38,7 +39,21 @@ async function setService(serviceName, change, format) {
     ];
     printResult(format, { status: 'ok' }, () => lines.join('\n'));
 }
-export const serviceCommand = new Command('service').description('change where a service answers and how it is built');
+async function removeService(serviceName, skipAsking, format) {
+    const api = await signedInClient();
+    const { project, service } = await resolveService(api, serviceName, '<name>');
+    if (!skipAsking) {
+        const typed = await askText(`Type ${service.name} to remove it with its volume and variables`, null, '--yes');
+        if (typed !== service.name) {
+            throw new CliError('name_mismatch', `That isn't ${service.name}. The service stays.`);
+        }
+    }
+    await dataOrThrow(api.DELETE('/api/projects/{projectId}/services/{serviceId}', {
+        params: { path: { projectId: project.id, serviceId: service.id } },
+    }));
+    printResult(format, { status: 'removed', service: service.name, project: project.name }, () => `${receipt(`Removed service ${service.name} from ${project.name}`)}\nAny future grayspar deploy will redeploy the ${service.name} service.`);
+}
+export const serviceCommand = new Command('service').description('change where a service answers and how it is built, or remove it');
 serviceCommand
     .command('set')
     .argument('[name]', 'the service to change, left out when the project has one')
@@ -61,3 +76,9 @@ serviceCommand
     };
     return setService(name, change, format);
 }));
+serviceCommand
+    .command('remove')
+    .argument('<name>', 'the service to remove')
+    .option('-y, --yes', 'remove it without asking')
+    .description('remove a service with its volume and variables')
+    .action(commandAction((format, command, name) => removeService(name, command.opts().yes === true, format)));

package/dist/commands/status.js

@@ -11,5 +11,5 @@ async function status(format) {
     printResult(format, project, () => `${color.heading(project.name)}\n\n${servicesTable(project)}`);
 }
 export const statusCommand = new Command('status')
-    .description('show what a project is doing')
+    .description("show each service's address and status")
     .action(commandAction((format) => status(format)));

package/dist/commands/volume.js

@@ -66,22 +66,22 @@ export async function removeVolume(mountPath, serviceName, skipAsking, format) {
         receipts: [`Removed volume ${mountPath} from ${service.name} and deleted its data`],
     });
 }
-export const volumeCommand = new Command('volume').description('keep a folder across deploys');
+export const volumeCommand = new Command('volume').description('keep folders across deploys with volumes');
 volumeCommand
     .command('list', { isDefault: true })
     .addOption(serviceOption('which service to read'))
-    .description('list the folders a service keeps')
+    .description('list the volumes of a project')
     .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')
+    .description('add a volume to a service')
     .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')
+    .description('delete a volume and its data')
     .action(commandAction((format, command, path) => removeVolume(path, serviceNameOf(command), command.opts().yes === true, format)));

package/dist/commands/whoami.js

@@ -12,5 +12,5 @@ async function whoami(format) {
     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')
+    .description('show which account this machine is signed in with')
     .action(commandAction((format) => whoami(format)));

package/dist/index.js

@@ -1,58 +1,9 @@
 #!/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);
+import { program } from './program.js';
+// A reader such as `head` can leave early, which ends the output and nothing more.
+process.stdout.on('error', (error) => {
+    if (error.code === 'EPIPE')
+        process.exit(0);
+    throw error;
 });
-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/build-logs.js

@@ -0,0 +1,36 @@
+import { dataOrThrow } from './client.js';
+function completeLines(held, text) {
+    const parts = `${held}${text}`.split('\n');
+    return { lines: parts.slice(0, -1), held: parts.at(-1) ?? '' };
+}
+async function readBuildLog(api, projectId, buildId, after) {
+    const page = await dataOrThrow(api.GET('/api/projects/{projectId}/builds/{buildId}/logs', {
+        params: { path: { projectId, buildId }, query: after === undefined ? {} : { after } },
+    }));
+    return { text: page.chunks.map((chunk) => chunk.text).join(''), next: page.next };
+}
+export async function wholeBuildLog(api, projectId, buildId) {
+    return (await readBuildLog(api, projectId, buildId)).text;
+}
+export function buildLogFollower(api, projectId, print) {
+    const builds = new Map();
+    return async (revisions) => {
+        for (const { service, build } of revisions) {
+            const followed = builds.get(build.id) ?? { held: '', finished: false };
+            builds.set(build.id, followed);
+            if (build.startedAt === null || followed.finished)
+                continue;
+            const page = await readBuildLog(api, projectId, build.id, followed.after);
+            followed.after = page.next ?? undefined;
+            const { lines, held } = completeLines(followed.held, page.text);
+            followed.held = held;
+            for (const line of lines)
+                print(service, line);
+            if (build.finishedAt !== null) {
+                if (followed.held !== '')
+                    print(service, followed.held);
+                followed.finished = true;
+            }
+        }
+    };
+}

package/dist/lib/client.js

@@ -63,7 +63,7 @@ export async function dataOrThrow(pending) {
         ? error.detail
         : null;
     if (status >= 500) {
-        throw detail === null
+        throw detail === null || answer.response.headers.has('retry-after')
             ? new CliError('unavailable', "Grayspar didn't answer. Try again in a moment.")
             : new CliError('server_error', detail);
     }

package/dist/lib/follow-deployment.js

@@ -1,3 +1,4 @@
+import { wholeBuildLog } from './build-logs.js';
 import { dataOrThrow } from './client.js';
 import { CliError } from './errors.js';
 import { printResult, startProgress } from './output.js';
@@ -6,6 +7,11 @@ 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;
+const STATUS_LINES = {
+    queued: 'Queued…',
+    building: 'Building…',
+    deploying: 'Deploying…',
+};
 export function outcomeOf(deployment) {
     if (deployment.finishedAt === null)
         return null;
@@ -30,7 +36,8 @@ export function outcomeOf(deployment) {
         case 'cancelled':
             return { status: 'cancelled', deployment: deployment.id };
         case 'queued':
-        case 'in-progress':
+        case 'building':
+        case 'deploying':
             return null;
     }
 }
@@ -55,7 +62,7 @@ export async function awaitDeployment(api, project, deploymentId, { format, labe
                 progress.stop();
                 return outcome;
             }
-            progress.update(current.status === 'queued' ? `${label} (queued)` : label);
+            progress.update(STATUS_LINES[current.status] ?? label);
             await clock.sleep(POLL_INTERVAL_MS);
         }
     }
@@ -65,10 +72,7 @@ export async function awaitDeployment(api, project, deploymentId, { format, labe
     }
 }
 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',
-    }));
+    const log = await wholeBuildLog(api, project.id, buildId);
     return log
         .split('\n')
         .filter((line) => line.trim() !== '')

package/dist/lib/retry-transient.js

@@ -1,6 +1,5 @@
-/* A request that never arrived or failed without Grayspar's own answer is tried again with a growing, jittered wait,
-   for as long as failures follow one another without a break, then the last failure is let through. The two minutes
-   count from the start of the first failing attempt, and each later attempt is cut off when they are up. */
+/* A request that never arrived or failed without Grayspar's answer retries with growing, jittered waits while failures
+   run unbroken, for two minutes from the first failing attempt, which also end the last; then the failure stands. */
 import { setTimeout as pause } from 'node:timers/promises';
 import { CliError } from './errors.js';
 const FIRST_DELAY_MS = 1000;
@@ -10,7 +9,7 @@ export const realClock = { now: () => Date.now(), sleep: (ms) => pause(ms) };
 export function isTransient(error) {
     return (error instanceof CliError && (error.code === 'unreachable' || error.code === 'unavailable'));
 }
-export async function retryTransient(work, clock = realClock) {
+export async function retryTransient(work, clock = realClock, onWaiting) {
     let failingSince = null;
     for (let attempt = 0;; attempt += 1) {
         const started = clock.now();
@@ -22,6 +21,8 @@ export async function retryTransient(work, clock = realClock) {
         catch (error) {
             if (!isTransient(error))
                 throw error;
+            if (failingSince === null)
+                onWaiting?.();
             failingSince ??= started;
             if (clock.now() - failingSince >= GIVE_UP_AFTER_MS)
                 throw error;

package/dist/lib/services-table.js

@@ -5,6 +5,8 @@ const RUNTIME_STATUS = {
     running: { label: 'Running', tint: color.ok },
     restarting: { label: 'Restarting', tint: untinted },
     crashed: { label: 'Crashed', tint: color.bad },
+    sleeping: { label: 'Sleeping', tint: untinted },
+    stopped: { label: 'Stopped', tint: untinted },
     unknown: { label: 'Unknown', tint: untinted },
     failed: { label: 'Failed', tint: color.bad },
 };

package/dist/program.js

@@ -0,0 +1,56 @@
+/* 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';
+export 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grayspar/cli",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "The cloud for small software. Deploy your applications with one command, and share them with exactly the people you choose.",
   "repository": {
     "type": "git",