@grayspar/cli 0.0.1 → 0.0.3

package/dist/commands/deploy/submit-deploy.js

@@ -0,0 +1,127 @@
+import { dataOrThrow } from '../../lib/client.js';
+import { CliError } from '../../lib/errors.js';
+import { askChoice, askText, askYesNo, isInteractive } from '../../lib/prompt.js';
+import { failure } from '../../lib/ui.js';
+import { servicesToSend } from './deploy-flags.js';
+const PATH_POINTER_PATTERN = /^#\/services\/(\d+)\/pathPrefix$/;
+function askedIn(refusal, sent) {
+    if (refusal === undefined)
+        return null;
+    if (refusal.questions !== undefined)
+        return { asked: refusal.questions, detail: refusal.detail };
+    const paths = (refusal.errors ?? []).flatMap(({ detail, pointer }) => {
+        const index = PATH_POINTER_PATTERN.exec(pointer ?? '')?.[1];
+        const service = index === undefined ? undefined : sent[Number(index)]?.name;
+        return service === undefined ? [] : [{ service, suggestion: null, problem: detail }];
+    });
+    return paths.length === 0
+        ? null
+        : { asked: { address: [], paths, dockerfiles: [] }, detail: refusal.detail };
+}
+async function sendDeploy(api, destination, body) {
+    if (destination.kind === 'project') {
+        const answer = await api.POST('/api/projects/{projectId}/deployments', {
+            params: { path: { projectId: destination.project.id } },
+            body,
+        });
+        const asked = askedIn(answer.error, body.services ?? []);
+        if (asked !== null)
+            return asked;
+        const { deployment } = await dataOrThrow(Promise.resolve(answer));
+        return { accepted: { project: destination.project, deployment } };
+    }
+    const answer = await api.POST('/api/teams/{teamId}/projects', {
+        params: { path: { teamId: destination.team.id } },
+        body: { ...body, name: destination.name },
+    });
+    const asked = askedIn(answer.error, body.services ?? []);
+    if (asked !== null)
+        return asked;
+    return { accepted: await dataOrThrow(Promise.resolve(answer)) };
+}
+function dockerfileRefusal({ detail }, { dockerfile, service }) {
+    return new CliError('needs_an_answer', `${detail}\nAdd --dockerfile ${service}=${dockerfile} to build it, or --yes to leave it out.`, '--dockerfile');
+}
+function refusalFor({ asked, detail }, suggestionsTaken) {
+    const action = asked.address.length > 0
+        ? 'Choose it with --path <name>=/.'
+        : suggestionsTaken
+            ? 'Give the path with --path <name>=<path>, or --no-path <name> if it takes no requests.'
+            : 'Give each path with --path <name>=<path>, or --no-path <name> if it takes no requests, or take the suggested paths with --yes.';
+    return new CliError('needs_a_path', `${detail}\n${action}`, '--path');
+}
+function suggestionsFor(askedQuestions) {
+    const taken = new Map();
+    for (const { service, suggestion, problem } of askedQuestions.asked.paths) {
+        if (suggestion === null || problem !== null)
+            throw refusalFor(askedQuestions, true);
+        taken.set(service, suggestion);
+    }
+    if (askedQuestions.asked.address.length > 0)
+        throw refusalFor(askedQuestions, true);
+    return taken;
+}
+async function askFirstQuestion(asked, address) {
+    if (asked.address.length > 0) {
+        const root = await askChoice(`Select the service that opens at ${address}`, `Opens at ${address}`, asked.address.map((name) => ({ value: name, label: name })), '--path');
+        return [root, '/'];
+    }
+    const [question] = asked.paths;
+    if (question === undefined)
+        throw new Error('API asked a question without naming one');
+    if (question.problem !== null)
+        process.stdout.write(`${failure(question.problem)}\n`);
+    return [
+        question.service,
+        await askText(`Path for ${question.service}`, question.suggestion, '--path'),
+    ];
+}
+export async function submitDeploy(api, destination, options, serviceFlags, foundNames, request) {
+    const canAsk = isInteractive() && !options.yes;
+    const declinedDockerfiles = [];
+    let hasAsked = false;
+    for (;;) {
+        const sent = await sendDeploy(api, destination, {
+            ...request,
+            services: servicesToSend(foundNames, serviceFlags),
+            ...(declinedDockerfiles.length === 0 ? {} : { declinedDockerfiles }),
+        });
+        if ('accepted' in sent) {
+            if (hasAsked)
+                process.stdout.write('\n');
+            return sent.accepted;
+        }
+        const [dockerfile] = sent.asked.dockerfiles;
+        if (dockerfile !== undefined) {
+            if (options.yes) {
+                declinedDockerfiles.push(...sent.asked.dockerfiles.map((question) => question.dockerfile));
+                continue;
+            }
+            if (!canAsk)
+                throw dockerfileRefusal(sent, dockerfile);
+            const builds = await askYesNo(`Build ${dockerfile.dockerfile} from the project's root as the service ${dockerfile.service}?`, false, '--dockerfile');
+            hasAsked = true;
+            if (!builds) {
+                declinedDockerfiles.push(dockerfile.dockerfile);
+                continue;
+            }
+            serviceFlags.dockerfiles.set(dockerfile.service, dockerfile.dockerfile);
+            if (serviceFlags.onlyServices.length > 0)
+                serviceFlags.onlyServices.push(dockerfile.service);
+            continue;
+        }
+        if (!options.yes && !canAsk)
+            throw refusalFor(sent, false);
+        const given = options.yes
+            ? suggestionsFor(sent)
+            : new Map([await askFirstQuestion(sent.asked, addressOf(destination))]);
+        hasAsked ||= !options.yes;
+        for (const [name, path] of given)
+            serviceFlags.paths.set(name, path);
+    }
+}
+function addressOf(destination) {
+    return destination.kind === 'project'
+        ? new URL(destination.project.url).host
+        : "the project's address";
+}

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

@@ -1,11 +1,48 @@
-/* The saved variables are the source of truth, so a deploy adds what the project lacks and asks
-   before a local value replaces a saved one that differs; the server answers without the values. */
+/* The saved variables are the source of truth: a deploy adds what the project lacks once its names have been shown,
+   asks before a local value replaces a saved one, and keeps a value that points at this machine on it. */
+import { createHmac } from 'node:crypto';
 import { stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { dataOrThrow } from '../../lib/client.js';
 import { CliError } from '../../lib/errors.js';
-import { askChoice, isInteractive } from '../../lib/prompt.js';
-import { color } from '../../lib/ui.js';
+import { askChoice, askYesNo, isInteractive } from '../../lib/prompt.js';
+import { color, table, warning } from '../../lib/ui.js';
+const LOCAL_HOST_PATTERN = /(?:^|[^\w.-])(?:localhost|127\.0\.0\.1)(?![\w.-])/;
+export function pointsAtThisMachine(value) {
+    return LOCAL_HOST_PATTERN.test(value);
+}
+export function comparisonOf(saved, local) {
+    return Object.fromEntries(Object.entries(local).map(([service, values]) => [
+        service,
+        Object.fromEntries(Object.entries(values).map(([key, value]) => {
+            const entry = saved[service]?.find((variable) => variable.name === key);
+            if (entry === undefined)
+                return [key, { state: 'new', savedAt: null }];
+            const hash = createHmac('sha256', Buffer.from(entry.salt, 'base64url'))
+                .update(value)
+                .digest('hex');
+            return [
+                key,
+                { state: hash === entry.hash ? 'same' : 'different', savedAt: entry.updatedAt },
+            ];
+        })),
+    ]));
+}
+export function newVariablesOf(services, variables, comparison) {
+    return services.flatMap((service, index) => {
+        const found = variables[index];
+        if (found === undefined)
+            return [];
+        return Object.entries(found.values)
+            .filter(([key]) => (comparison[service]?.[key]?.state ?? 'new') === 'new')
+            .map(([key, value]) => ({
+            service,
+            key,
+            file: found.sourceFiles[key] ?? '.env',
+            leftOut: pointsAtThisMachine(value),
+        }));
+    });
+}
 export function sendableVariables(services, variables, comparison, fileWins) {
     return Object.fromEntries(services.map((service, index) => {
         const values = variables[index]?.values ?? {};
@@ -35,17 +72,51 @@ async function editedAt(root, file) {
         return null;
     return stat(join(root, file)).then((found) => found.mtime, () => null);
 }
-export async function variablesToSend(api, project, root, services, variables, preference) {
+function leftOutWarning({ service, key, file }) {
+    return warning(`${key} in ${file} points at localhost, so it was left out. Set it with grayspar env set ${key}=… --service ${service}`);
+}
+async function confirmNewVariables(sendable, fresh, { projectName, format, yes }) {
+    const leftOut = fresh.filter((variable) => variable.leftOut);
+    const offered = fresh.filter((variable) => !variable.leftOut);
+    const dropped = (names) => {
+        for (const { service, key } of names)
+            delete sendable[service]?.[key];
+    };
+    dropped(leftOut);
+    const warnings = leftOut.map(leftOutWarning);
+    if (offered.length > 0 && !yes) {
+        const one = offered.length === 1;
+        const many = one ? 'variable' : 'variables';
+        if (format !== 'text' || !isInteractive()) {
+            const them = one ? 'it' : 'them';
+            throw new CliError('needs_an_answer', `${offered.length} ${many} in .env files ${one ? 'is' : 'are'} new to ${projectName}, and there is no terminal to ask whether to send ${them}.\nSend ${them} with --yes, or deploy without .env files with --no-env.`, '--yes');
+        }
+        process.stdout.write(`${color.heading(`Found ${offered.length} new ${many}`)}\n\n` +
+            `${table(['SERVICE', 'VARIABLE', 'FILE'], offered.map(({ service, key, file }) => [service, key, file]))}\n` +
+            (warnings.length === 0 ? '' : `\n${warnings.join('\n')}\n`) +
+            '\n');
+        const send = await askYesNo(`Send ${offered.length} ${many} to ${projectName}?`, true, '--yes');
+        process.stdout.write('\n');
+        if (!send)
+            dropped(offered);
+    }
+    else if (warnings.length > 0 && format === 'text') {
+        process.stdout.write(`${warnings.join('\n')}\n\n`);
+    }
+    return { variables: sendable, leftOut };
+}
+export async function variablesToSend(api, project, root, services, variables, envConflict, asking) {
     const local = Object.fromEntries(services.map((service, index) => [service, variables[index]?.values ?? {}]));
-    const comparison = await dataOrThrow(api.POST('/api/projects/{id}/env/compare', {
-        params: { path: { id: project.id } },
-        body: { services: local },
-    }));
+    const saved = project === null
+        ? {}
+        : await dataOrThrow(api.GET('/api/projects/{projectId}/env', { params: { path: { projectId: project.id } } }));
+    const comparison = comparisonOf(saved, local);
+    const fresh = newVariablesOf(services, variables, comparison);
     const conflicts = services.flatMap((service) => Object.entries(comparison[service] ?? {})
         .filter(([, entry]) => entry.state === 'different')
         .map(([key]) => ({ service, key })));
-    if (conflicts.length === 0 || preference !== undefined) {
-        return sendableVariables(services, variables, comparison, () => preference === 'file');
+    if (conflicts.length === 0 || envConflict !== undefined) {
+        return confirmNewVariables(sendableVariables(services, variables, comparison, () => envConflict === 'file'), fresh, asking);
     }
     const names = conflicts.map(({ service, key }) => `${key} on ${service}`).join(', ');
     if (!isInteractive()) {
@@ -65,5 +136,5 @@ export async function variablesToSend(api, project, root, services, variables, p
         ], '--env-conflict');
         fileWinsByConflict.set(`${service} ${key}`, pick === 'file');
     }
-    return sendableVariables(services, variables, comparison, ({ service, key }) => fileWinsByConflict.get(`${service} ${key}`) === true);
+    return confirmNewVariables(sendableVariables(services, variables, comparison, ({ service, key }) => fileWinsByConflict.get(`${service} ${key}`) === true), fresh, asking);
 }

package/dist/commands/env.js

@@ -4,19 +4,20 @@ 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 } from '../lib/follow-deployment.js';
 import { printResult } from '../lib/output.js';
 import { resolveService, resolveServices } from '../lib/resolve-service.js';
 import { tableOrEmptyNote } from '../lib/ui.js';
-async function saveVariables(api, project, service, change, format, receipt) {
-    const saved = await dataOrThrow(api.PUT('/api/projects/{id}/services/{serviceId}/env', {
-        params: { path: { id: project.id, serviceId: service.id } },
+async function saveVariables(api, project, service, change, format, receipts) {
+    const saved = await dataOrThrow(api.PATCH('/api/projects/{projectId}/services/{serviceId}/env', {
+        params: { path: { projectId: project.id, serviceId: service.id } },
         body: change,
     }));
-    await followRedeploy(api, project, saved.deployment, format, {
-        receipts: [receipt],
-        whenNothingIsLive: appliesOnNextDeploy(project),
-    });
+    if (saved.deployment === null) {
+        printResult(format, { deployment: null }, () => `Nothing changed on ${service.name}.`);
+        return;
+    }
+    await followRedeploy(api, project, saved.deployment, format, { receipts });
 }
 async function setVariables(pairs, serviceName, format) {
     const api = await signedInClient();
@@ -29,15 +30,15 @@ async function setVariables(pairs, serviceName, format) {
         }
         variables[pair.slice(0, equals)] = pair.slice(equals + 1);
     }
-    await saveVariables(api, project, service, { variables }, format, `Set ${Object.keys(variables).join(', ')} on ${service.name}`);
+    await saveVariables(api, project, service, { variables }, format, Object.keys(variables).map((key) => `Set variable ${key} on ${service.name}`));
 }
 async function listVariables(serviceName, format) {
     const api = await signedInClient();
     const { project, services } = await resolveServices(api, serviceName);
     const listed = await Promise.all(services.map(async (service) => ({
         service: service.name,
-        variables: await dataOrThrow(api.GET('/api/projects/{id}/services/{serviceId}/env', {
-            params: { path: { id: project.id, serviceId: service.id } },
+        variables: await dataOrThrow(api.GET('/api/projects/{projectId}/services/{serviceId}/env', {
+            params: { path: { projectId: project.id, serviceId: service.id } },
         })),
     })));
     printResult(format, listed, () => {
@@ -48,7 +49,7 @@ async function listVariables(serviceName, format) {
 async function removeVariables(keys, serviceName, format) {
     const api = await signedInClient();
     const { project, service } = await resolveService(api, serviceName);
-    await saveVariables(api, project, service, { remove: keys }, format, `Removed ${keys.join(', ')} from ${service.name}`);
+    await saveVariables(api, project, service, { remove: keys }, format, keys.map((key) => `Removed variable ${key} from ${service.name}`));
 }
 export const envCommand = new Command('env').description("set a project's environment variables");
 envCommand

package/dist/commands/link.js

@@ -3,7 +3,7 @@ import { signedInClient } from '../lib/client.js';
 import { commandAction } from '../lib/command-helpers.js';
 import { CliError } from '../lib/errors.js';
 import { printResult } from '../lib/output.js';
-import { removeLink, writeLink } from '../lib/project-link.js';
+import { findLink, removeLink, writeLink } from '../lib/project-link.js';
 import { resolveProject } from '../lib/resolve-project.js';
 import { receipt } from '../lib/ui.js';
 async function link(format) {
@@ -13,11 +13,12 @@ async function link(format) {
     printResult(format, { status: 'ok', project: project.name }, () => receipt(`Linked this folder to ${project.name}`));
 }
 async function unlink(format) {
-    const existed = await removeLink(process.cwd());
-    if (!existed) {
-        throw new CliError('not_linked', 'This folder is not linked to a project.');
+    const found = await findLink(process.cwd());
+    if (found === null) {
+        throw new CliError('not_linked', "This folder isn't linked to a project.");
     }
-    printResult(format, { status: 'ok' }, () => receipt('Unlinked this folder'));
+    await removeLink(found.folder);
+    printResult(format, { status: 'ok' }, () => receipt(`Unlinked ${found.folder}`));
 }
 export const linkCommand = new Command('link')
     .description('bind this folder to a project')

package/dist/commands/login/login.js

@@ -1,10 +1,11 @@
 import { randomBytes } from 'node:crypto';
+import { hostname } from 'node:os';
 import { Command } from 'commander';
-import { DEFAULT_API_URL, publicClient } from '../../lib/client.js';
+import { DEFAULT_API_URL, endSavedSession, 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 { printResult, startProgress } from '../../lib/output.js';
 import { color, receipt } from '../../lib/ui.js';
 import { challengeFor } from './challenge.js';
 import { openBrowser } from './open-browser.js';
@@ -14,10 +15,10 @@ 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);
+    const url = new URL('/cli', apiUrl);
     url.searchParams.set('port', String(listener.port));
     url.searchParams.set('challenge', challengeFor(verifier));
-    printText(options.format, `${color.heading('Grayspar login')}\n${url.toString()}`);
+    process.stderr.write(`${options.format === 'text' ? `${color.heading('Grayspar login')}\n` : ''}${url.toString()}\n`);
     try {
         if (options.browser)
             openBrowser(url.toString());
@@ -28,20 +29,24 @@ async function login(options) {
                 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 },
+                body: { code, verifier, deviceName: hostname() },
             });
             if (session === undefined) {
-                throw new CliError('sign_in_refused', 'That sign-in did not complete. Try again.');
+                throw new CliError('sign_in_refused', "That sign-in didn't complete. Try again.");
             }
+            // The session these credentials replace would otherwise stay valid for months with nothing holding it.
+            await endSavedSession();
             await writeCredentials({
                 apiUrl,
                 token: session.token,
                 email: session.email,
             });
+            await listener.answerBrowser(true);
             progress.stop();
             printResult(options.format, { status: 'ok', email: session.email }, () => receipt(`Signed in as ${session.email}`));
         }
         catch (error) {
+            await listener.answerBrowser(false);
             progress.stop();
             throw error;
         }

package/dist/commands/login/open-browser.js

@@ -1,5 +1,5 @@
-/* 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. */
+/* Best effort: a machine with no browser prints the address instead, to open on the same machine. 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]],

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

@@ -1,33 +1,53 @@
 /* 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. */
+   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. */
 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>`;
+function browserPage(mark, markColor, title, detail) {
+    return `<!doctype html><meta charset="utf-8"><meta name="color-scheme" content="light dark">
+<title>Grayspar CLI</title>
+<style>body{font:16px/1.5 system-ui;margin:0;min-height:100svh;display:grid;place-content:center;text-align:center;background:light-dark(#fff,#0f1010);color:light-dark(#111,#eee)}
+svg{display:block;width:48px;height:48px;margin:0 auto;color:${markColor}}h1{font-size:1.25rem;font-weight:600;margin:1rem 0 .25rem}p{margin:0;opacity:.7}</style>
+<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><circle cx="12" cy="12" r="10"/><path d="${mark}"/></svg>
+<h1>${title}</h1><p>${detail}</p>`;
+}
+const SIGNED_IN_PAGE = browserPage('m8 12 3 3 5-6', '#2f9e5b', 'Signed in successfully', 'You can close this window.');
+const NOT_SIGNED_IN_PAGE = browserPage('m9 9 6 6m0-6-6 6', '#d9534f', "The sign-in didn't complete", 'Run grayspar login again.');
 export async function waitForSignInRedirect(timeoutMs) {
     let settle = () => undefined;
     const waitForCode = new Promise((resolve) => {
         settle = resolve;
     });
+    let browser = null;
+    let redirected = false;
     const server = createServer((request, response) => {
         const url = new URL(request.url ?? '/', 'http://127.0.0.1');
-        if (url.pathname !== '/callback') {
+        if (url.pathname !== '/callback' || redirected) {
             response.writeHead(404).end();
             return;
         }
-        response.writeHead(200, { 'content-type': 'text/html; charset=utf-8' }).end(SIGNED_IN_PAGE);
+        redirected = true;
+        browser = response;
         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.');
+        throw new Error('sign-in listener did not get a port');
     }
     return {
         port: address.port,
         waitForCode,
+        answerBrowser: (signedIn) => new Promise((answered) => {
+            if (browser === null) {
+                answered();
+                return;
+            }
+            browser
+                .writeHead(signedIn ? 200 : 400, { 'content-type': 'text/html; charset=utf-8' })
+                .end(signedIn ? SIGNED_IN_PAGE : NOT_SIGNED_IN_PAGE, () => answered());
+            browser = null;
+        }),
         close: () => {
             clearTimeout(timer);
             server.close();

package/dist/commands/logout.js

@@ -1,29 +1,17 @@
 /* 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. */
+   forgotten here all the same, and the person is told how to end it from the dashboard. */
 import { Command } from 'commander';
-import { signedInClient } from '../lib/client.js';
+import { endSavedSession } from '../lib/client.js';
 import { commandAction } from '../lib/command-helpers.js';
-import { clearCredentials, readCredentials } from '../lib/credentials.js';
+import { clearCredentials } 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();
+    const ended = await endSavedSession();
     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.')}`);
+        : `${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')

package/dist/commands/logs.js

@@ -7,6 +7,7 @@ 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 { retryTransient } from '../lib/retry-transient.js';
 import { color } from '../lib/ui.js';
 const FOLLOW_INTERVAL_MS = 2_000;
 async function logs(options, format) {
@@ -14,27 +15,25 @@ async function logs(options, format) {
     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', {
+    const readLogs = (after, signal) => dataOrThrow(api.GET('/api/projects/{projectId}/services/{serviceId}/logs', {
         params: {
-            path: { id: project.id, serviceId: service.id },
+            path: { projectId: project.id, serviceId: service.id },
             query: after === undefined ? {} : { after },
         },
+        signal,
     }));
     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);
+    if (!options.follow && format === 'text' && first.lines.length === 0) {
+        process.stdout.write(`${service.name} has printed nothing yet.\n`);
         return;
     }
     printLogLines(first.lines, format);
+    if (!options.follow)
+        return;
     let after = first.lines.at(-1)?.id;
     for (;;) {
         await pause(FOLLOW_INTERVAL_MS);
-        const next = await readLogs(after);
+        const next = await retryTransient((signal) => readLogs(after, signal));
         printLogLines(next.lines, format);
         after = next.lines.at(-1)?.id ?? after;
     }
@@ -48,21 +47,27 @@ function printLogLines(lines, format) {
 }
 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 { deployments } = await dataOrThrow(api.GET('/api/projects/{projectId}/deployments', {
+        params: { path: { projectId: project.id } },
+    }));
     const latest = deployments[0];
     if (latest === undefined) {
-        throw new CliError('never_deployed', `${project.name} has not been deployed yet.`);
+        throw new CliError('never_deployed', `${project.name} hasn't 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 } },
+    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',
         })),
     })));
     if (format === 'json') {
-        process.stdout.write(`${JSON.stringify({ deployment: latest.id, builds }, null, 2)}\n`);
+        for (const { service, log } of builds) {
+            for (const text of log.split('\n').filter((line) => line !== '')) {
+                process.stdout.write(`${JSON.stringify({ service, text })}\n`);
+            }
+        }
         return;
     }
     for (const build of builds) {

package/dist/commands/open-path.js

@@ -14,8 +14,8 @@ async function listOpenPaths(format) {
 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 } },
+    await dataOrThrow(api.POST('/api/projects/{projectId}/open-paths', {
+        params: { path: { projectId: project.id } },
         body: { path },
     }));
     printResult(format, { status: 'ok', path }, () => `${receipt(`Added open path ${path} to ${project.name}`)}\nAnyone can reach it without signing in.`);
@@ -23,8 +23,8 @@ async function addOpenPath(path, format) {
 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 } },
+    await dataOrThrow(api.DELETE('/api/projects/{projectId}/open-paths', {
+        params: { path: { projectId: project.id }, query: { path } },
     }));
     printResult(format, { status: 'ok', path }, () => receipt(`Removed open path ${path} from ${project.name}`));
 }

package/dist/commands/restart.js

@@ -1,19 +1,21 @@
-/* A restart runs the same container again in place, so the service keeps its volumes and its address,
+/* A restart runs the same container again in place, so the service keeps its volume 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 { commandFor } from '../lib/resolve-project.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 } },
+    await dataOrThrow(api.POST('/api/projects/{projectId}/services/{serviceId}/restart', {
+        params: { path: { projectId: 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}`);
+    const follow = await commandFor(project, 'grayspar status');
+    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 volumes')
+    .description('run a service again in place, keeping its volume')
     .addOption(serviceOption('which service to restart'))
     .action(commandAction((format, command) => restart(serviceNameOf(command), format)));