@lifesi/genesis 0.1.0 → 0.1.2

package/dist/fleets.js

@@ -3,6 +3,13 @@ const byteLength = (value) => new TextEncoder().encode(value).byteLength;
 const invalid = (operationId, message) => new GenesisError({
     status: 0, type: 'invalid_request', operationId, message,
 });
+function instanceOptions(operation, options) {
+    const key = options.idempotencyKey;
+    if (key !== undefined && (typeof key !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(key))) {
+        throw invalid(operation, 'Idempotency-Key must be one canonical UUID4.');
+    }
+    return { signal: options.signal, ...(key === undefined ? {} : { headers: { 'idempotency-key': key } }) };
+}
 function validateTask(body) {
     if (typeof body?.input !== 'string' || !body.input || byteLength(body.input) > 65536 || body.input.includes('\0')) {
         throw invalid('fleets_submitTask', 'Task input must contain 1–65536 UTF-8 bytes without NUL.');
@@ -19,9 +26,36 @@ function validateKey(apiKey) {
         throw invalid('fleets_setConnection', 'Foundry key must contain 1–4096 UTF-8 bytes without CR, LF or NUL.');
     }
 }
-/** Managed agent tasks, always scoped to the credential's verified organization. */
+const instanceId = (value, operation) => {
+    if (typeof value !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) {
+        throw invalid(operation, 'Invalid Fleets instance ID.');
+    }
+};
+/** Managed Henry instances and tasks scoped to the credential's verified org. */
 export function fleetsModule(client) {
     return {
+        instances: {
+            list: async (query = {}) => {
+                if (query.limit !== undefined && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 50)) {
+                    throw invalid('fleets_listInstances', 'Limit must be 1–50.');
+                }
+                if (query.after !== undefined)
+                    instanceId(query.after, 'fleets_listInstances');
+                return client.request('fleets_listInstances', query);
+            },
+            get: async (instance_id) => {
+                instanceId(instance_id, 'fleets_getInstance');
+                return client.request('fleets_getInstance', { instance_id });
+            },
+            stop: async (instance_id, options = {}) => {
+                instanceId(instance_id, 'fleets_stopInstance');
+                return client.request('fleets_stopInstance', { instance_id }, instanceOptions('fleets_stopInstance', options));
+            },
+            start: async (instance_id, options = {}) => {
+                instanceId(instance_id, 'fleets_startInstance');
+                return client.request('fleets_startInstance', { instance_id }, instanceOptions('fleets_startInstance', options));
+            },
+        },
         connection: {
             get: () => client.request('fleets_getConnection', {}),
             set: async (api_key) => {

package/dist/flocks.d.ts

@@ -0,0 +1,73 @@
+import type { GenesisClient } from './client.js';
+import type { OperationInput } from './types.js';
+/** Org scope comes from the LifeID credential verified by the gateway. */
+export declare function flocksModule(client: GenesisClient): {
+    readiness: {
+        get: () => Promise<{
+            node_enrollment_available: boolean;
+            reason_code?: "node_credential_issuer_unavailable";
+        }>;
+    };
+    nodes: {
+        list: () => Promise<{
+            id: string;
+            name: string;
+            nickname: string;
+            platform: string;
+            cpu_count: number;
+            state: "enrolled" | "revoked";
+            last_seen_at: number;
+            enrolled_at: number;
+        }[]>;
+        rename: (id: string, nickname: string) => Promise<{
+            id: string;
+            name: string;
+            nickname: string;
+            platform: string;
+            cpu_count: number;
+            state: "enrolled" | "revoked";
+            last_seen_at: number;
+            enrolled_at: number;
+        }>;
+        revoke: (id: string) => Promise<{
+            id: string;
+            name: string;
+            nickname: string;
+            platform: string;
+            cpu_count: number;
+            state: "enrolled" | "revoked";
+            last_seen_at: number;
+            enrolled_at: number;
+        }>;
+        heartbeat: (id: string, nodeBinding: string) => Promise<{
+            accepted: boolean;
+        }>;
+        enroll: (body: OperationInput<"flocks_enrollNode">["body"]) => Promise<{
+            node: import("./index.js").components["schemas"]["Flocks.Node"];
+            node_binding: string;
+            heartbeat_interval_seconds: number;
+        }>;
+        activate: (id: string, body: OperationInput<"flocks_activateNode">["body"]) => Promise<{
+            node: import("./index.js").components["schemas"]["Flocks.Node"];
+            activated: boolean;
+        }>;
+        rotateCredential: (id: string, body: OperationInput<"flocks_rotateNodeCredential">["body"]) => Promise<{
+            accepted: boolean;
+        }>;
+    };
+    joinTokens: {
+        exchange: (body: OperationInput<"flocks_exchangeJoinToken">["body"]) => Promise<{
+            node_id: string;
+            organization_id: string;
+            credential_id: string;
+            credential_value: string;
+            scopes: "flocks:node"[];
+            expires_at: string;
+            node_nonce_hash?: string;
+        }>;
+        create: (ttlSeconds?: number) => Promise<{
+            token: string;
+            expires_at: number;
+        }>;
+    };
+};

package/dist/flocks.js

@@ -0,0 +1,22 @@
+/** Org scope comes from the LifeID credential verified by the gateway. */
+export function flocksModule(client) {
+    const nodePath = (id) => ({ id });
+    return {
+        readiness: {
+            get: () => client.request('flocks_getEnrollmentReadiness'),
+        },
+        nodes: {
+            list: () => client.request('flocks_listNodes'),
+            rename: (id, nickname) => client.request('flocks_renameNode', { ...nodePath(id), body: { nickname } }),
+            revoke: (id) => client.request('flocks_revokeNode', nodePath(id)),
+            heartbeat: (id, nodeBinding) => client.request('flocks_heartbeatNode', { ...nodePath(id), body: { node_binding: nodeBinding } }),
+            enroll: (body) => client.request('flocks_enrollNode', { body }),
+            activate: (id, body) => client.request('flocks_activateNode', { id, body }),
+            rotateCredential: (id, body) => client.request('flocks_rotateNodeCredential', { id, body }),
+        },
+        joinTokens: {
+            exchange: (body) => client.request('flocks_exchangeJoinToken', { body }),
+            create: (ttlSeconds = 600) => client.request('flocks_createJoinToken', { body: { ttl_seconds: ttlSeconds } }),
+        },
+    };
+}