@onesi/genesis 0.1.13 → 0.2.1

package/dist/hives-environment.js

@@ -17,6 +17,18 @@ export function validateHivesEnvironment(input) {
         throw new Error('Environment input exceeds 2 MiB. Split it into smaller batches.');
     return result;
 }
+/** Names for DELETE /env: 1–100 distinct valid environment names. */
+export function validateHivesEnvironmentNames(input) {
+    if (!Array.isArray(input) || input.length < 1 || input.length > 100)
+        throw new Error('Environment deletion requires a JSON array of 1–100 names.');
+    for (const name of input) {
+        if (typeof name !== 'string' || name.length > 255 || !/^[A-Za-z][A-Za-z0-9_]*$/.test(name))
+            throw new Error('Environment names must start with a letter and contain only letters, numbers and underscores (up to 255 characters).');
+    }
+    if (new Set(input).size !== input.length)
+        throw new Error('Environment deletion names must be distinct.');
+    return [...input];
+}
 function record(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new Error('Hives returned invalid environment metadata.');
@@ -56,3 +68,13 @@ export function hivesEnvironmentReveal(value, key) {
         throw new Error('Hives returned invalid environment reveal data.');
     return { name: data.name, value: data.value };
 }
+/** PUT /env answers the whole decrypted map. Keep only the submitted names it confirms; never a value. */
+export function hivesEnvironmentSetNames(value, project, submitted) {
+    const data = record(value);
+    if (typeof project !== 'string' || !submitted || typeof submitted !== 'object')
+        throw new Error('Hives returned invalid environment data.');
+    const updated = Object.keys(submitted);
+    if (updated.some((name) => typeof data[name] !== 'string'))
+        throw new Error('Hives did not confirm every submitted environment name. Read the names before retrying.');
+    return { project_id: project, updated: updated.map((name) => ({ name })) };
+}

package/dist/hives-node.js

@@ -12,10 +12,13 @@ export async function closeHivesNodeTransport() {
     await current?.destroy();
 }
 export function hivesOperationBudget(id) {
-    if (['hives_list_buckets', 'hives_create_bucket', 'hives_get_bucket', 'hives_delete_bucket', 'hives_list_objects', 'hives_upload_object', 'hives_upload_object_by_key', 'hives_delete_object', 'hives_delete_object_by_key', 'hives_download_object_by_key', 'hives_get_cors_config', 'hives_set_cors_config', 'hives_generate_presigned_url', 'hives_reconcile'].includes(id))
+    if (['hives_list_buckets', 'hives_create_bucket', 'hives_get_bucket', 'hives_delete_bucket', 'hives_list_objects', 'hives_upload_object', 'hives_upload_object_by_key', 'hives_upload_object_named_download', 'hives_delete_object', 'hives_delete_object_by_key', 'hives_delete_object_named_download', 'hives_download_object_by_key', 'hives_get_cors_config', 'hives_set_cors_config', 'hives_generate_presigned_url', 'hives_reconcile'].includes(id))
         return 100_000;
     if (id === 'hives_cancel_deployment' || id === 'hives_delete_deployment' || id === 'hives_stop_deployment')
         return 330_000;
+    // A live SSE subscription is bounded by its caller's window or --follow limit (at most 300 s).
+    if (id === 'hives_stream_logs' || id === 'hives_stream_deployment_logs')
+        return 330_000;
     if (['hives_create_deployment', 'hives_upload_deployment', 'hives_invoke_deployment', 'hives_invoke_function', 'hives_invoke_function_async'].includes(id))
         return 40_000;
     if (['hives_create_function', 'hives_update_function', 'hives_delete_function'].includes(id))

package/dist/hives-operations.d.ts

@@ -29,15 +29,19 @@ export declare function hivesOperations(client: GenesisClient): {
                 continuation_token?: string;
                 max_keys?: number;
             }, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-cells.js").HivesObjectList>;
-            put(project: string, id: string, key: string, bytes: Blob | ArrayBuffer | ArrayBufferView, options?: import("./hives-resources-transport.js").HivesResourceOptions & {
+            put(project: string, id: string, key: string, bytes: Blob | ArrayBuffer | ArrayBufferView, options?: import("./hives-resources-transport.js").HivesFundedWriteOptions & {
                 content_type?: string;
             }): Promise<import("./hives-cells.js").HivesObjectAcknowledgement>;
             remove: (project: string, id: string, key: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<void>;
             download: (project: string, id: string, key: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<Response>;
-            putFlat(project: string, id: string, key: string, bytes: Blob | ArrayBuffer | ArrayBufferView, options?: import("./hives-resources-transport.js").HivesResourceOptions & {
+            putFlat(project: string, id: string, key: string, bytes: Blob | ArrayBuffer | ArrayBufferView, options?: import("./hives-resources-transport.js").HivesFundedWriteOptions & {
                 content_type?: string;
             }): Promise<import("./hives-cells.js").HivesObjectAcknowledgement>;
             removeFlat: (project: string, id: string, key: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<void>;
+            putDownload(project: string, id: string, bytes: Blob | ArrayBuffer | ArrayBufferView, options?: import("./hives-resources-transport.js").HivesFundedWriteOptions & {
+                content_type?: string;
+            }): Promise<import("./hives-cells.js").HivesObjectAcknowledgement>;
+            removeDownload: (project: string, id: string, options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<void>;
         };
         presign(project: string, id: string, body: import("./hives-cells.js").HivesPresign, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-cells.js").HivesPresignedUrl>;
     };
@@ -125,7 +129,7 @@ export declare function hivesOperations(client: GenesisClient): {
                 deleted: true;
             }>;
         };
-        publish(project: string, id: string, body: import("./hives-topics.js").HivesTopicPublish, options?: import("./hives-resources-transport.js").HivesResourceOptions): Promise<import("./hives-topics.js").HivesTopicPublication>;
+        publish(project: string, id: string, body: import("./hives-topics.js").HivesTopicPublish, options?: import("./hives-resources-transport.js").HivesFundedWriteOptions): Promise<import("./hives-topics.js").HivesTopicPublication>;
     };
     runtimes: {
         list: (options?: import("./hives-resources-transport.js").HivesResourceOptions) => Promise<{
@@ -334,4 +338,118 @@ export declare function hivesOperations(client: GenesisClient): {
             updated_at: string;
         }>;
     };
+    logs: {
+        query: (project_id: string, q?: Omit<In<"hives_query_logs">, "project_id">) => Promise<{
+            logs: import("./index.js").components["schemas"]["Hives.LogEntry"][];
+            pagination: import("./index.js").components["schemas"]["Hives.PaginationMeta"];
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+        }>;
+        stream: (project_id: string, q?: import("./hives-platform.js").HivesLogStreamQuery, init?: {
+            signal?: AbortSignal;
+        }) => AsyncGenerator<import("./hives-platform.js").HivesLogStreamEvent, void, any>;
+        window: (project_id: string, q?: import("./hives-platform.js").HivesLogStreamQuery, options?: import("./hives-platform.js").HivesLogWindowOptions) => Promise<import("./hives-platform.js").HivesLogWindow>;
+    };
+    domains: {
+        list: (project_id: string, q?: Omit<In<"hives_list_domains">, "project_id">) => Promise<{
+            data: {
+                created_at: string;
+                dns_status: string;
+                domain: string;
+                domain_type: import("./index.js").components["schemas"]["Hives.DomainType"];
+                id: string;
+                ssl_expires_at?: string | null;
+                ssl_status: string;
+                verification_record?: null | import("./index.js").components["schemas"]["Hives.VerificationRecord"];
+            }[];
+            pagination: import("./index.js").components["schemas"]["Hives.PaginationMeta"];
+        }>;
+        add: (project_id: string, body: In<"hives_add_domain">["body"]) => Promise<{
+            created_at: string;
+            dns_status: string;
+            domain: string;
+            domain_type: import("./index.js").components["schemas"]["Hives.DomainType"];
+            id: string;
+            ssl_expires_at?: string | null;
+            ssl_status: string;
+            verification_record?: null | import("./index.js").components["schemas"]["Hives.VerificationRecord"];
+        }>;
+        verify: (project_id: string, domain_id: string) => Promise<{
+            checked_at: string;
+            dns_status: string;
+            error?: string | null;
+            verified: boolean;
+        }>;
+        provisionSsl: (project_id: string, domain_id: string) => Promise<{
+            error?: string | null;
+            expires_at?: string | null;
+            ssl_status: string;
+            started: boolean;
+        }>;
+    };
+    auth: {
+        me: () => Promise<{
+            avatar?: string | null;
+            createdAt: string;
+            email: string;
+            id: string;
+            name: string;
+            organizationId?: string | null;
+            role: string;
+        }>;
+    };
+    fleets: {
+        list: () => Promise<{
+            fleets: import("./index.js").components["schemas"]["Hives.FleetStatusView"][];
+        }>;
+        deploy: (body: In<"hives_deploy_fleet">["body"]) => Promise<{
+            fleetId: string;
+            gatewayEndpoint?: string | null;
+            totalInstances: number;
+        }>;
+        status: (fleet_id: string) => Promise<{
+            fleetId: string;
+            gateway?: null | import("./index.js").components["schemas"]["Hives.GatewaySummary"];
+            healthyInstances: number;
+            name: string;
+            protocols: import("./index.js").components["schemas"]["Hives.ProtocolStatusView"][];
+            state: string;
+            totalInstances: number;
+        }>;
+        teardown: (fleet_id: string) => Promise<void>;
+    };
+    remote: {
+        sessions: {
+            list: (project_id: string, q?: Omit<In<"hives_list_remote_sessions">, "project_id">) => Promise<Record<string, never>>;
+            close: (project_id: string, session_id: string) => Promise<Record<string, never>>;
+        };
+        ssh: (project_id: string, body: In<"hives_create_ssh_session">["body"]) => Promise<{
+            expires_at: string;
+            fingerprint: string;
+            host: string;
+            port: number;
+            session_id: string;
+            username: string;
+        }>;
+        terminal: (project_id: string, body: In<"hives_create_terminal_session">["body"]) => Promise<{
+            expires_at: string;
+            session_id: string;
+            token: string;
+            websocket_url: string;
+        }>;
+        debug: (project_id: string, body: In<"hives_create_debug_session">["body"]) => Promise<{
+            debug_url: string;
+            expires_at: string;
+            protocol: string;
+            session_id: string;
+            token: string;
+        }>;
+        sftp: {
+            list: (project_id: string, target_id: string, q?: {
+                path?: string;
+            }) => Promise<Record<string, never>>;
+            read: (project_id: string, target_id: string, path: string) => Promise<Record<string, never>>;
+            write: (project_id: string, target_id: string, body: In<"hives_sftp_write">["body"]) => Promise<Record<string, never>>;
+            delete: (project_id: string, target_id: string, body: In<"hives_sftp_delete">["body"]) => Promise<Record<string, never>>;
+        };
+    };
 };

package/dist/hives-operations.js

@@ -2,9 +2,11 @@ import { hivesTopics } from './hives-topics.js';
 import { hivesCells } from './hives-cells.js';
 import { hivesQueues } from './hives-queues.js';
 import { hivesRuntimes } from './hives-runtimes.js';
+import { hivesPlatform } from './hives-platform.js';
 /** The original Hives scheduler, settings and measured activity use the same gateway and identity. */
 export function hivesOperations(client) {
     return {
+        ...hivesPlatform(client),
         cells: hivesCells(client),
         queues: hivesQueues(client),
         topics: hivesTopics(client),

package/dist/hives-platform.d.ts

@@ -0,0 +1,149 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput as In } from './types.js';
+/** One Server-Sent Event from `GET /v1/hives/projects/{project_id}/logs/stream`. `data` is parsed JSON when it is JSON. */
+export interface HivesLogStreamEvent {
+    event: string;
+    id?: string;
+    data: unknown;
+}
+export type HivesLogStreamQuery = Omit<In<'hives_stream_logs'>, 'project_id'>;
+export interface HivesLogWindowOptions {
+    /** Stop after this many events (1–10000, default 100). */
+    maxEvents?: number;
+    /** Stop after this many seconds (1–300, default 10). */
+    seconds?: number;
+    signal?: AbortSignal;
+}
+export interface HivesLogWindow {
+    events: HivesLogStreamEvent[];
+    ended: 'max_events' | 'time' | 'closed';
+}
+/** Pull-based SSE reader. `cancel()` closes the connection even while a read is pending. */
+export declare function hivesSseReader(response: Response): {
+    next(): Promise<HivesLogStreamEvent | undefined>;
+    cancel(): Promise<void>;
+};
+/** Yield SSE events until the caller stops iterating, the signal aborts or the server closes the stream. */
+export declare function hivesSseEvents(response: Response): AsyncGenerator<HivesLogStreamEvent>;
+/**
+ * Hives platform reads and actions the gateway already routes: project logs (query and live SSE), custom domains,
+ * the Hives identity, Hives fleets and remote sessions/SFTP.
+ */
+export declare function hivesPlatform(client: GenesisClient): {
+    logs: {
+        query: (project_id: string, q?: Omit<In<"hives_query_logs">, "project_id">) => Promise<{
+            logs: import("./index.js").components["schemas"]["Hives.LogEntry"][];
+            pagination: import("./index.js").components["schemas"]["Hives.PaginationMeta"];
+            time_range: import("./index.js").components["schemas"]["Hives.TimeRange"];
+        }>;
+        /** Live SSE events. Iterate and `break` (or abort the signal) to close the connection; it never ends on its own. */
+        stream: (project_id: string, q?: HivesLogStreamQuery, init?: {
+            signal?: AbortSignal;
+        }) => AsyncGenerator<HivesLogStreamEvent, void, any>;
+        /** A bounded window of the live stream: the first `maxEvents` events or `seconds` of stream, whichever comes first. */
+        window: (project_id: string, q?: HivesLogStreamQuery, options?: HivesLogWindowOptions) => Promise<HivesLogWindow>;
+    };
+    domains: {
+        list: (project_id: string, q?: Omit<In<"hives_list_domains">, "project_id">) => Promise<{
+            data: {
+                created_at: string;
+                dns_status: string;
+                domain: string;
+                domain_type: import("./index.js").components["schemas"]["Hives.DomainType"];
+                id: string;
+                ssl_expires_at?: string | null;
+                ssl_status: string;
+                verification_record?: null | import("./index.js").components["schemas"]["Hives.VerificationRecord"];
+            }[];
+            pagination: import("./index.js").components["schemas"]["Hives.PaginationMeta"];
+        }>;
+        add: (project_id: string, body: In<"hives_add_domain">["body"]) => Promise<{
+            created_at: string;
+            dns_status: string;
+            domain: string;
+            domain_type: import("./index.js").components["schemas"]["Hives.DomainType"];
+            id: string;
+            ssl_expires_at?: string | null;
+            ssl_status: string;
+            verification_record?: null | import("./index.js").components["schemas"]["Hives.VerificationRecord"];
+        }>;
+        verify: (project_id: string, domain_id: string) => Promise<{
+            checked_at: string;
+            dns_status: string;
+            error?: string | null;
+            verified: boolean;
+        }>;
+        provisionSsl: (project_id: string, domain_id: string) => Promise<{
+            error?: string | null;
+            expires_at?: string | null;
+            ssl_status: string;
+            started: boolean;
+        }>;
+    };
+    auth: {
+        me: () => Promise<{
+            avatar?: string | null;
+            createdAt: string;
+            email: string;
+            id: string;
+            name: string;
+            organizationId?: string | null;
+            role: string;
+        }>;
+    };
+    fleets: {
+        list: () => Promise<{
+            fleets: import("./index.js").components["schemas"]["Hives.FleetStatusView"][];
+        }>;
+        deploy: (body: In<"hives_deploy_fleet">["body"]) => Promise<{
+            fleetId: string;
+            gatewayEndpoint?: string | null;
+            totalInstances: number;
+        }>;
+        status: (fleet_id: string) => Promise<{
+            fleetId: string;
+            gateway?: null | import("./index.js").components["schemas"]["Hives.GatewaySummary"];
+            healthyInstances: number;
+            name: string;
+            protocols: import("./index.js").components["schemas"]["Hives.ProtocolStatusView"][];
+            state: string;
+            totalInstances: number;
+        }>;
+        teardown: (fleet_id: string) => Promise<void>;
+    };
+    remote: {
+        sessions: {
+            list: (project_id: string, q?: Omit<In<"hives_list_remote_sessions">, "project_id">) => Promise<Record<string, never>>;
+            close: (project_id: string, session_id: string) => Promise<Record<string, never>>;
+        };
+        ssh: (project_id: string, body: In<"hives_create_ssh_session">["body"]) => Promise<{
+            expires_at: string;
+            fingerprint: string;
+            host: string;
+            port: number;
+            session_id: string;
+            username: string;
+        }>;
+        terminal: (project_id: string, body: In<"hives_create_terminal_session">["body"]) => Promise<{
+            expires_at: string;
+            session_id: string;
+            token: string;
+            websocket_url: string;
+        }>;
+        debug: (project_id: string, body: In<"hives_create_debug_session">["body"]) => Promise<{
+            debug_url: string;
+            expires_at: string;
+            protocol: string;
+            session_id: string;
+            token: string;
+        }>;
+        sftp: {
+            list: (project_id: string, target_id: string, q?: {
+                path?: string;
+            }) => Promise<Record<string, never>>;
+            read: (project_id: string, target_id: string, path: string) => Promise<Record<string, never>>;
+            write: (project_id: string, target_id: string, body: In<"hives_sftp_write">["body"]) => Promise<Record<string, never>>;
+            delete: (project_id: string, target_id: string, body: In<"hives_sftp_delete">["body"]) => Promise<Record<string, never>>;
+        };
+    };
+};

package/dist/hives-platform.js

@@ -0,0 +1,183 @@
+import { GenesisError } from './errors.js';
+const bounded = (value, fallback, max, name) => {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isInteger(value) || value < 1 || value > max) {
+        throw new GenesisError({ status: 0, type: 'invalid_request', operationId: 'hives_stream_logs', message: `${name} must be an integer from 1 to ${max}.` });
+    }
+    return value;
+};
+function parseEvent(lines) {
+    let event = 'message';
+    let id;
+    const data = [];
+    for (const line of lines) {
+        if (!line || line.startsWith(':'))
+            continue; // SSE comments carry keepalives only.
+        const colon = line.indexOf(':');
+        const field = colon < 0 ? line : line.slice(0, colon);
+        let value = colon < 0 ? '' : line.slice(colon + 1);
+        if (value.startsWith(' '))
+            value = value.slice(1);
+        if (field === 'event')
+            event = value;
+        else if (field === 'id')
+            id = value;
+        else if (field === 'data')
+            data.push(value);
+    }
+    if (!data.length)
+        return undefined;
+    const text = data.join('\n');
+    let parsed = text;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch { /* non-JSON data such as heartbeat "ping" stays text */ }
+    return { event, ...(id === undefined ? {} : { id }), data: parsed };
+}
+/** Pull-based SSE reader. `cancel()` closes the connection even while a read is pending. */
+export function hivesSseReader(response) {
+    const reader = response.body?.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let lines = [];
+    let finished = !reader;
+    const take = () => {
+        let index;
+        while ((index = buffer.search(/\r\n|\r|\n/)) >= 0) {
+            const line = buffer.slice(0, index);
+            buffer = buffer.slice(index + (buffer.startsWith('\r\n', index) ? 2 : 1));
+            if (line !== '') {
+                lines.push(line);
+                continue;
+            }
+            const event = parseEvent(lines);
+            lines = [];
+            if (event)
+                return event;
+        }
+        return undefined;
+    };
+    return {
+        async next() {
+            for (;;) {
+                const ready = take();
+                if (ready)
+                    return ready;
+                if (finished) {
+                    const tail = parseEvent(buffer ? [...lines, buffer] : lines);
+                    buffer = '';
+                    lines = [];
+                    return tail;
+                }
+                const { done, value } = await reader.read();
+                if (done)
+                    finished = true;
+                else
+                    buffer += decoder.decode(value, { stream: true });
+            }
+        },
+        async cancel() { finished = true; await reader?.cancel().catch(() => { }); },
+    };
+}
+/** Yield SSE events until the caller stops iterating, the signal aborts or the server closes the stream. */
+export async function* hivesSseEvents(response) {
+    const sse = hivesSseReader(response);
+    try {
+        for (let event = await sse.next(); event; event = await sse.next())
+            yield event;
+    }
+    finally {
+        await sse.cancel();
+    }
+}
+/**
+ * Hives platform reads and actions the gateway already routes: project logs (query and live SSE), custom domains,
+ * the Hives identity, Hives fleets and remote sessions/SFTP.
+ */
+export function hivesPlatform(client) {
+    const open = async (project_id, q = {}, init = {}) => {
+        const res = await client.raw('hives_stream_logs', { ...q, project_id }, { signal: init.signal, headers: { accept: 'text/event-stream' } });
+        if (!(res.headers.get('content-type') ?? '').toLowerCase().startsWith('text/event-stream')) {
+            void res.body?.cancel().catch(() => { });
+            throw new GenesisError({ status: res.status, type: 'invalid_response', operationId: 'hives_stream_logs', message: 'Hives did not return a Server-Sent Events stream.',
+                requestId: res.headers.get('x-request-id') ?? undefined });
+        }
+        return res;
+    };
+    return {
+        logs: {
+            query: (project_id, q = {}) => client.request('hives_query_logs', { ...q, project_id }),
+            /** Live SSE events. Iterate and `break` (or abort the signal) to close the connection; it never ends on its own. */
+            stream: async function* (project_id, q = {}, init = {}) {
+                yield* hivesSseEvents(await open(project_id, q, init));
+            },
+            /** A bounded window of the live stream: the first `maxEvents` events or `seconds` of stream, whichever comes first. */
+            window: async (project_id, q = {}, options = {}) => {
+                const maxEvents = bounded(options.maxEvents, 100, 10_000, 'maxEvents');
+                const seconds = bounded(options.seconds, 10, 300, 'seconds');
+                const events = [];
+                // The window starts before the request, so a server that withholds headers cannot outlast it.
+                const deadline = new AbortController();
+                let timer;
+                const elapsed = new Promise((resolve) => { timer = setTimeout(() => { resolve('time'); deadline.abort(); }, seconds * 1000); });
+                const signal = options.signal ? AbortSignal.any([options.signal, deadline.signal]) : deadline.signal;
+                let sse;
+                try {
+                    const response = await Promise.race([open(project_id, q, { signal }), elapsed]);
+                    if (response === 'time')
+                        return { events, ended: 'time' };
+                    sse = hivesSseReader(response);
+                    for (;;) {
+                        const next = await Promise.race([sse.next(), elapsed]);
+                        if (next === 'time')
+                            return { events, ended: 'time' };
+                        if (!next)
+                            return { events, ended: 'closed' };
+                        events.push(next);
+                        if (events.length >= maxEvents)
+                            return { events, ended: 'max_events' };
+                    }
+                }
+                catch (error) {
+                    if (deadline.signal.aborted && !options.signal?.aborted)
+                        return { events, ended: 'time' };
+                    throw error;
+                }
+                finally {
+                    clearTimeout(timer);
+                    await sse?.cancel();
+                }
+            },
+        },
+        domains: {
+            list: (project_id, q = {}) => client.request('hives_list_domains', { ...q, project_id }),
+            add: (project_id, body) => client.request('hives_add_domain', { project_id, body }),
+            verify: (project_id, domain_id) => client.request('hives_verify_domain', { project_id, domain_id }),
+            provisionSsl: (project_id, domain_id) => client.request('hives_provision_ssl', { project_id, domain_id }),
+        },
+        auth: { me: () => client.request('hives_me') },
+        fleets: {
+            list: () => client.request('hives_list_fleets'),
+            deploy: (body) => client.request('hives_deploy_fleet', { body }),
+            status: (fleet_id) => client.request('hives_get_fleet_status', { fleet_id }),
+            teardown: (fleet_id) => client.request('hives_teardown_fleet', { fleet_id }),
+        },
+        remote: {
+            sessions: {
+                list: (project_id, q = {}) => client.request('hives_list_remote_sessions', { ...q, project_id }),
+                close: (project_id, session_id) => client.request('hives_close_remote_session', { project_id, session_id }),
+            },
+            ssh: (project_id, body) => client.request('hives_create_ssh_session', { project_id, body }),
+            terminal: (project_id, body) => client.request('hives_create_terminal_session', { project_id, body }),
+            debug: (project_id, body) => client.request('hives_create_debug_session', { project_id, body }),
+            sftp: {
+                list: (project_id, target_id, q = {}) => client.request('hives_sftp_list', { ...q, project_id, target_id }),
+                read: (project_id, target_id, path) => client.request('hives_sftp_read', { project_id, target_id, path }),
+                write: (project_id, target_id, body) => client.request('hives_sftp_write', { project_id, target_id, body }),
+                delete: (project_id, target_id, body) => client.request('hives_sftp_delete', { project_id, target_id, body }),
+            },
+        },
+    };
+}

package/dist/hives-resources-transport.d.ts

@@ -6,12 +6,18 @@ export declare const HIVES_RESOURCE_JSON_BYTES: number;
 export interface HivesResourceOptions {
     signal?: AbortSignal;
 }
+/** Funded Hives writes (topic publish, Cells object writes): Hives refuses them without one Idempotency-Key. */
+export interface HivesFundedWriteOptions extends HivesResourceOptions {
+    idempotencyKey?: string;
+}
+/** The caller's key, or a fresh one when none is given. Reuse a key only to replay the same write, never to act twice. */
+export declare function hivesFundedWriteHeaders(options?: HivesFundedWriteOptions, id?: string): Record<string, string>;
 export declare function hivesResourceId(value: string): string;
 export declare function resourceError(status: number, id?: string): GenesisError;
 /** A non-2xx Hives resource reply as a GenesisError with the gateway's code, request id and required scope (bounded read, body discarded). */
 export declare function resourceErrorFromResponse(response: Response, id?: string): Promise<GenesisError>;
 export declare const isHivesResourceOperation: (id: string) => boolean;
-export declare const isHivesObjectUpload: (id: string) => id is "hives_upload_object_by_key" | "hives_upload_object";
+export declare const isHivesObjectUpload: (id: string) => id is "hives_upload_object_by_key" | "hives_upload_object_named_download" | "hives_upload_object";
 /** Shared-client hook proposal: snapshot only the two real raw Cells upload operations. */
 export declare function hivesObjectBody(value: unknown): Promise<ArrayBuffer>;
 export declare function hivesContentType(value?: string): string;

package/dist/hives-resources-transport.js

@@ -2,6 +2,14 @@ import { GenesisError } from './errors.js';
 export const HIVES_OBJECT_BYTES = 10 * 1024 * 1024;
 export const HIVES_QUEUE_BYTES = 256 * 1024;
 export const HIVES_RESOURCE_JSON_BYTES = 2 * 1024 * 1024;
+/** The caller's key, or a fresh one when none is given. Reuse a key only to replay the same write, never to act twice. */
+export function hivesFundedWriteHeaders(options = {}, id) {
+    const key = options.idempotencyKey ?? globalThis.crypto.randomUUID();
+    // Hives' bound (operation_funding.rs key()): one value of 1-128 printable ASCII bytes.
+    if (typeof key !== 'string' || !/^[ -~]{1,128}$/.test(key))
+        throw resourceError(0, id);
+    return { 'idempotency-key': key };
+}
 export function hivesResourceId(value) {
     if (typeof value !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(value))
         throw resourceError(0);
@@ -50,8 +58,8 @@ export async function resourceErrorFromResponse(response, id) {
         code: fields.code, requestId: fields.requestId,
         body: fields.code || fields.requiredScope ? { error: { code: fields.code, request_id: fields.requestId, required_scope: fields.requiredScope } } : undefined });
 }
-export const isHivesResourceOperation = (id) => /^(?:hives_marketplace_(?:categories|featured|installed|get_installation|uninstall|reconcile|list_packages|publish|get_package|install|update|list_versions)|hives_(?:get|configure|remove)_native_queue_consumer|hives_.*_native_queue|hives_.*_native_topic|hives_(?:(?:list_volumes|create_volume|get_volume|delete_volume|mount_volume|unmount_volume)|list_buckets|create_bucket|get_bucket|delete_bucket|list_objects|upload_object(?:_by_key)?|delete_object(?:_by_key)?|download_object_by_key|get_cors_config|set_cors_config|generate_presigned_url|reconcile|list_runtimes|get_runtime|select_runtime|list_project_runtimes))$/.test(id);
-export const isHivesObjectUpload = (id) => id === 'hives_upload_object_by_key' || id === 'hives_upload_object';
+export const isHivesResourceOperation = (id) => /^(?:hives_marketplace_(?:categories|featured|installed|get_installation|uninstall|reconcile|list_packages|publish|get_package|install|update|list_versions)|hives_(?:get|configure|remove)_native_queue_consumer|hives_.*_native_queue|hives_.*_native_topic|hives_(?:(?:list_volumes|create_volume|get_volume|delete_volume|mount_volume|unmount_volume)|list_buckets|create_bucket|get_bucket|delete_bucket|list_objects|upload_object(?:_by_key|_named_download)?|delete_object(?:_by_key|_named_download)?|download_object_by_key|get_cors_config|set_cors_config|generate_presigned_url|reconcile|list_runtimes|get_runtime|select_runtime|list_project_runtimes))$/.test(id);
+export const isHivesObjectUpload = (id) => id === 'hives_upload_object_by_key' || id === 'hives_upload_object' || id === 'hives_upload_object_named_download';
 /** Shared-client hook proposal: snapshot only the two real raw Cells upload operations. */
 export async function hivesObjectBody(value) {
     let bytes;

package/dist/hives-sse.d.ts

@@ -0,0 +1,24 @@
+/** One Server-Sent Event. `data` is parsed JSON when it is JSON, otherwise the raw text. */
+export interface HivesSseEvent {
+    event: string;
+    id?: string;
+    data: unknown;
+}
+export interface HivesSseWindowOptions {
+    /** Stop after this many events (1-1000, default 100). */
+    maxEvents?: number;
+    /** Stop after this many seconds (1-15, default 10). The CLI and MCP Hives node transport allows a body 20 s, so a window stays below it. */
+    seconds?: number;
+    signal?: AbortSignal;
+}
+/** A bounded read of an endless stream; `ended` says which bound closed it. */
+export interface HivesSseWindow {
+    events: HivesSseEvent[];
+    ended: 'max_events' | 'time' | 'closed' | 'aborted';
+}
+/**
+ * Read one bounded window of a Server-Sent Events response (for example
+ * `await genesis.raw('hives_stream_deployment_logs', {...})`) and close the connection.
+ * Never buffers the whole body: an SSE stream does not end on its own.
+ */
+export declare function hivesSseWindow(response: Response, options?: HivesSseWindowOptions): Promise<HivesSseWindow>;