@onesi/genesis-cli 0.0.0-stage → 0.1.13

package/dist/hives-resources.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+import type { Genesis } from '@onesi/genesis';
+type Deps = {
+    client: () => Promise<Genesis>;
+    emit: (data: unknown, pretty: () => string) => void;
+    readRequest?: (path: string, limit: number) => Promise<Record<string, unknown>>;
+};
+export declare function registerHivesResources(hives: Command, deps: Deps): void;
+export {};

package/dist/hives-resources.js

@@ -0,0 +1,94 @@
+import { registerHivesMarketplace } from './hives-marketplace.js';
+import { createReadStream } from 'node:fs';
+import { stat, writeFile } from 'node:fs/promises';
+import { readFunctionJson } from './function-input.js';
+async function bytes(path) {
+    const metadata = await stat(path);
+    if (!metadata.isFile() || metadata.size > 10 * 1024 * 1024)
+        throw new Error('Choose a regular file of at most 10 MiB.');
+    const stream = createReadStream(path);
+    const chunks = [];
+    let total = 0;
+    try {
+        for await (const chunk of stream) {
+            const value = Buffer.from(chunk);
+            total += value.byteLength;
+            if (total > 10 * 1024 * 1024)
+                throw new Error('Object file exceeds 10 MiB.');
+            chunks.push(value);
+        }
+    }
+    finally {
+        stream.destroy();
+    }
+    return Uint8Array.from(Buffer.concat(chunks, total));
+}
+function number(value, min, max) { if (value === undefined)
+    return undefined; if (!/^\d+$/.test(value) || !Number.isSafeInteger(Number(value)) || Number(value) < min || Number(value) > max)
+    throw new Error('Invalid bounded numeric option.'); return Number(value); }
+export function registerHivesResources(hives, deps) {
+    registerHivesMarketplace(hives, deps);
+    const output = (data) => deps.emit(data, () => JSON.stringify(data, null, 2));
+    const read = deps.readRequest ?? readFunctionJson;
+    const cells = hives.command('cells').description('Owned GCS buckets and objects; uncertain mutations require readback/reconciliation');
+    cells.command('list <project_id>').option('--page <number>').option('--per-page <number>').action(async (project, o) => output(await (await deps.client()).hives.cells.list(project, { page: number(o.page, 1, 10000), per_page: number(o.perPage, 1, 100) })));
+    cells.command('get <project_id> <bucket_id>').action(async (project, id) => output(await (await deps.client()).hives.cells.get(project, id)));
+    cells.command('create <project_id>').requiredOption('--request-file <path>', 'JSON name, region, visibility and CORS').action(async (project, o) => output(await (await deps.client()).hives.cells.create(project, await read(o.requestFile, 512 * 1024))));
+    for (const action of ['remove', 'reconcile'])
+        cells.command(`${action} <project_id> <bucket_id>`).action(async (project, id) => output(await (await deps.client()).hives.cells[action](project, id)));
+    const cors = cells.command('cors');
+    cors.command('get <project_id> <bucket_id>').action(async (project, id) => output(await (await deps.client()).hives.cells.cors.get(project, id)));
+    cors.command('set <project_id> <bucket_id>').requiredOption('--request-file <path>', 'JSON object with rules array').action(async (project, id, o) => { const body = await read(o.requestFile, 512 * 1024); if (!Array.isArray(body.rules))
+        throw new Error('CORS JSON requires rules.'); output(await (await deps.client()).hives.cells.cors.set(project, id, body.rules)); });
+    const objects = cells.command('objects');
+    objects.command('list <project_id> <bucket_id>').option('--prefix <value>').option('--delimiter <value>').option('--continuation-token <value>').option('--max-keys <number>').action(async (project, id, o) => output(await (await deps.client()).hives.cells.objects.list(project, id, { prefix: o.prefix, delimiter: o.delimiter, continuation_token: o.continuationToken, max_keys: number(o.maxKeys, 1, 1000) })));
+    for (const action of ['put', 'put-flat'])
+        objects.command(`${action} <project_id> <bucket_id> <key>`).requiredOption('--file <path>', 'Exact binary bytes up to 10 MiB').option('--content-type <value>').action(async (project, id, key, o) => { const client = await deps.client(); output(await client.hives.cells.objects[action === 'put' ? 'put' : 'putFlat'](project, id, key, await bytes(o.file), { content_type: o.contentType })); });
+    for (const action of ['remove', 'remove-flat'])
+        objects.command(`${action} <project_id> <bucket_id> <key>`).action(async (project, id, key) => { await (await deps.client()).hives.cells.objects[action === 'remove' ? 'remove' : 'removeFlat'](project, id, key); output({ acknowledged: true }); });
+    objects.command('download <project_id> <bucket_id> <key>').requiredOption('--output-file <path>', 'Create a new file; existing files are never overwritten').action(async (project, id, key, o) => { const response = await (await deps.client()).hives.cells.objects.download(project, id, key); const data = new Uint8Array(await response.arrayBuffer()); await writeFile(o.outputFile, data, { flag: 'wx', mode: 0o600 }); output({ saved: true, bytes: data.byteLength }); });
+    cells.command('presign <project_id> <bucket_id>').requiredOption('--request-file <path>', 'Explicit GET/PUT capability request; PUT requires exact content_length').action(async (project, id, o) => output(await (await deps.client()).hives.cells.presign(project, id, await read(o.requestFile, 64 * 1024))));
+    const queues = hives.command('queues').description('Buzz durable messages and possessed temporary delivery receipts');
+    const consumer = queues.command('consumer').description('Persisted standard-queue function binding; inspect state after an unknown mutation outcome');
+    for (const action of ['get', 'remove'])
+        consumer.command(`${action} <project_id> <queue_id>`).action(async (project, id) => output(await (await deps.client()).hives.queues.consumer[action](project, id)));
+    consumer.command('configure <project_id> <queue_id>').requiredOption('--request-file <path>', 'Exact existing queue delivery settings and owned active function').action(async (project, id, o) => output(await (await deps.client()).hives.queues.consumer.configure(project, id, await read(o.requestFile, 4096))));
+    for (const action of ['list'])
+        queues.command(`${action} <project_id>`).action(async (project) => output(await (await deps.client()).hives.queues[action](project)));
+    for (const action of ['get', 'stats', 'consumers', 'pause', 'resume', 'purge', 'remove', 'dead-letter-stats', 'purge-dead-letters']) {
+        const names = { 'dead-letter-stats': 'deadLetterStats', 'purge-dead-letters': 'purgeDeadLetters' };
+        queues.command(`${action} <project_id> <queue_id>`).action(async (project, id) => { const client = await deps.client(); const method = action in names ? names[action] : action; output(await client.hives.queues[method](project, id)); });
+    }
+    queues.command('create <project_id>').requiredOption('--request-file <path>', 'Queue name, standard/dead_letter/fifo type and optional delivery settings').action(async (project, o) => output(await (await deps.client()).hives.queues.create(project, await read(o.requestFile, 512 * 1024))));
+    queues.command('configure <project_id> <queue_id>').requiredOption('--request-file <path>').action(async (project, id, o) => output(await (await deps.client()).hives.queues.configure(project, id, await read(o.requestFile, 512 * 1024))));
+    queues.command('send <project_id> <queue_id>').requiredOption('--request-file <path>', 'Exactly body or body_base64; decoded body 256 KiB. FIFO retains its separate message_group_id and deduplication_id contract').option('--idempotency-key <key>', 'Persist the original key for a funded standard-queue send; never change it after uncertainty').action(async (project, id, o) => output(await (await deps.client()).hives.queues.send(project, id, await read(o.requestFile, 512 * 1024), { idempotencyKey: o.idempotencyKey })));
+    queues.command('operations').description('Read original queue operation status without sending another message').command('get <project_id> <queue_id> <operation_id>').action(async (project, id, operation) => output(await (await deps.client()).hives.queues.operations.get(project, id, operation)));
+    queues.command('receive <project_id> <queue_id>').option('--max-messages <number>').option('--wait-seconds <number>').action(async (project, id, o) => output(await (await deps.client()).hives.queues.receive(project, id, { maxMessages: number(o.maxMessages, 1, 10), waitSeconds: number(o.waitSeconds, 0, 10) })));
+    for (const action of ['ack', 'nack'])
+        queues.command(`${action} <project_id> <queue_id> <message_id>`).requiredOption('--receipt-file <path>', 'JSON receiptHandle; not a credential/header/query').action(async (project, id, message, o) => { const body = await read(o.receiptFile, 4096); if (typeof body.receiptHandle !== 'string')
+            throw new Error('Receipt JSON requires receiptHandle.'); output(await (await deps.client()).hives.queues[action](project, id, message, body.receiptHandle)); });
+    queues.command('dead-letters <project_id> <queue_id>').option('--limit <number>').option('--offset <number>').action(async (project, id, o) => output(await (await deps.client()).hives.queues.deadLetters(project, id, { limit: number(o.limit, 1, 10), offset: number(o.offset, 0, 8192) })));
+    for (const action of ['replay', 'delete-dead-letter'])
+        queues.command(`${action} <project_id> <queue_id> <message_id>`).action(async (project, id, message) => output(await (await deps.client()).hives.queues[action === 'replay' ? 'replay' : 'deleteDeadLetter'](project, id, message)));
+    const topics = hives.command('topics').description('Owned Buzz topics; publication persists deliveries, never retries an unknown outcome');
+    topics.command('list <project_id>').action(async (project) => output(await (await deps.client()).hives.topics.list(project)));
+    for (const action of ['get', 'remove'])
+        topics.command(`${action} <project_id> <topic_id>`).action(async (project, id) => output(await (await deps.client()).hives.topics[action](project, id)));
+    topics.command('create <project_id>').requiredOption('--request-file <path>', 'JSON topic name').action(async (project, o) => output(await (await deps.client()).hives.topics.create(project, await read(o.requestFile, 4096))));
+    topics.command('publish <project_id> <topic_id>').requiredOption('--request-file <path>', 'Exactly body or body_base64 plus optional string attributes; no automatic retry').action(async (project, id, o) => output(await (await deps.client()).hives.topics.publish(project, id, await read(o.requestFile, 512 * 1024))));
+    const subscriptions = topics.command('subscriptions').description('Same-project standard queue destinations; removing a subscription retains queued messages');
+    subscriptions.command('list <project_id> <topic_id>').action(async (project, id) => output(await (await deps.client()).hives.topics.subscriptions.list(project, id)));
+    subscriptions.command('add <project_id> <topic_id> <queue_id>').action(async (project, id, queue) => output(await (await deps.client()).hives.topics.subscriptions.add(project, id, queue)));
+    subscriptions.command('remove <project_id> <topic_id> <subscription_id>').action(async (project, id, subscription) => output(await (await deps.client()).hives.topics.subscriptions.remove(project, id, subscription)));
+    const volumes = hives.command('volumes').description('Persistent local storage; refresh saved state after an uncertain acknowledgement');
+    volumes.command('list <project_id>').option('--page <number>').option('--per-page <number>').action(async (project, o) => output(await (await deps.client()).hives.volumes.list(project, { page: number(o.page, 1, 10000), per_page: number(o.perPage, 1, 100) })));
+    for (const action of ['get', 'unmount', 'remove'])
+        volumes.command(`${action} <project_id> <volume_id>`).action(async (project, id) => output(await (await deps.client()).hives.volumes[action](project, id)));
+    volumes.command('create <project_id>').requiredOption('--request-file <path>', 'JSON name and size_mib (32–1024); local read_write_once only').action(async (project, o) => output(await (await deps.client()).hives.volumes.create(project, await read(o.requestFile, 4096))));
+    volumes.command('mount <project_id> <volume_id>').requiredOption('--request-file <path>', 'JSON target_id, mount_path and explicit read_only; preserve these values when reconnecting').action(async (project, id, o) => output(await (await deps.client()).hives.volumes.mount(project, id, await read(o.requestFile, 4096))));
+    const runtime = hives.command('runtimes').description('Compiled serving implementation metadata; not available capacity');
+    runtime.command('list').action(async () => output(await (await deps.client()).hives.runtimes.list()));
+    runtime.command('project <project_id>').action(async (project) => output(await (await deps.client()).hives.runtimes.project(project)));
+    runtime.command('get <name>').action(async (name) => output(await (await deps.client()).hives.runtimes.get(name)));
+    runtime.command('select').requiredOption('--wasi <value>').requiredOption('--runner <value>').requiredOption('--artifact <value>').action(async (input) => output(await (await deps.client()).hives.runtimes.select(input)));
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+import { type CredentialStore } from './store.js';
+import { type Out } from './output.js';
+import { type SecretInputOptions } from './secret-input.js';
+export interface Deps {
+    out?: Out;
+    store?: () => Promise<CredentialStore>;
+    fetch?: typeof fetch;
+    /** Cancel Hives calls through response-body completion; other products retain their transport. */
+    signal?: AbortSignal;
+    env?: Record<string, string | undefined>;
+    openBrowser?: (url: string) => void;
+    sleep?: (ms: number) => Promise<void>;
+    readSecretInput?: (options: SecretInputOptions, limit: number) => Promise<string>;
+    readWasmFile?: (path: string) => Promise<Blob>;
+    writeBytes?: (bytes: Uint8Array) => void;
+    writeOutputFile?: (path: string, bytes: Uint8Array) => Promise<void>;
+    readHivesRequest?: (path: string, limit: number) => Promise<Record<string, unknown>>;
+}
+export declare function buildProgram(deps?: Deps): Command;
+export declare function main(argv: string[], deps?: Deps): Promise<number>;