@onesi/genesis 0.1.13 → 0.2.1

package/dist/flocks.d.ts

@@ -1,5 +1,17 @@
 import type { GenesisClient } from './client.js';
-import type { OperationInput } from './types.js';
+import type { OperationInput, OperationOutput } from './types.js';
+/** Options for account mutations. */
+export interface FlocksWriteOptions {
+    signal?: AbortSignal;
+}
+export interface WaitForJobOptions {
+    intervalMs?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    onUpdate?: (job: FlocksJob) => void;
+}
+export type FlocksJob = OperationOutput<'flocks_getAccountJob'>;
+export type FlocksRun = OperationOutput<'flocks_getRun'>;
 /** Org scope comes from the One account credential verified by the gateway. */
 export declare function flocksModule(client: GenesisClient): {
     readiness: {
@@ -18,7 +30,18 @@ export declare function flocksModule(client: GenesisClient): {
             state: "enrolled" | "revoked";
             last_seen_at: number;
             enrolled_at: number;
+            labels?: {
+                [key: string]: string;
+            };
+            accounts?: import("./index.js").components["schemas"]["Flocks.HeartbeatAccount"][];
+            accounts_supported?: boolean;
         }[]>;
+        /** One node's presence (online, heartbeat age, harnesses) and a page of the runs recorded on it, newest first. */
+        activity: (id: string, query?: Omit<OperationInput<"flocks_getNodeActivity">, "id">) => Promise<{
+            node: import("./index.js").components["schemas"]["Flocks.NodePresence"];
+            items: import("./index.js").components["schemas"]["Flocks.Run"][];
+            next_cursor: string | null;
+        }>;
         rename: (id: string, nickname: string) => Promise<{
             id: string;
             name: string;
@@ -28,6 +51,27 @@ export declare function flocksModule(client: GenesisClient): {
             state: "enrolled" | "revoked";
             last_seen_at: number;
             enrolled_at: number;
+            labels?: {
+                [key: string]: string;
+            };
+            accounts?: import("./index.js").components["schemas"]["Flocks.HeartbeatAccount"][];
+            accounts_supported?: boolean;
+        }>;
+        /** Set an instance nickname and/or labels (the label key `flock` groups instances). */
+        update: (id: string, body: OperationInput<"flocks_renameNode">["body"]) => Promise<{
+            id: string;
+            name: string;
+            nickname: string;
+            platform: string;
+            cpu_count: number;
+            state: "enrolled" | "revoked";
+            last_seen_at: number;
+            enrolled_at: number;
+            labels?: {
+                [key: string]: string;
+            };
+            accounts?: import("./index.js").components["schemas"]["Flocks.HeartbeatAccount"][];
+            accounts_supported?: boolean;
         }>;
         revoke: (id: string) => Promise<{
             id: string;
@@ -38,6 +82,11 @@ export declare function flocksModule(client: GenesisClient): {
             state: "enrolled" | "revoked";
             last_seen_at: number;
             enrolled_at: number;
+            labels?: {
+                [key: string]: string;
+            };
+            accounts?: import("./index.js").components["schemas"]["Flocks.HeartbeatAccount"][];
+            accounts_supported?: boolean;
         }>;
         heartbeat: (id: string, nodeBinding: string) => Promise<{
             accepted: boolean;
@@ -119,6 +168,34 @@ export declare function flocksModule(client: GenesisClient): {
             expiresAtMs: number;
         }>;
     };
+    /** Your recent agent sessions and events; needs a signed-in session (the gateway forwards the human bearer for this read only). */
+    activity: {
+        get: () => Promise<{
+            sessions: ({
+                session_id: string;
+                agent_id?: string;
+                provider: string;
+                title?: string;
+                status: string;
+                roost_url?: string;
+                updated_at: string;
+            } & {
+                [key: string]: unknown;
+            })[];
+            events: ({
+                event_id: string;
+                session_id?: string;
+                provider: string;
+                type: string;
+                text: string;
+                login_url?: string;
+                login_code?: string;
+                created_at: string;
+            } & {
+                [key: string]: unknown;
+            })[];
+        }>;
+    };
     runs: {
         list: (query?: OperationInput<"flocks_listRuns">) => Promise<{
             items: import("./index.js").components["schemas"]["Flocks.Run"][];
@@ -135,7 +212,34 @@ export declare function flocksModule(client: GenesisClient): {
             owner_subject?: string;
             created_at: number;
             updated_at: number;
+            inference_account_id: string | null;
+            account_owner_org: string | null;
+            grantee_org: string | null;
+            run_seconds: number | null;
+        }>;
+        /** Starts a run of an agent (202 Run). `node_id` overrides the agent's pinned node for this run. */
+        create: (agent_id: string, body: OperationInput<"flocks_createRun">["body"], o?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            id: string;
+            agent_id: string;
+            harness: string;
+            node_id: string | null;
+            task: string;
+            state: "pending" | "running" | "completed" | "failed";
+            error_code: string | null;
+            owner_subject?: string;
+            created_at: number;
+            updated_at: number;
+            inference_account_id: string | null;
+            account_owner_org: string | null;
+            grantee_org: string | null;
+            run_seconds: number | null;
         }>;
+        /** Polls a run until it is completed or failed. Rejects with a timeout error after `timeoutMs` (default 30 minutes). */
+        wait: (run_id: string, o?: WaitForJobOptions & {
+            onUpdate?: (run: FlocksRun) => void;
+        }) => Promise<FlocksRun>;
     };
     joinTokens: {
         exchange: (body: OperationInput<"flocks_exchangeJoinToken">["body"]) => Promise<{
@@ -152,4 +256,233 @@ export declare function flocksModule(client: GenesisClient): {
             expires_at: number;
         }>;
     };
+    /** Providers (claude, codex) with the login kinds each supports and plain guidance on which plans fit sharing one login. */
+    providers: {
+        list: () => Promise<{
+            items: import("./index.js").components["schemas"]["Flocks.Provider"][];
+        }>;
+    };
+    /** Inference accounts your org owns, plus accounts granted to it. The service never returns a credential. */
+    accounts: {
+        list: (query?: OperationInput<"flocks_listAccounts">) => Promise<{
+            items: import("./index.js").components["schemas"]["Flocks.Account"][];
+            next_cursor: string | null;
+        }>;
+        create: (body: OperationInput<"flocks_createAccount">["body"], o?: FlocksWriteOptions) => Promise<{
+            id: string;
+            provider: string;
+            label: string;
+            auth_kind: "subscription_oauth" | "api_key";
+            identity: string | null;
+            status: "pending_login" | "active" | "needs_login" | "revoked" | "deleted";
+            owner_org: string;
+            granted: boolean;
+            created_by: string;
+            created_at: number;
+            updated_at: number;
+            bound_instances?: number;
+        }>;
+        get: (id: string) => Promise<{
+            id: string;
+            provider: string;
+            label: string;
+            auth_kind: "subscription_oauth" | "api_key";
+            identity: string | null;
+            status: "pending_login" | "active" | "needs_login" | "revoked" | "deleted";
+            owner_org: string;
+            granted: boolean;
+            created_by: string;
+            created_at: number;
+            updated_at: number;
+            bound_instances?: number;
+        }>;
+        /** Owner only: clears the recorded identity (the next verified switch on one of your own instances records it again). */
+        resetIdentity: (id: string, o?: FlocksWriteOptions) => Promise<{
+            id: string;
+            provider: string;
+            label: string;
+            auth_kind: "subscription_oauth" | "api_key";
+            identity: string | null;
+            status: "pending_login" | "active" | "needs_login" | "revoked" | "deleted";
+            owner_org: string;
+            granted: boolean;
+            created_by: string;
+            created_at: number;
+            updated_at: number;
+            bound_instances?: number;
+        }>;
+        /** Signs the account out of every bound instance, then revokes the credential. Returns { account, job_id }. */
+        delete: (id: string, o?: FlocksWriteOptions) => Promise<{
+            account: import("./index.js").components["schemas"]["Flocks.Account"];
+            job_id: string;
+        }>;
+        /** Starts a login on one of your instances; the device url and code appear on the job item for you only. */
+        login: (id: string, instance_id: string, o?: FlocksWriteOptions) => Promise<{
+            id: string;
+            kind: "login" | "switch" | "logout";
+            state: "running" | "succeeded" | "partial" | "failed";
+            account_id: string | null;
+            provider: string;
+            concurrency: number;
+            force: boolean;
+            totals: {
+                queued: number;
+                dispatched: number;
+                succeeded: number;
+                failed: number;
+                timed_out: number;
+                rolled_back: number;
+                unsupported: number;
+            };
+            items: import("./index.js").components["schemas"]["Flocks.JobItem"][];
+            created_at: number;
+            updated_at: number;
+        }>;
+    };
+    /** Grants let another org bind its own instances to one of your accounts; revoking signs them out at once. */
+    grants: {
+        list: (query?: OperationInput<"flocks_listGrants">) => Promise<{
+            items: import("./index.js").components["schemas"]["Flocks.Grant"][];
+        }>;
+        create: (account_id: string, body: OperationInput<"flocks_createGrant">["body"], o?: FlocksWriteOptions) => Promise<{
+            id: string;
+            account_id: string;
+            owner_org: string;
+            grantee_org: string;
+            status: "active" | "revoked";
+            note: string;
+            created_by: string;
+            created_at: number;
+            revoked_at: number | null;
+        }>;
+        revoke: (grant_id: string, o?: FlocksWriteOptions) => Promise<{
+            grant: import("./index.js").components["schemas"]["Flocks.Grant"];
+            job_id: string | null;
+        }>;
+    };
+    /** Which account each instance runs under, and asynchronous switch and sign-out jobs. */
+    instances: {
+        getAccount: (id: string) => Promise<{
+            instance_id: string;
+            accounts: import("./index.js").components["schemas"]["Flocks.InstanceAccount"][];
+        }>;
+        switchAccount: (id: string, body: OperationInput<"flocks_switchInstanceAccount">["body"], o?: FlocksWriteOptions) => Promise<{
+            id: string;
+            kind: "login" | "switch" | "logout";
+            state: "running" | "succeeded" | "partial" | "failed";
+            account_id: string | null;
+            provider: string;
+            concurrency: number;
+            force: boolean;
+            totals: {
+                queued: number;
+                dispatched: number;
+                succeeded: number;
+                failed: number;
+                timed_out: number;
+                rolled_back: number;
+                unsupported: number;
+            };
+            items: import("./index.js").components["schemas"]["Flocks.JobItem"][];
+            created_at: number;
+            updated_at: number;
+        }>;
+        bulkSwitchAccount: (body: OperationInput<"flocks_bulkSwitchInstanceAccount">["body"], o?: FlocksWriteOptions) => Promise<{
+            id: string;
+            kind: "login" | "switch" | "logout";
+            state: "running" | "succeeded" | "partial" | "failed";
+            account_id: string | null;
+            provider: string;
+            concurrency: number;
+            force: boolean;
+            totals: {
+                queued: number;
+                dispatched: number;
+                succeeded: number;
+                failed: number;
+                timed_out: number;
+                rolled_back: number;
+                unsupported: number;
+            };
+            items: import("./index.js").components["schemas"]["Flocks.JobItem"][];
+            created_at: number;
+            updated_at: number;
+        }>;
+        /** `force` cancels in-flight runs instead of waiting for them. */
+        logout: (id: string, provider: string, force?: boolean, o?: FlocksWriteOptions) => Promise<{
+            id: string;
+            kind: "login" | "switch" | "logout";
+            state: "running" | "succeeded" | "partial" | "failed";
+            account_id: string | null;
+            provider: string;
+            concurrency: number;
+            force: boolean;
+            totals: {
+                queued: number;
+                dispatched: number;
+                succeeded: number;
+                failed: number;
+                timed_out: number;
+                rolled_back: number;
+                unsupported: number;
+            };
+            items: import("./index.js").components["schemas"]["Flocks.JobItem"][];
+            created_at: number;
+            updated_at: number;
+        }>;
+        bulkLogout: (body: OperationInput<"flocks_bulkLogoutInstanceAccount">["body"], o?: FlocksWriteOptions) => Promise<{
+            id: string;
+            kind: "login" | "switch" | "logout";
+            state: "running" | "succeeded" | "partial" | "failed";
+            account_id: string | null;
+            provider: string;
+            concurrency: number;
+            force: boolean;
+            totals: {
+                queued: number;
+                dispatched: number;
+                succeeded: number;
+                failed: number;
+                timed_out: number;
+                rolled_back: number;
+                unsupported: number;
+            };
+            items: import("./index.js").components["schemas"]["Flocks.JobItem"][];
+            created_at: number;
+            updated_at: number;
+        }>;
+    };
+    jobs: {
+        get: (id: string, o?: {
+            signal?: AbortSignal;
+        }) => Promise<{
+            id: string;
+            kind: "login" | "switch" | "logout";
+            state: "running" | "succeeded" | "partial" | "failed";
+            account_id: string | null;
+            provider: string;
+            concurrency: number;
+            force: boolean;
+            totals: {
+                queued: number;
+                dispatched: number;
+                succeeded: number;
+                failed: number;
+                timed_out: number;
+                rolled_back: number;
+                unsupported: number;
+            };
+            items: import("./index.js").components["schemas"]["Flocks.JobItem"][];
+            created_at: number;
+            updated_at: number;
+        }>;
+        /** Sends the pasted sign-in code to a login job that is waiting for it (initiator only). The code is never stored or returned. */
+        submitLoginInput: (id: string, instance_id: string, code: string, o?: FlocksWriteOptions) => Promise<{
+            accepted: true;
+        } & {
+            [key: string]: unknown;
+        }>;
+        /** Polls a job until its state is no longer `running`. Rejects with a timeout error after `timeoutMs` (default 10 minutes). */
+        wait: (id: string, o?: WaitForJobOptions) => Promise<FlocksJob>;
+    };
 };

package/dist/flocks.js

@@ -1,13 +1,30 @@
+import { GenesisError } from './errors.js';
+/** Sleeps `ms`, rejecting early on abort; the abort listener is removed when the timer fires. */
+function pause(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const onAbort = () => { clearTimeout(t); reject(signal.reason ?? new Error('aborted')); };
+        const t = setTimeout(() => { signal?.removeEventListener('abort', onAbort); resolve(); }, ms);
+        if (signal?.aborted)
+            return onAbort();
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
 /** Org scope comes from the One account credential verified by the gateway. */
 export function flocksModule(client) {
     const nodePath = (id) => ({ id });
+    const write = async (id, input, o = {}) => client.request(id, input, o.signal ? { signal: o.signal } : undefined);
+    const getJob = (id, o = {}) => client.request('flocks_getAccountJob', { id }, o.signal ? { signal: o.signal } : undefined);
     return {
         readiness: {
             get: () => client.request('flocks_getEnrollmentReadiness'),
         },
         nodes: {
             list: () => client.request('flocks_listNodes'),
+            /** One node's presence (online, heartbeat age, harnesses) and a page of the runs recorded on it, newest first. */
+            activity: (id, query = {}) => client.request('flocks_getNodeActivity', { id, ...query }),
             rename: (id, nickname) => client.request('flocks_renameNode', { ...nodePath(id), body: { nickname } }),
+            /** Set an instance nickname and/or labels (the label key `flock` groups instances). */
+            update: (id, body) => client.request('flocks_renameNode', { ...nodePath(id), body }),
             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 }),
@@ -27,13 +44,81 @@ export function flocksModule(client) {
             status: (agent_id) => client.request('flocks_getAgentStatus', { agent_id }),
             cancel: (agent_id, idempotency_key) => client.request('flocks_cancelAgent', { agent_id, body: { idempotency_key } }),
         },
+        /** Your recent agent sessions and events; needs a signed-in session (the gateway forwards the human bearer for this read only). */
+        activity: {
+            get: () => client.request('flocks_getActivity'),
+        },
         runs: {
             list: (query = {}) => client.request('flocks_listRuns', query),
             get: (run_id) => client.request('flocks_getRun', { run_id }),
+            /** Starts a run of an agent (202 Run). `node_id` overrides the agent's pinned node for this run. */
+            create: (agent_id, body, o = {}) => client.request('flocks_createRun', { agent_id, body }, o.signal ? { signal: o.signal } : undefined),
+            /** Polls a run until it is completed or failed. Rejects with a timeout error after `timeoutMs` (default 30 minutes). */
+            wait: async (run_id, o = {}) => {
+                const interval = o.intervalMs ?? 2000, deadline = Date.now() + (o.timeoutMs ?? 1_800_000);
+                for (;;) {
+                    const run = await client.request('flocks_getRun', { run_id }, o.signal ? { signal: o.signal } : undefined);
+                    o.onUpdate?.(run);
+                    if (run.state === 'completed' || run.state === 'failed')
+                        return run;
+                    if (Date.now() + interval > deadline)
+                        throw new GenesisError({ status: 0, type: 'timeout', operationId: 'flocks_getRun', message: `Run ${run_id} was still ${run.state} after ${o.timeoutMs ?? 1_800_000} ms; poll runs.get again.` });
+                    await pause(interval, o.signal);
+                }
+            },
         },
         joinTokens: {
             exchange: (body) => client.request('flocks_exchangeJoinToken', { body }),
             create: (ttlSeconds = 600) => client.request('flocks_createJoinToken', { body: { ttl_seconds: ttlSeconds } }),
         },
+        /** Providers (claude, codex) with the login kinds each supports and plain guidance on which plans fit sharing one login. */
+        providers: {
+            list: () => client.request('flocks_listProviders'),
+        },
+        /** Inference accounts your org owns, plus accounts granted to it. The service never returns a credential. */
+        accounts: {
+            list: (query = {}) => client.request('flocks_listAccounts', query),
+            create: (body, o) => write('flocks_createAccount', { body }, o),
+            get: (id) => client.request('flocks_getAccount', { id }),
+            /** Owner only: clears the recorded identity (the next verified switch on one of your own instances records it again). */
+            resetIdentity: (id, o) => write('flocks_resetAccountIdentity', { id }, o),
+            /** Signs the account out of every bound instance, then revokes the credential. Returns { account, job_id }. */
+            delete: (id, o) => write('flocks_deleteAccount', { id }, o),
+            /** Starts a login on one of your instances; the device url and code appear on the job item for you only. */
+            login: (id, instance_id, o) => write('flocks_loginAccount', { id, body: { instance_id } }, o),
+        },
+        /** Grants let another org bind its own instances to one of your accounts; revoking signs them out at once. */
+        grants: {
+            list: (query = {}) => client.request('flocks_listGrants', query),
+            create: (account_id, body, o) => write('flocks_createGrant', { id: account_id, body }, o),
+            revoke: (grant_id, o) => write('flocks_revokeGrant', { grant_id }, o),
+        },
+        /** Which account each instance runs under, and asynchronous switch and sign-out jobs. */
+        instances: {
+            getAccount: (id) => client.request('flocks_getInstanceAccount', { id }),
+            switchAccount: (id, body, o) => write('flocks_switchInstanceAccount', { id, body }, o),
+            bulkSwitchAccount: (body, o) => write('flocks_bulkSwitchInstanceAccount', { body }, o),
+            /** `force` cancels in-flight runs instead of waiting for them. */
+            logout: (id, provider, force, o) => write('flocks_logoutInstanceAccount', { id, body: { provider, ...(force ? { force: true } : {}) } }, o),
+            bulkLogout: (body, o) => write('flocks_bulkLogoutInstanceAccount', { body }, o),
+        },
+        jobs: {
+            get: getJob,
+            /** Sends the pasted sign-in code to a login job that is waiting for it (initiator only). The code is never stored or returned. */
+            submitLoginInput: (id, instance_id, code, o) => write('flocks_submitAccountLoginInput', { id, body: { instance_id, code } }, o),
+            /** Polls a job until its state is no longer `running`. Rejects with a timeout error after `timeoutMs` (default 10 minutes). */
+            wait: async (id, o = {}) => {
+                const interval = o.intervalMs ?? 2000, deadline = Date.now() + (o.timeoutMs ?? 600_000);
+                for (;;) {
+                    const job = await getJob(id, o.signal ? { signal: o.signal } : {});
+                    o.onUpdate?.(job);
+                    if (job.state !== 'running')
+                        return job;
+                    if (Date.now() + interval > deadline)
+                        throw new GenesisError({ status: 0, type: 'timeout', operationId: 'flocks_getAccountJob', message: `Job ${id} was still running after ${o.timeoutMs ?? 600_000} ms; poll jobs.get again.` });
+                    await pause(interval, o.signal);
+                }
+            },
+        },
     };
 }