avo-cli 0.0.3 → 4.2.0.beta.1

data/payload/dist/record-command.js

@@ -0,0 +1,51 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from './base-command.js';
+import { CliError, wrongShape } from './errors.js';
+import { splitList } from './list.js';
+import { renderTable } from './table.js';
+// `--fields` is defined here but declared only by the commands that print records, so `delete` does not advertise a
+// flag it would ignore. `schema` extends `BaseCommand` directly: its resource is optional and it prints a field list.
+export class RecordCommand extends BaseCommand {
+    static fieldsFlag = Flags.custom({
+        description: 'Columns to show, comma-separated, e.g. id,name,email',
+        helpGroup: 'OUTPUT',
+        helpValue: 'field,field',
+        // The shared comma rule, so no `run` splits a string.
+        async parse(value) {
+            return splitList(value);
+        },
+    })();
+    // `required` catches a missing word, not an empty one: `update users "$ID"` with the variable unset hands over `''`,
+    // and an id that encodes to nothing leaves a PATCH or DELETE aimed at the collection URL.
+    static idArg = Args.string({
+        description: 'Record id',
+        async parse(value) {
+            const id = value.trim();
+            if (id === '')
+                throw CliError.usage('No id given.');
+            return id;
+        },
+        required: true,
+    });
+    static resourceArg = Args.string({
+        description: 'A resource by its route key, as `schema` lists them',
+        required: true,
+    });
+    // One record, the way `get 5`, `create` and `update` all show it: down the page field by field, `--fields` picking
+    // the rows.
+    printRecord(response, flags) {
+        if (this.printedJson(flags, response))
+            return;
+        const { fields } = flags;
+        const rows = Object.entries(parseRecord(response))
+            .filter(([field]) => !fields || fields.includes(field))
+            .map(([field, value]) => ({ field, value }));
+        this.log(renderTable(rows));
+    }
+}
+function parseRecord(response) {
+    const body = response.body;
+    if (typeof body?.record !== 'object' || body.record === null)
+        throw wrongShape(response.url, 'a record');
+    return body.record;
+}

data/payload/dist/schema.js

@@ -0,0 +1,29 @@
+import { wrongShape } from './errors.js';
+// The one view name held here; every other is the server's to know, and a list would refuse a view a newer API serves.
+// It is sent explicitly because the answer does not echo the view, so the output names the view that was asked for.
+export const DEFAULT_VIEW = 'create';
+// `source` names where the payload came from, so a shape error can say what did not answer.
+function parseSchema(payload, source) {
+    const body = payload;
+    if (!Array.isArray(body?.resources)) {
+        throw wrongShape(source, 'a schema');
+    }
+    return body;
+}
+function parseResourceSchema(payload, source) {
+    const body = payload;
+    if (!Array.isArray(body?.fields)) {
+        throw wrongShape(source, 'a resource schema');
+    }
+    return body;
+}
+// The one place `_schema` is fetched, so the payload is shape-checked before any caller sees it.
+export async function loadSchema(client) {
+    const response = await client.get(['_schema']);
+    return { response, schema: parseSchema(response.body, response.url) };
+}
+// The same for `<resource>/_schema?view=…`. The view is always sent (see `DEFAULT_VIEW`).
+export async function fetchResourceSchema(client, resource, view) {
+    const response = await client.get([resource, '_schema'], { view });
+    return { response, schema: parseResourceSchema(response.body, response.url) };
+}

data/payload/dist/store.js

@@ -0,0 +1,91 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { CliError } from './errors.js';
+// Sync, so `resolveConfig` stays synchronous: one small local read. Nothing saved is the common case, not a failure.
+export function read(configDir) {
+    const file = fileIn(configDir);
+    let content;
+    try {
+        content = readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        throw failedTo('read', file, error);
+    }
+    return parse(content, file);
+}
+// Whether a saved file is there, without reading it, so a broken one cannot fail a command that does not use it.
+export function exists(configDir) {
+    return existsSync(fileIn(configDir));
+}
+// Answers whether it replaced a saved file, so `login` can say so.
+export function save(configDir, { apiVersion, host, token }) {
+    const file = fileIn(configDir);
+    const replaced = existsSync(file);
+    // A new file, then a rename: `writeFileSync`'s mode is ignored for a file that exists, and a symlink at either
+    // path would have its target written. `wx` refuses anything already at the temp path, so clear it first.
+    const temp = `${file}.tmp`;
+    try {
+        mkdirSync(configDir, { mode: 0o700, recursive: true });
+        rmSync(temp, { force: true });
+        writeFileSync(temp, `${JSON.stringify({ apiVersion, host, token }, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+        renameSync(temp, file);
+    }
+    catch (error) {
+        try {
+            rmSync(temp, { force: true });
+        }
+        catch {
+            // The write error is the one worth reporting; a temp file that also cannot go is no worse.
+        }
+        throw failedTo('write', file, error);
+    }
+    return replaced;
+}
+// Answers whether there was anything to delete, so `logout` can say so. A refused delete is not "nothing to delete":
+// the token is still on disk.
+export function remove(configDir) {
+    const file = fileIn(configDir);
+    try {
+        unlinkSync(file);
+        return true;
+    }
+    catch (error) {
+        if (isMissing(error))
+            return false;
+        throw failedTo('delete', file, error);
+    }
+}
+// Exported so a command naming the file says the same path the store reads and writes, not a second spelling of it.
+export function fileIn(configDir) {
+    return path.join(configDir, 'config.json');
+}
+function isMissing(error) {
+    const { code } = error;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+}
+// Exit 2 like the unusable-file message below: each is a file the customer has to deal with, not a command line.
+function failedTo(action, file, error) {
+    const { code } = error;
+    return CliError.usage(`Could not ${action} ${file} (${code ?? 'unknown error'}).`);
+}
+// A file we cannot use is one the customer has to deal with, so the message names it. It never quotes the contents:
+// the token is in there.
+function parse(content, file) {
+    const unusable = CliError.usage(`${file} is not a usable saved host and token. Delete it, or run \`avo login\` again.`);
+    let saved;
+    try {
+        saved = JSON.parse(content);
+    }
+    catch {
+        throw unusable;
+    }
+    const { apiVersion, host, token } = (saved ?? {});
+    if (!present(apiVersion) || !present(host) || !present(token))
+        throw unusable;
+    return { apiVersion, host, token };
+}
+function present(value) {
+    return typeof value === 'string' && value.length > 0;
+}

data/payload/dist/suggest.js

@@ -0,0 +1,29 @@
+// Two edits, case folded, covers a typo or a missing plural `s`; anything further is likelier a different word than
+// a slip.
+const MAX_DISTANCE = 2;
+export function suggest(name, candidates) {
+    const needle = name.toLowerCase();
+    let best;
+    let bestDistance = MAX_DISTANCE + 1;
+    for (const candidate of candidates) {
+        const distance = editDistance(needle, candidate.toLowerCase());
+        if (distance < bestDistance) {
+            best = candidate;
+            bestDistance = distance;
+        }
+    }
+    return best;
+}
+// Levenshtein, one row at a time.
+function editDistance(a, b) {
+    let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (let i = 1; i <= a.length; i++) {
+        const current = [i];
+        for (let j = 1; j <= b.length; j++) {
+            const substitution = previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
+            current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, substitution);
+        }
+        previous = current;
+    }
+    return previous[b.length];
+}

data/payload/dist/table.js

@@ -0,0 +1,40 @@
+// Wide enough for an email or a title, narrow enough that five columns still fit a terminal.
+const MAX_CELL_WIDTH = 40;
+// No box drawing and no colour: it has to read the same in a terminal, in a CI log, and to an agent.
+export function renderTable(rows, columns = collectColumns(rows)) {
+    const cells = rows.map((row) => columns.map((column) => truncate(formatCell(row[column]))));
+    // Widened a cell at a time: `Math.max(...column)` can exceed the argument limit on a long page.
+    const widths = columns.map((column) => column.length);
+    for (const row of cells) {
+        for (const [index, cell] of row.entries()) {
+            if (cell.length > widths[index])
+                widths[index] = cell.length;
+        }
+    }
+    const line = (values) => values.map((value, index) => value.padEnd(widths[index])).join('  ').trimEnd();
+    return [line(columns), ...cells.map((cell) => line(cell))].join('\n');
+}
+// Nothing becomes `-`, so an empty cell is visibly empty. An object becomes its JSON: the wire carries no type, so an
+// association and an app's own JSON column look alike, and the cell does not guess.
+export function formatCell(value) {
+    if (value === null || value === undefined || value === '')
+        return '-';
+    if (Array.isArray(value)) {
+        return value.length === 0 ? '-' : value.map((item) => formatCell(item)).join(', ');
+    }
+    if (typeof value === 'object')
+        return JSON.stringify(value);
+    return String(value).replaceAll(/\s*\n\s*/g, ' ');
+}
+// Every key seen, in the order first seen: the server decides the columns.
+function collectColumns(rows) {
+    const columns = new Set();
+    for (const row of rows) {
+        for (const key of Object.keys(row))
+            columns.add(key);
+    }
+    return [...columns];
+}
+function truncate(text) {
+    return text.length > MAX_CELL_WIDTH ? `${text.slice(0, MAX_CELL_WIDTH - 1)}…` : text;
+}

data/payload/dist/write-command.js

@@ -0,0 +1,26 @@
+import { Flags } from '@oclif/core';
+import { buildPayload } from './payload.js';
+import { RecordCommand } from './record-command.js';
+import { fetchResourceSchema } from './schema.js';
+// The flag stays a string, read by `readData` in `run`: oclif rewords whatever a flag's own `parse` throws, and a
+// refusal should read as its thrower worded it.
+export class WriteCommand extends RecordCommand {
+    static baseFlags = {
+        ...RecordCommand.baseFlags,
+        data: Flags.string({
+            char: 'd',
+            description: 'Fields to write, as one JSON object; @path reads it from a file, - from stdin',
+            helpValue: 'json|@path|-',
+            required: true,
+        }),
+        fields: RecordCommand.fieldsFlag,
+    };
+    // The view is a write's one pre-flight, for `param_key` and what `buildPayload` reads. Method and view are both
+    // passed, never derived: core names these views `new` and `edit`, which the schema endpoint does not accept.
+    async sendFields(client, request, path, data) {
+        const [resource] = path;
+        const { schema } = await fetchResourceSchema(client, resource, request.view);
+        const payload = buildPayload(data, schema.fields);
+        return client.request(request.method, path, { body: { [schema.param_key]: payload } });
+    }
+}

data/payload/node_modules/@inquirer/ansi/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2025 Simon Boudrias
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/payload/node_modules/@inquirer/ansi/README.md

@@ -0,0 +1,89 @@
+# @inquirer/ansi
+
+A lightweight package providing ANSI escape sequences for terminal cursor manipulation and screen clearing.
+
+# Installation
+
+<table>
+<tr>
+  <th>npm</th>
+  <th>yarn</th>
+</tr>
+<tr>
+<td>
+
+```sh
+npm install @inquirer/ansi
+```
+
+</td>
+<td>
+
+```sh
+yarn add @inquirer/ansi
+```
+
+</td>
+</tr>
+</table>
+
+## Usage
+
+```js
+import {
+  cursorUp,
+  cursorDown,
+  cursorTo,
+  cursorLeft,
+  cursorHide,
+  cursorShow,
+  eraseLines,
+} from '@inquirer/ansi';
+
+// Move cursor up 3 lines
+process.stdout.write(cursorUp(3));
+
+// Move cursor to specific position (x: 10, y: 5)
+process.stdout.write(cursorTo(10, 5));
+
+// Hide/show cursor
+process.stdout.write(cursorHide);
+process.stdout.write(cursorShow);
+
+// Clear 5 lines
+process.stdout.write(eraseLines(5));
+```
+
+Or when used inside an inquirer prompt:
+
+```js
+import { cursorHide } from '@inquirer/ansi';
+import { createPrompt } from '@inquirer/core';
+
+export default createPrompt((config, done: (value: void) => void) => {
+  return `Choose an option${cursorHide}`;
+});
+```
+
+## API
+
+### Cursor Movement
+
+- **`cursorUp(count?: number)`** - Move cursor up by `count` lines (default: 1)
+- **`cursorDown(count?: number)`** - Move cursor down by `count` lines (default: 1)
+- **`cursorTo(x: number, y?: number)`** - Move cursor to position (x, y). If y is omitted, only moves horizontally
+- **`cursorLeft`** - Move cursor to beginning of line
+
+### Cursor Visibility
+
+- **`cursorHide`** - Hide the cursor
+- **`cursorShow`** - Show the cursor
+
+### Screen Manipulation
+
+- **`eraseLines(count: number)`** - Clear `count` lines and position cursor at the beginning of the first cleared line
+
+# License
+
+Copyright (c) 2025 Simon Boudrias (twitter: [@vaxilart](https://twitter.com/Vaxilart))<br/>
+Licensed under the MIT license.

data/payload/node_modules/@inquirer/ansi/dist/commonjs/index.d.ts

@@ -0,0 +1,14 @@
+/** Move cursor to first column */
+export declare const cursorLeft: string;
+/** Hide the cursor */
+export declare const cursorHide: string;
+/** Show the cursor */
+export declare const cursorShow: string;
+/** Move cursor up by count rows */
+export declare const cursorUp: (rows?: number) => string;
+/** Move cursor down by count rows */
+export declare const cursorDown: (rows?: number) => string;
+/** Move cursor to position (x, y) */
+export declare const cursorTo: (x: number, y?: number) => string;
+/** Erase the specified number of lines above the cursor */
+export declare const eraseLines: (lines: number) => string;

data/payload/node_modules/@inquirer/ansi/dist/commonjs/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eraseLines = exports.cursorTo = exports.cursorDown = exports.cursorUp = exports.cursorShow = exports.cursorHide = exports.cursorLeft = void 0;
+const ESC = '\u001B[';
+/** Move cursor to first column */
+exports.cursorLeft = ESC + 'G';
+/** Hide the cursor */
+exports.cursorHide = ESC + '?25l';
+/** Show the cursor */
+exports.cursorShow = ESC + '?25h';
+/** Move cursor up by count rows */
+const cursorUp = (rows = 1) => (rows > 0 ? `${ESC}${rows}A` : '');
+exports.cursorUp = cursorUp;
+/** Move cursor down by count rows */
+const cursorDown = (rows = 1) => rows > 0 ? `${ESC}${rows}B` : '';
+exports.cursorDown = cursorDown;
+/** Move cursor to position (x, y) */
+const cursorTo = (x, y) => {
+    if (typeof y === 'number' && !Number.isNaN(y)) {
+        return `${ESC}${y + 1};${x + 1}H`;
+    }
+    return `${ESC}${x + 1}G`;
+};
+exports.cursorTo = cursorTo;
+const eraseLine = ESC + '2K';
+/** Erase the specified number of lines above the cursor */
+const eraseLines = (lines) => lines > 0 ? (eraseLine + (0, exports.cursorUp)(1)).repeat(lines - 1) + eraseLine + exports.cursorLeft : '';
+exports.eraseLines = eraseLines;

data/payload/node_modules/@inquirer/ansi/dist/commonjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

data/payload/node_modules/@inquirer/ansi/dist/esm/index.d.ts

@@ -0,0 +1,14 @@
+/** Move cursor to first column */
+export declare const cursorLeft: string;
+/** Hide the cursor */
+export declare const cursorHide: string;
+/** Show the cursor */
+export declare const cursorShow: string;
+/** Move cursor up by count rows */
+export declare const cursorUp: (rows?: number) => string;
+/** Move cursor down by count rows */
+export declare const cursorDown: (rows?: number) => string;
+/** Move cursor to position (x, y) */
+export declare const cursorTo: (x: number, y?: number) => string;
+/** Erase the specified number of lines above the cursor */
+export declare const eraseLines: (lines: number) => string;

data/payload/node_modules/@inquirer/ansi/dist/esm/index.js

@@ -0,0 +1,21 @@
+const ESC = '\u001B[';
+/** Move cursor to first column */
+export const cursorLeft = ESC + 'G';
+/** Hide the cursor */
+export const cursorHide = ESC + '?25l';
+/** Show the cursor */
+export const cursorShow = ESC + '?25h';
+/** Move cursor up by count rows */
+export const cursorUp = (rows = 1) => (rows > 0 ? `${ESC}${rows}A` : '');
+/** Move cursor down by count rows */
+export const cursorDown = (rows = 1) => rows > 0 ? `${ESC}${rows}B` : '';
+/** Move cursor to position (x, y) */
+export const cursorTo = (x, y) => {
+    if (typeof y === 'number' && !Number.isNaN(y)) {
+        return `${ESC}${y + 1};${x + 1}H`;
+    }
+    return `${ESC}${x + 1}G`;
+};
+const eraseLine = ESC + '2K';
+/** Erase the specified number of lines above the cursor */
+export const eraseLines = (lines) => lines > 0 ? (eraseLine + cursorUp(1)).repeat(lines - 1) + eraseLine + cursorLeft : '';

data/payload/node_modules/@inquirer/ansi/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

data/payload/node_modules/@inquirer/ansi/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@inquirer/ansi",
+  "version": "1.0.2",
+  "engines": {
+    "node": ">=18"
+  },
+  "author": "Simon Boudrias <admin@simonboudrias.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SBoudrias/Inquirer.js.git"
+  },
+  "keywords": [
+    "answer",
+    "answers",
+    "ask",
+    "base",
+    "cli",
+    "command",
+    "command-line",
+    "confirm",
+    "enquirer",
+    "generate",
+    "generator",
+    "hyper",
+    "input",
+    "inquire",
+    "inquirer",
+    "interface",
+    "iterm",
+    "javascript",
+    "menu",
+    "node",
+    "nodejs",
+    "prompt",
+    "promptly",
+    "prompts",
+    "question",
+    "readline",
+    "scaffold",
+    "scaffolder",
+    "scaffolding",
+    "stdin",
+    "stdout",
+    "terminal",
+    "tty",
+    "ui",
+    "yeoman",
+    "yo",
+    "zsh",
+    "ansi"
+  ],
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.2",
+    "@repo/tsconfig": "0.0.0",
+    "tshy": "^3.0.3"
+  },
+  "tshy": {
+    "exclude": [
+      "src/**/*.test.ts"
+    ],
+    "exports": {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "tsc": "tshy",
+    "attw": "attw --pack"
+  },
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    }
+  },
+  "main": "./dist/commonjs/index.js",
+  "types": "./dist/commonjs/index.d.ts",
+  "module": "./dist/esm/index.js",
+  "homepage": "https://github.com/SBoudrias/Inquirer.js/blob/main/packages/ansi/README.md",
+  "gitHead": "6881993e517e76fa891b72e1f5086fd11f7676ac"
+}

data/payload/node_modules/@inquirer/core/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2025 Simon Boudrias
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.