@onesi/genesis 0.1.13 → 0.2.0

package/dist/flocks.d.ts

@@ -1,5 +1,16 @@
 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'>;
 /** Org scope comes from the One account credential verified by the gateway. */
 export declare function flocksModule(client: GenesisClient): {
     readiness: {
@@ -18,6 +29,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;
         }[]>;
         rename: (id: string, nickname: string) => Promise<{
             id: string;
@@ -28,6 +44,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 +75,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 +161,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"][];
@@ -152,4 +222,218 @@ 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;
+        }>;
+        /** 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,6 +1,9 @@
+import { GenesisError } from './errors.js';
 /** 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'),
@@ -8,6 +11,8 @@ export function flocksModule(client) {
         nodes: {
             list: () => client.request('flocks_listNodes'),
             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,6 +32,10 @@ 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 }),
@@ -35,5 +44,55 @@ export function flocksModule(client) {
             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 }),
+            /** 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 new Promise((resolve, reject) => {
+                        const t = setTimeout(resolve, interval);
+                        o.signal?.addEventListener('abort', () => { clearTimeout(t); reject(o.signal.reason ?? new Error('aborted')); }, { once: true });
+                    });
+                }
+            },
+        },
     };
 }