@grayspar/cli 0.0.2 → 0.0.4

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

package/dist/commands/login/login.js

@@ -41,10 +41,12 @@ async function login(options) {
                 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/sign-in-callback.js

@@ -1,23 +1,32 @@
 /* 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';
-// The terminal trades the code for its session after this page has gone out, so the page claims nothing about it.
-const SIGNED_IN_PAGE = `<!doctype html><meta charset="utf-8"><title>Grayspar CLI</title>
-<body style="font:16px/1.5 system-ui;margin:4rem auto;max-width:28rem;text-align:center">
-<h1 style="font-size:1.25rem">Back to your terminal</h1>
-<p>It finishes signing in there. You can close this window.</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));
@@ -29,6 +38,16 @@ export async function waitForSignInRedirect(timeoutMs) {
     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/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) {
@@ -78,12 +101,12 @@ export const logsCommand = new Command('logs')
     .description('show what a service printed while running, or with --build the last build log')
     .addOption(serviceOption('which service to read'))
     .option('--build', 'show the log from the last build instead')
-    .option('-f, --follow', 'keep printing new lines as they arrive')
+    .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/index.js

@@ -55,4 +55,10 @@ for (const command of [
     program.addCommand(command);
 }
 routeUsageErrors(program);
+// 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;
+});
 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

@@ -10,7 +10,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 +22,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/package.json

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