@onesi/genesis-cli 0.1.13 → 0.2.1

package/dist/orgs.js

@@ -0,0 +1,89 @@
+import { createHash } from 'node:crypto';
+import { basename, extname } from 'node:path';
+import { readFunctionFile, readFunctionJson, writeFunctionOutput } from './function-input.js';
+/** Orgs accepts documents of 1 byte to 5 MiB (sent as base64 in JSON). */
+export const ORGS_MAX_DOCUMENT_BYTES = 5 * 1024 * 1024;
+const MEDIA_TYPES = {
+    '.pdf': 'application/pdf', '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+    '.txt': 'text/plain', '.md': 'text/markdown', '.markdown': 'text/markdown', '.json': 'application/json',
+};
+const DOCUMENT_KINDS = ['articles', 'certificate', 'operating_agreement', 'bylaws', 'resolution', 'filing_receipt', 'tax_letter', 'other'];
+const group = (parent, name) => parent.commands.find(c => c.name() === name) ?? parent.command(name);
+/**
+ * The Orgs commands that are more than one JSON request: uploading a document from a file, downloading
+ * a document's bytes to a path (checked against its sha256), and requesting formation with --dry-run.
+ * Every other Orgs operation is a generic command under `genesis orgs` (products.ts).
+ */
+export function registerOrgs(program, deps) {
+    const orgs = group(program, 'orgs');
+    const documents = group(orgs, 'documents');
+    documents.command('add <entity>')
+        .description('Add a document from a file (up to 5 MiB) or a Boxes file (POST /v1/orgs/entities/{entity}/documents)')
+        .requiredOption('--kind <kind>', DOCUMENT_KINDS.join(' | '))
+        .option('--file <path>', 'document file; sent as base64')
+        .option('--boxes-file-id <id>', 'a Boxes file instead of --file')
+        .option('--title <title>', 'defaults to the file name')
+        .option('--media-type <type>', 'application/pdf | image/png | image/jpeg | text/plain | text/markdown | application/json (default: from the file extension)')
+        .action(async (entity, o) => {
+        if (!DOCUMENT_KINDS.includes(o.kind))
+            throw new Error(`--kind must be one of ${DOCUMENT_KINDS.join(', ')}`);
+        if (!o.file === !o.boxesFileId)
+            throw new Error('Pass exactly one of --file or --boxes-file-id.');
+        const mediaType = o.mediaType ?? (o.file ? MEDIA_TYPES[extname(o.file).toLowerCase()] : undefined);
+        if (!mediaType)
+            throw new Error('Pass --media-type (the file extension does not name a supported type).');
+        const title = o.title ?? (o.file ? basename(o.file) : undefined);
+        if (!title)
+            throw new Error('Pass --title.');
+        let content;
+        if (o.file) {
+            const bytes = await readFunctionFile(o.file, ORGS_MAX_DOCUMENT_BYTES);
+            if (!bytes.length)
+                throw new Error('The document file is empty.');
+            content = { content_base64: Buffer.from(bytes).toString('base64') };
+        }
+        else
+            content = { boxes_file_id: o.boxesFileId };
+        const body = { kind: o.kind, title, media_type: mediaType, ...content };
+        const result = await (await deps.client()).request('orgs_add_document', { entity, body }, { signal: deps.signal });
+        deps.emit(result, () => JSON.stringify(result, null, 2));
+    });
+    documents.command('content <document>')
+        .description("Download a document's bytes to a new file and check its sha256 (GET /v1/orgs/documents/{document}/content)")
+        .requiredOption('--out <path>', 'new file to write (an existing file is never overwritten)')
+        .action(async (document, o) => {
+        const genesis = await deps.client();
+        const { bytes, contentType, sha256 } = await genesis.orgs.documents.content(document, { signal: deps.signal });
+        const actual = createHash('sha256').update(bytes).digest('hex');
+        if (sha256 && sha256 !== actual)
+            throw new Error('The downloaded bytes do not match the document sha256. Nothing was written.');
+        await writeFunctionOutput(o.out, bytes);
+        const result = { document, path: o.out, bytes: bytes.byteLength, content_type: contentType, sha256: actual, verified: sha256 === actual };
+        deps.emit(result, () => JSON.stringify(result, null, 2));
+    });
+    group(orgs, 'formation').command('request <entity>')
+        .description('Prepare the formation packet and start a rehearsal run that stops at the state submit/payment page; --dry-run returns only the packet (POST /v1/orgs/entities/{entity}/formation)')
+        .option('--contact-email <email>', 'contact email for the filing (required unless in --body-file)')
+        .option('--runtime <runtime>', 'panes (default) | rigs | shells')
+        .option('--instance-id <id>', 'an existing browser instance to drive')
+        .option('--effective-date <date>', 'YYYY-MM-DD')
+        .option('--dry-run', 'build and return the packet only; start nothing')
+        .option('--body-file <path>', 'JSON request body (e.g. organizers), up to 1 MiB; flags override its fields')
+        .action(async (entity, o) => {
+        const body = o.bodyFile ? await readFunctionJson(o.bodyFile, 1024 * 1024) : {};
+        if (o.contactEmail !== undefined)
+            body.contact_email = o.contactEmail;
+        if (o.runtime !== undefined)
+            body.runtime = o.runtime;
+        if (o.instanceId !== undefined)
+            body.instance_id = o.instanceId;
+        if (o.effectiveDate !== undefined)
+            body.effective_date = o.effectiveDate;
+        if (o.dryRun)
+            body.dry_run = true;
+        if (typeof body.contact_email !== 'string')
+            throw new Error('Pass --contact-email (or contact_email in --body-file).');
+        const result = await (await deps.client()).request('orgs_request_formation', { entity, body }, { signal: deps.signal });
+        deps.emit(result, () => JSON.stringify(result, null, 2));
+    });
+}

package/dist/output.d.ts

@@ -21,7 +21,19 @@ export declare const c: {
  * operators (U+2060-2064), Mongolian vowel separator (U+180E), soft hyphen
  * (U+00AD) and tag characters (U+E0000-E007F).
  */
-export declare function safe(v: unknown): string;
+export declare function safe(v: unknown, keepLines?: boolean): string;
+/**
+ * A message cleaned for redaction: terminal controls and invisible characters are stripped first (line breaks
+ * kept, so header lines still match), so none can split a secret and hide it from the patterns.
+ */
+export declare function redactMessage(message: string): string;
+/**
+ * A message as the terminal prints it: redacted, made safe, then redacted again, because `safe` drops the tabs and
+ * line breaks redaction kept, which could join the pieces of a split secret back together.
+ */
+export declare function printable(message: string): string;
+/** The message of a caught error, redacted (tokens, card numbers, emails...) and safe to print. */
+export declare function errorText(e: unknown): string;
 /** Render rows as an aligned table; every cell is passed through safe(). */
 export declare function table(rows: Record<string, unknown>[], cols: string[]): string;
 /** Pull the array out of the various list envelopes ({data}, {zones}, {records}, bare array). */

package/dist/output.js

@@ -1,3 +1,4 @@
+import { redactErrorText } from '@onesi/genesis';
 export const stdio = { log: (s) => process.stdout.write(s + '\n'), err: (s) => process.stderr.write(s + '\n') };
 const tty = () => !!process.stdout.isTTY && !process.env.NO_COLOR;
 export const c = {
@@ -18,14 +19,32 @@ export const c = {
  * operators (U+2060-2064), Mongolian vowel separator (U+180E), soft hyphen
  * (U+00AD) and tag characters (U+E0000-E007F).
  */
-export function safe(v) {
+export function safe(v, keepLines = false) {
     return String(v)
         .replace(/(?:\x1b\]|\x9d)[^\x07\x1b\x9c]*(?:\x07|\x1b\\|\x9c)?/g, '')
         .replace(/(?:\x1b\[|\x9b)[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]?/g, '')
         .replace(/\x1b[\x20-\x2f]*[\x30-\x7e]?/g, '')
-        .replace(/[\x00-\x1f\x7f-\x9f]/g, '')
+        .replace(keepLines ? /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g : /[\x00-\x1f\x7f-\x9f]/g, '')
         .replace(/[\u202a-\u202e\u2066-\u2069\u200b-\u200f\u061c\ufeff\u2028\u2029\u2060-\u2064\u180e\u00ad\u{e0000}-\u{e007f}]/gu, '');
 }
+/**
+ * A message cleaned for redaction: terminal controls and invisible characters are stripped first (line breaks
+ * kept, so header lines still match), so none can split a secret and hide it from the patterns.
+ */
+export function redactMessage(message) {
+    return redactErrorText(safe(message, true));
+}
+/**
+ * A message as the terminal prints it: redacted, made safe, then redacted again, because `safe` drops the tabs and
+ * line breaks redaction kept, which could join the pieces of a split secret back together.
+ */
+export function printable(message) {
+    return redactErrorText(safe(redactMessage(message)));
+}
+/** The message of a caught error, redacted (tokens, card numbers, emails...) and safe to print. */
+export function errorText(e) {
+    return printable(e instanceof Error ? e.message : String(e));
+}
 /** Render rows as an aligned table; every cell is passed through safe(). */
 export function table(rows, cols) {
     if (!rows.length)

package/dist/products.d.ts

@@ -7,8 +7,12 @@ export declare const PRODUCT_COMMANDS: Record<string, {
     description: string;
     commands: Record<string, OperationId>;
 }>;
-export declare function registerProducts(program: Command, dependencies: {
+type ProductDependencies = {
     client: () => Promise<Genesis>;
     emit: (data: unknown, pretty: () => string) => void;
     signal?: AbortSignal;
-}): void;
+};
+export declare function registerProducts(program: Command, dependencies: ProductDependencies): void;
+export declare function printableMediaType(contentType: string | null | undefined): boolean;
+export declare function registerOperationCommands(root: Command, commands: Readonly<Record<string, OperationId>>, dependencies: ProductDependencies): void;
+export {};