@grayspar/cli 0.0.0-stage → 0.0.2

package/dist/lib/retry-transient.js

@@ -0,0 +1,32 @@
+/* A request that never arrived or failed without Grayspar's own answer is tried again with a growing, jittered wait,
+   for as long as failures follow one another without a break, then the last failure is let through. The two minutes
+   count from the start of the first failing attempt, and each later attempt is cut off when they are up. */
+import { setTimeout as pause } from 'node:timers/promises';
+import { CliError } from './errors.js';
+const FIRST_DELAY_MS = 1000;
+const LONGEST_DELAY_MS = 15_000;
+const GIVE_UP_AFTER_MS = 2 * 60 * 1000;
+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) {
+    let failingSince = null;
+    for (let attempt = 0;; attempt += 1) {
+        const started = clock.now();
+        try {
+            return await work(failingSince === null
+                ? undefined
+                : AbortSignal.timeout(Math.max(1, Math.round(failingSince + GIVE_UP_AFTER_MS - started))));
+        }
+        catch (error) {
+            if (!isTransient(error))
+                throw error;
+            failingSince ??= started;
+            if (clock.now() - failingSince >= GIVE_UP_AFTER_MS)
+                throw error;
+            const delay = Math.min(LONGEST_DELAY_MS, FIRST_DELAY_MS * 2 ** attempt);
+            await clock.sleep(delay * (0.5 + Math.random() / 2));
+        }
+    }
+}

package/dist/lib/services-table.js

@@ -0,0 +1,29 @@
+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 },
+    unknown: { label: 'Unknown', tint: untinted },
+    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/usage-errors.js

@@ -0,0 +1,43 @@
+import { CliError } from './errors.js';
+import { exitWithError } from './output.js';
+const HELP_LINE = 'Run it with --help to see what it takes.';
+const FLAG_NAME_PATTERN = /^--[\w-]+/;
+function match(error, pattern) {
+    return pattern.exec(error.message);
+}
+export function usageErrorFor(error) {
+    const flag = match(error, /option '([^']+)'/)?.[1];
+    const flagName = flag === undefined ? undefined : FLAG_NAME_PATTERN.exec(flag)?.[0];
+    switch (error.code) {
+        case 'commander.missingMandatoryOptionValue':
+            return new CliError('bad_usage', `This command needs ${flag ?? 'a flag'}.\n${HELP_LINE}`, flagName);
+        case 'commander.optionMissingArgument':
+            return new CliError('bad_usage', `${flag ?? 'A flag'} needs a value.\n${HELP_LINE}`, flagName);
+        case 'commander.invalidArgument': {
+            const choices = match(error, /Allowed choices are ([^.]+)/)?.[1];
+            return new CliError('bad_usage', `${flag ?? 'That'} ${choices === undefined ? "doesn't take that value" : `takes one of ${choices}`}.\n${HELP_LINE}`, flagName);
+        }
+        case 'commander.unknownOption':
+            return new CliError('bad_usage', `${match(error, /unknown option '([^']+)'/)?.[1] ?? 'That flag'} isn't a flag of this command.\n${HELP_LINE}`);
+        case 'commander.unknownCommand':
+            return new CliError('bad_usage', `${match(error, /unknown command '([^']+)'/)?.[1] ?? 'That'} isn't a command.\nRun grayspar --help to see the commands.`);
+        case 'commander.missingArgument':
+            return new CliError('bad_usage', `This command needs ${match(error, /argument '([^']+)'/)?.[1] ?? 'more'} after its name.\n${HELP_LINE}`);
+        case 'commander.excessArguments':
+            return new CliError('bad_usage', `This command was given more than it takes.\n${HELP_LINE}`);
+        default:
+            return new CliError('bad_usage', `That command line isn't valid.\n${HELP_LINE}`);
+    }
+}
+export function routeUsageErrors(program) {
+    const refuse = (error) => {
+        if (error.exitCode === 0 || error.code === 'commander.help')
+            process.exit(error.exitCode);
+        exitWithError(program.opts().json === true ? 'json' : 'text', usageErrorFor(error));
+    };
+    const route = (command) => {
+        command.exitOverride(refuse).configureOutput({ outputError: () => undefined });
+        command.commands.forEach(route);
+    };
+    route(program);
+}

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('package.json of the CLI has no version');
+}
+export const cliVersion = readVersion();

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "@grayspar/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.2",
+  "description": "The cloud for small software. Deploy your applications with one command, and share them with exactly the people you choose.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/grayspar/Grayspar.git",
+    "directory": "packages/cli"
+  },
+  "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"
+  }
 }