@grayspar/cli 0.0.0-stage → 0.0.1

package/dist/lib/credentials.js

@@ -0,0 +1,38 @@
+/* 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 { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+export function credentialsPath() {
+    const base = process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config');
+    return join(base, 'grayspar', 'credentials.json');
+}
+export async function readCredentials() {
+    try {
+        const raw = await readFile(credentialsPath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        return isCredentials(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+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);
+}
+export async function clearCredentials() {
+    await rm(credentialsPath(), { force: true });
+}
+function isCredentials(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'token' in value &&
+        typeof value.token === 'string' &&
+        'apiUrl' in value &&
+        typeof value.apiUrl === 'string' &&
+        'email' in value &&
+        typeof value.email === 'string');
+}

package/dist/lib/errors.js

@@ -0,0 +1,12 @@
+/* Every refusal names the flag that would have answered it, so an agent reading the JSON knows what
+   to add rather than guessing at the shape of the thing that was missing. */
+export class CliError extends Error {
+    code;
+    supplyWith;
+    constructor(code, message, supplyWith) {
+        super(message);
+        this.name = 'CliError';
+        this.code = code;
+        this.supplyWith = supplyWith;
+    }
+}

package/dist/lib/follow-deployment.js

@@ -0,0 +1,99 @@
+import { dataOrThrow } from './client.js';
+import { portLines } from './listening.js';
+import { printResult, startProgress } from './output.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 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];
+                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 };
+            }
+            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));
+        }
+    }
+    catch (error) {
+        progress.stop();
+        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 },
+        },
+        parseAs: 'text',
+    }));
+    const tail = log
+        .split('\n')
+        .filter((line) => line.trim() !== '')
+        .slice(-12)
+        .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`);
+    process.exitCode = 1;
+}
+export function appliesOnNextDeploy(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 }, () => [
+            ...receipts,
+            ...(change.whenNothingIsLive === undefined ? [] : [change.whenNothingIsLive]),
+        ].join('\n'));
+        return;
+    }
+    const outcome = await awaitDeployment(api, project, deployment.id, {
+        format,
+        label: `Redeploying ${project.name}…`,
+    });
+    if (format === 'json') {
+        process.stdout.write(`${JSON.stringify(outcome, null, 2)}\n`);
+        if (outcome.status === 'failed')
+            process.exitCode = 1;
+        return;
+    }
+    if (outcome.status === 'failed') {
+        await reportFailure(api, project, outcome);
+        return;
+    }
+    if (outcome.status === 'pending') {
+        process.stdout.write(`Still redeploying. To follow it, run\ngrayspar status --project ${project.name}\n`);
+        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`));
+}

package/dist/lib/listening.js

@@ -0,0 +1,24 @@
+import { receipt, warning } from './ui.js';
+function advice(found) {
+    switch (found.kind) {
+        case 'several':
+            return `listens on ports ${found.ports.join(' and ')}. Choose one with grayspar service set ${found.service} --port …`;
+        case 'localhost':
+            return 'listens only on localhost, where no request reaches it. Listen on 0.0.0.0';
+        case 'none':
+            return 'has not opened a port, so no request reaches it. Listen on $PORT';
+    }
+}
+export function portLines(listening) {
+    const receipts = [];
+    const warnings = [];
+    for (const found of listening) {
+        if (found.kind === 'adopted') {
+            receipts.push(receipt(`Set port of ${found.service} to ${found.port}, the port it listens on`));
+        }
+        else {
+            warnings.push(warning(`${found.service} ${advice(found)}`));
+        }
+    }
+    return { receipts, warnings };
+}

package/dist/lib/output.js

@@ -0,0 +1,36 @@
+/* Results go to standard output and diagnostics to standard error, so `--json` output stays machine
+   readable even while something is being explained to the person watching. */
+import { CliError } from './errors.js';
+import { isInteractive } from './prompt.js';
+import { failure, spinner } from './ui.js';
+export function printText(format, text) {
+    if (format === 'text')
+        process.stdout.write(`${text}\n`);
+}
+export function printResult(format, value, text) {
+    process.stdout.write(format === 'json' ? `${JSON.stringify(value, null, 2)}\n` : `${text()}\n`);
+}
+export function printNote(format, text) {
+    if (format === 'text')
+        process.stderr.write(`${text}\n`);
+}
+export function startProgress(format, text) {
+    return format === 'text' && isInteractive()
+        ? spinner(text)
+        : { update: () => undefined, stop: () => undefined };
+}
+export function exitWithError(format, error) {
+    const known = error instanceof CliError ? error : null;
+    if (format === 'json') {
+        process.stdout.write(`${JSON.stringify({
+            status: 'error',
+            error: known?.code ?? 'unexpected',
+            message: 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.exit(1);
+}

package/dist/lib/project-link.js

@@ -0,0 +1,45 @@
+/* The link binds a folder to a project by id, so renaming the folder never retargets a deploy. It
+   lives in .grayspar and ignores itself, so it stays out of the user's commits. */
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+const LINK_FOLDER = '.grayspar';
+const LINK_FILE = 'project.json';
+export async function findLink(startFolder) {
+    let folder = resolve(startFolder);
+    for (;;) {
+        const found = await readLinkAt(join(folder, LINK_FOLDER, LINK_FILE));
+        if (found !== null)
+            return found;
+        const parent = dirname(folder);
+        if (parent === folder)
+            return null;
+        folder = parent;
+    }
+}
+export async function writeLink(folder, link) {
+    const linkFolder = join(folder, LINK_FOLDER);
+    await mkdir(linkFolder, { recursive: true });
+    await writeFile(join(linkFolder, LINK_FILE), `${JSON.stringify(link, null, 2)}\n`);
+    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;
+}
+async function readLinkAt(path) {
+    try {
+        const parsed = JSON.parse(await readFile(path, 'utf8'));
+        return isLink(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isLink(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'projectId' in value &&
+        typeof value.projectId === 'string');
+}

package/dist/lib/prompt.js

@@ -0,0 +1,65 @@
+/* Without a terminal there is nobody to answer, so a question becomes an error naming the flag that would have carried
+   the answer. A typed question arrives with its suggestion on the line as the answer, and settles into `Label: answer`. */
+import { createPrompt, isEnterKey, useEffect, useKeypress, useState } from '@inquirer/core';
+import select from '@inquirer/select';
+import { CliError } from './errors.js';
+import { color } from './ui.js';
+export function isInteractive() {
+    return 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) {
+    try {
+        return await work();
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'ExitPromptError') {
+            throw new CliError('cancelled', 'Cancelled.', flag);
+        }
+        throw error;
+    }
+}
+export async function askChoice(message, label, options, flag) {
+    if (!isInteractive())
+        refuseWithoutTerminal(message, flag);
+    const choices = options.map((option) => ({ name: option.label, value: option.value }));
+    const theme = {
+        prefix: '',
+        icon: { cursor: '>' },
+        style: {
+            message: (text, status) => status === 'done' ? `${label}:` : color.heading(`${text}:`),
+            answer: (text) => text,
+        },
+    };
+    return cancellable(() => select({ message, choices, theme }), flag);
+}
+const textPrompt = createPrompt((config, done) => {
+    const [answered, setAnswered] = useState(false);
+    const [value, setValue] = useState(config.suggestion ?? '');
+    useEffect((rl) => {
+        if (config.suggestion !== null)
+            rl.write(config.suggestion);
+    }, [config.suggestion]);
+    useKeypress((key, rl) => {
+        if (answered)
+            return;
+        if (!isEnterKey(key)) {
+            setValue(rl.line);
+            return;
+        }
+        const answer = value.trim();
+        setValue(answer);
+        if (answer === '')
+            return;
+        setAnswered(true);
+        done(answer);
+    });
+    return answered ? `${config.label}: ${value}` : `${color.heading(`${config.label}:`)} ${value}`;
+});
+export async function askText(label, suggestion, flag) {
+    if (!isInteractive())
+        refuseWithoutTerminal(label, flag);
+    return cancellable(() => textPrompt({ label, suggestion }), flag);
+}

package/dist/lib/resolve-project.js

@@ -0,0 +1,56 @@
+import { dataOrThrow } from './client.js';
+import { CliError } from './errors.js';
+import { findLink } from './project-link.js';
+import { askChoice } from './prompt.js';
+import { resolveTeam, teamIsNamed } from './resolve-team.js';
+let namedProject;
+export function setNamedProject(slug) {
+    namedProject = slug;
+}
+export function projectIsNamed() {
+    return namedProject !== undefined;
+}
+export function teamProjects(api, teamId) {
+    return dataOrThrow(api.GET('/api/teams/{teamId}/projects', { params: { path: { teamId } } }));
+}
+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 } },
+        });
+        if (answer.response.status === 404) {
+            throw new CliError('link_outdated', 'The project this folder is linked to no longer exists. Run grayspar link.', '--project');
+        }
+        return dataOrThrow(Promise.resolve(answer));
+    }
+    return selectProject(api, await resolveTeam(api));
+}
+async function selectProject(api, team) {
+    const projects = await teamProjects(api, team.id);
+    const [first] = projects;
+    if (first === undefined) {
+        throw new CliError('no_projects', `${team.name} has no projects yet. Deploy one first.`);
+    }
+    const id = await askChoice('Select a project', 'Project', projects.map((project) => ({ value: project.id, label: project.name })), '--project');
+    return projects.find((project) => project.id === id) ?? first;
+}
+async function projectNamed(api, given) {
+    const teams = teamIsNamed() ? [await resolveTeam(api)] : await dataOrThrow(api.GET('/api/teams'));
+    const matches = [];
+    for (const team of teams) {
+        const project = (await teamProjects(api, team.id)).find((candidate) => candidate.name === given);
+        if (project !== undefined)
+            matches.push({ team, project });
+    }
+    const [only] = matches;
+    if (only === undefined) {
+        throw new CliError('no_such_project', `You have no project called ${given}.\nRun grayspar project to see your projects.`, '--project');
+    }
+    if (matches.length === 1)
+        return only.project;
+    const team = await resolveTeam(api, { among: matches.map((match) => match.team) });
+    return matches.find((match) => match.team.id === team.id)?.project ?? only.project;
+}

package/dist/lib/resolve-service.js

@@ -0,0 +1,29 @@
+import { CliError } from './errors.js';
+import { askChoice } from './prompt.js';
+import { resolveProject } from './resolve-project.js';
+export async function resolveService(api, serviceName, answeredBy = '--service') {
+    const project = await resolveProject(api);
+    const [first] = project.services;
+    if (first === undefined) {
+        throw new CliError('never_deployed', `${project.name} has no services yet. Deploy it first.`);
+    }
+    if (serviceName !== undefined) {
+        const service = project.services.find((candidate) => candidate.name === serviceName);
+        if (service === undefined) {
+            throw new CliError('no_such_service', `${project.name} has no service called ${serviceName}.\nRun grayspar status to see its services.`, answeredBy);
+        }
+        return { project, service };
+    }
+    if (project.services.length === 1)
+        return { project, service: first };
+    const id = await askChoice('Select a service', 'Service', project.services.map((service) => ({ value: service.id, label: service.name })), answeredBy);
+    return { project, service: project.services.find((service) => service.id === id) ?? first };
+}
+export async function resolveServices(api, serviceName) {
+    if (serviceName === undefined) {
+        const project = await resolveProject(api);
+        return { project, services: project.services };
+    }
+    const { project, service } = await resolveService(api, serviceName);
+    return { project, services: [service] };
+}

package/dist/lib/resolve-team.js

@@ -0,0 +1,31 @@
+import { dataOrThrow } from './client.js';
+import { CliError } from './errors.js';
+import { askChoice } from './prompt.js';
+let namedTeam;
+export function setNamedTeam(slug) {
+    namedTeam = slug;
+}
+export function teamIsNamed() {
+    return namedTeam !== undefined;
+}
+export async function resolveTeam(api, options = {}) {
+    const all = options.among ?? (await dataOrThrow(api.GET('/api/teams')));
+    const teams = options.deploying === true ? all.filter((team) => team.can.deploy) : all;
+    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');
+        }
+        return team;
+    }
+    const [first] = teams;
+    if (first === undefined) {
+        throw all.length === 0
+            ? new CliError('no_team', 'This account belongs to no team.')
+            : new CliError('view_only', 'You can only view the projects in your teams, so none can take a deploy.');
+    }
+    if (teams.length === 1 || options.takeDefault === true)
+        return first;
+    const id = await askChoice('Select a team', 'Team', teams.map((team) => ({ value: team.id, label: team.name })), '--team');
+    return teams.find((team) => team.id === id) ?? first;
+}

package/dist/lib/services-table.js

@@ -0,0 +1,28 @@
+import { color, table } from './ui.js';
+const untinted = (text) => text;
+const RUNTIME_STATUS = {
+    deploying: { label: 'Deploying', tint: untinted },
+    running: { label: 'Running', tint: color.ok },
+    restarting: { label: 'Restarting', tint: untinted },
+    crashed: { label: 'Crashed', tint: color.bad },
+    failed: { label: 'Failed', tint: color.bad },
+};
+export function servicesTable(project) {
+    const rows = project.services.map((service) => [
+        service.name,
+        service.pathPrefix === null
+            ? 'internal'
+            : service.pathPrefix === '/'
+                ? project.url
+                : `${project.url}${service.pathPrefix}`,
+        RUNTIME_STATUS[service.runtime].label,
+    ]);
+    return table(['SERVICE', 'URL', 'STATUS'], rows, (cell, column, row) => {
+        const service = project.services[row];
+        if (column === 1 && service?.pathPrefix !== null)
+            return color.link(cell);
+        if (column === 2 && service !== undefined)
+            return RUNTIME_STATUS[service.runtime].tint(cell);
+        return cell;
+    });
+}

package/dist/lib/ui.js

@@ -0,0 +1,58 @@
+/* One place owns how text output looks: every line starts at column 0, a result leads with ✓, ! or ✗ and still
+   reads without it, grey is kept for what sits beside an answer, and colour never reaches the JSON path or a pipe. */
+import pc from 'picocolors';
+export const color = {
+    heading: (text) => pc.bold(text),
+    dim: (text) => pc.dim(text),
+    ok: (text) => pc.green(text),
+    bad: (text) => pc.red(text),
+    link: (text) => pc.cyan(text),
+};
+export function receipt(message) {
+    return `${pc.green('✓')} ${message}`;
+}
+export function warning(message) {
+    return `${pc.yellow('!')} ${message}`;
+}
+export function failure(message) {
+    return `${pc.red('✗')} ${message}`;
+}
+export function table(header, rows, style = (cell) => cell) {
+    const widths = [];
+    for (const row of [header, ...rows]) {
+        row.forEach((cell, column) => {
+            widths[column] = Math.max(widths[column] ?? 0, cell.length);
+        });
+    }
+    const line = (cells, row) => cells
+        .map((cell, column) => {
+        const padded = column === cells.length - 1 ? cell : cell.padEnd(widths[column] ?? 0);
+        return row === null ? padded : style(padded, column, row);
+    })
+        .join('    ');
+    return [line(header, null), ...rows.map(line)].join('\n');
+}
+export function tableOrEmptyNote(header, rows, whenEmpty, style) {
+    return rows.length === 0 ? whenEmpty : table(header, rows, style);
+}
+const SPINNER_FRAMES = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏';
+const CLEAR_LINE = '\r\x1b[2K';
+export function spinner(text) {
+    let shown = text;
+    let frame = 0;
+    const draw = () => {
+        process.stderr.write(`${CLEAR_LINE}${pc.cyan(SPINNER_FRAMES.charAt(frame % SPINNER_FRAMES.length))} ${shown}`);
+        frame += 1;
+    };
+    draw();
+    const timer = setInterval(draw, 80);
+    return {
+        update: (next) => {
+            shown = next;
+        },
+        stop: () => {
+            clearInterval(timer);
+            process.stderr.write(CLEAR_LINE);
+        },
+    };
+}

package/dist/lib/version.js

@@ -0,0 +1,12 @@
+import { readFileSync } from 'node:fs';
+function readVersion() {
+    const manifest = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+    if (typeof manifest === 'object' &&
+        manifest !== null &&
+        'version' in manifest &&
+        typeof manifest.version === 'string') {
+        return manifest.version;
+    }
+    throw new Error('The CLI\u2019s package.json has no version.');
+}
+export const cliVersion = readVersion();

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "@grayspar/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.1",
+  "description": "The cloud for small software. Deploy your applications with one command, and share them with exactly the people you choose.",
+  "keywords": [
+    "grayspar",
+    "deploy",
+    "hosting",
+    "cloud",
+    "cli",
+    "private",
+    "sharing",
+    "access control"
+  ],
+  "homepage": "https://grayspar.com",
+  "bugs": {
+    "email": "support@grayspar.com"
+  },
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "grayspar": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@inquirer/core": "10.3.2",
+    "@inquirer/select": "4.4.2",
+    "commander": "14.0.2",
+    "ignore": "7.0.10",
+    "openapi-fetch": "0.17.0",
+    "picocolors": "1.1.1",
+    "tar": "7.5.22"
+  },
+  "devDependencies": {
+    "@grayspar/api-types": "0.0.0"
+  },
+  "scripts": {
+    "prebuild": "pnpm --filter @grayspar/api generate",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit"
+  }
 }