@grayspar/cli 0.0.1 → 0.0.2

package/dist/commands/service.js

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

package/dist/commands/volume.js

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

package/dist/index.js

@@ -16,8 +16,10 @@ 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')
@@ -26,8 +28,10 @@ const program = new Command()
     .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 { team, project } = command.optsWithGlobals();
+    const { json, team, project } = command.optsWithGlobals();
+    setJsonOutput(json === true);
     setNamedTeam(team);
     setNamedProject(project);
 });
@@ -50,4 +54,5 @@ for (const command of [
 ]) {
     program.addCommand(command);
 }
+routeUsageErrors(program);
 await program.parseAsync(process.argv);

package/dist/lib/client.js

@@ -5,14 +5,31 @@ 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 are not signed in. Run grayspar login.');
+        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;
     }
-    return clientAt(process.env.GRAYSPAR_API_URL ?? credentials.apiUrl, {
-        authorization: `Bearer ${credentials.token}`,
-    });
 }
 export function publicClient(baseUrl) {
     return clientAt(baseUrl, {});
@@ -21,9 +38,12 @@ 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', `Grayspar could not be reached at ${baseUrl}.\nCheck your connection, then run the command again.`),
+        onError: () => new CliError('unreachable', `Can't reach Grayspar at ${baseUrl}.\nCheck your connection, then run the command again.`),
     });
     return client;
 }
@@ -36,10 +56,16 @@ export async function dataOrThrow(pending) {
         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' &&
+    const detail = typeof error === 'object' &&
         error !== null &&
         'detail' in error &&
         typeof error.detail === 'string'
         ? error.detail
-        : `The server answered ${String(status)}.`);
+        : 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/credentials.js

@@ -1,6 +1,6 @@
 /* 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, rm, writeFile } from 'node:fs/promises';
+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() {
@@ -20,8 +20,19 @@ export async function readCredentials() {
 export async function writeCredentials(credentials) {
     const path = credentialsPath();
     await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-    await writeFile(path, `${JSON.stringify(credentials, null, 2)}\n`, { mode: 0o600 });
-    await chmod(path, 0o600);
+    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 });

package/dist/lib/follow-deployment.js

@@ -1,43 +1,62 @@
 import { dataOrThrow } from './client.js';
-import { portLines } from './listening.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 POLL_CEILING_MS = 12 * 60 * 1000;
-export async function awaitDeployment(api, project, deploymentId, { format, label }) {
+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);
-    const deadline = Date.now() + POLL_CEILING_MS;
     try {
         for (;;) {
-            const current = await dataOrThrow(api.GET('/api/projects/{id}/deployments/{deployId}', {
-                params: { path: { id: project.id, deployId: deploymentId } },
-            }));
-            if (current.status === 'failed' ||
-                current.status === 'failed-to-start' ||
-                current.status === 'crashed') {
-                const failed = current.builds.find((build) => build.status === 'failed' ||
-                    build.status === 'failed-to-start' ||
-                    build.status === 'crashed') ?? current.builds[0];
+            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 {
-                    status: 'failed',
-                    deployment: deploymentId,
-                    failedBuild: failed?.id ?? '',
-                    failedService: failed?.service ?? 'A service',
-                    built: failed !== undefined && failed.status !== 'failed',
-                };
-            }
-            if (current.status === 'live') {
-                progress.stop();
-                const listening = current.builds.flatMap(({ service, listening: found }) => found === null ? [] : [{ service, ...found }]);
-                return { status: 'live', deployment: deploymentId, listening };
+                return outcome;
             }
             progress.update(current.status === 'queued' ? `${label} (queued)` : label);
-            if (Date.now() > deadline) {
-                progress.stop();
-                return { status: 'pending', deployment: deploymentId };
-            }
-            await new Promise((settle) => setTimeout(settle, POLL_INTERVAL_MS));
+            await clock.sleep(POLL_INTERVAL_MS);
         }
     }
     catch (error) {
@@ -45,31 +64,42 @@ export async function awaitDeployment(api, project, deploymentId, { format, labe
         throw error;
     }
 }
-export async function reportFailure(api, project, outcome, hint) {
-    const log = await dataOrThrow(api.GET('/api/projects/{id}/deployments/{deployId}/builds/{buildId}/logs', {
-        params: {
-            path: { id: project.id, deployId: outcome.deployment, buildId: outcome.failedBuild },
-        },
+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 tail = log
+    return log
         .split('\n')
         .filter((line) => line.trim() !== '')
-        .slice(-12)
+        .slice(-FAILURE_TAIL_LINES)
         .map((line) => color.dim(line));
-    const failureStage = outcome.built ? 'failed to start' : 'failed to build';
-    process.stdout.write(`${failure(`${outcome.failedService} ${failureStage}`)}\n${tail.join('\n')}\n\n` +
-        (hint === undefined ? '' : `${hint.join('\n')}\n\n`) +
-        `To read the whole log, run\ngrayspar logs --build --project ${project.name}\n`);
+}
+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 appliesOnNextDeploy(project) {
+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, { status: 'ok', deployment: null }, () => [
+        printResult(format, { deployment: null }, () => [
             ...receipts,
             ...(change.whenNothingIsLive === undefined ? [] : [change.whenNothingIsLive]),
         ].join('\n'));
@@ -80,20 +110,18 @@ export async function followRedeploy(api, project, deployment, format, change) {
         label: `Redeploying ${project.name}…`,
     });
     if (format === 'json') {
-        process.stdout.write(`${JSON.stringify(outcome, null, 2)}\n`);
-        if (outcome.status === 'failed')
+        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 reportFailure(api, project, outcome);
+        await printDeployFailure(api, project, outcome);
         return;
     }
-    if (outcome.status === 'pending') {
-        process.stdout.write(`Still redeploying. To follow it, run\ngrayspar status --project ${project.name}\n`);
+    if (outcome.status === 'cancelled') {
+        await printReplacedDeploy(project);
         return;
     }
-    const ports = portLines(outcome.listening);
-    process.stdout.write(`${[...receipts, receipt(`Redeployed ${project.name}`), ...ports.receipts].join('\n')}\n` +
-        (ports.warnings.length === 0 ? '' : `\n${ports.warnings.join('\n')}\n`));
+    process.stdout.write(`${[...receipts, receipt(`Redeployed ${project.name}`)].join('\n')}\n`);
 }

package/dist/lib/output.js

@@ -3,6 +3,7 @@
 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`);
@@ -25,12 +26,15 @@ export function exitWithError(format, error) {
         process.stdout.write(`${JSON.stringify({
             status: 'error',
             error: known?.code ?? 'unexpected',
-            message: error instanceof Error ? error.message : String(error),
+            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(error instanceof Error ? error.message : String(error))}\n`);
+        process.stderr.write(`${failure(known?.message ?? INTERNAL_FAILURE)}\n`);
     }
     process.exit(1);
 }

package/dist/lib/project-link.js

@@ -9,7 +9,7 @@ export async function findLink(startFolder) {
     for (;;) {
         const found = await readLinkAt(join(folder, LINK_FOLDER, LINK_FILE));
         if (found !== null)
-            return found;
+            return { ...found, folder };
         const parent = dirname(folder);
         if (parent === folder)
             return null;
@@ -23,10 +23,7 @@ export async function writeLink(folder, link) {
     await writeFile(join(linkFolder, '.gitignore'), '*\n');
 }
 export async function removeLink(folder) {
-    const linkFolder = join(folder, LINK_FOLDER);
-    const existed = (await readLinkAt(join(linkFolder, LINK_FILE))) !== null;
-    await rm(linkFolder, { recursive: true, force: true });
-    return existed;
+    await rm(join(folder, LINK_FOLDER), { recursive: true, force: true });
 }
 async function readLinkAt(path) {
     try {

package/dist/lib/prompt.js

@@ -4,19 +4,24 @@ import { createPrompt, isEnterKey, useEffect, useKeypress, useState } from '@inq
 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 Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    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);
 }
-async function cancellable(work, 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') {
-            throw new CliError('cancelled', 'Cancelled.', flag);
+            process.exit(CTRL_C_EXIT_CODE);
         }
         throw error;
     }
@@ -33,7 +38,7 @@ export async function askChoice(message, label, options, flag) {
             answer: (text) => text,
         },
     };
-    return cancellable(() => select({ message, choices, theme }), flag);
+    return exitOnCtrlC(() => select({ message, choices, theme }));
 }
 const textPrompt = createPrompt((config, done) => {
     const [answered, setAnswered] = useState(false);
@@ -58,8 +63,41 @@ const textPrompt = createPrompt((config, done) => {
     });
     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 cancellable(() => textPrompt({ label, suggestion }), flag);
+    return exitOnCtrlC(() => textPrompt({ label, suggestion }));
 }

package/dist/lib/resolve-project.js

@@ -13,13 +13,17 @@ export function projectIsNamed() {
 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/{id}', {
-            params: { path: { id: link.projectId } },
+        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');

package/dist/lib/resolve-team.js

@@ -14,7 +14,7 @@ export async function resolveTeam(api, options = {}) {
     if (namedTeam !== undefined) {
         const team = all.find((candidate) => candidate.slug === namedTeam);
         if (team === undefined) {
-            throw new CliError('no_such_team', `You are not in a team called ${namedTeam}.`, '--team');
+            throw new CliError('no_such_team', `You aren't in a team called ${namedTeam}.`, '--team');
         }
         return team;
     }