@aeolus-fleet/gateway 0.0.0-stage → 0.28.0

package/dist/adapters/trpc/router.d.ts

@@ -0,0 +1,606 @@
+import type { Connect } from '../../core/connection/connect.js';
+import type { ReadConnection } from '../../core/connection/read-connection.js';
+import type { DeleteFleet } from '../../core/installation/delete-fleet.js';
+import type { InstallationMode } from '../../core/installation/ports.js';
+import type { ReadFleet } from '../../core/installation/read-fleet.js';
+import type { IsServed } from '../../core/installation/served.js';
+import type { SetFleetEnabled } from '../../core/installation/set-fleet-enabled.js';
+import type { AuthenticateActor } from '../../core/actors/authenticate-actor.js';
+import type { ReadOutsideParties, SetOutsideParties } from '../../core/outside-parties/set-outside-parties.js';
+import type { ApproveParty } from '../../core/parties/approve-party.js';
+import type { CrewParty } from '../../core/parties/crew-party.js';
+import type { ListParties, ReadParty } from '../../core/parties/list-parties.js';
+import type { RetireParty } from '../../core/parties/retire-party.js';
+import type { ChangePartyOwner, ChangePartyScopes } from '../../core/parties/change-party.js';
+import type { MarkTool } from '../../core/mcp-out/mark-tool.js';
+import type { StateParty } from '../../core/mcp-out/state-party.js';
+import type { CheckServer } from '../../core/parties/check-server.js';
+import type { ReadPartyTools } from '../../core/parties/read-party-tools.js';
+import type { RegisterClient } from '../../core/oauth/register-client.js';
+import type { DecideRequest } from '../../core/requests/decide-request.js';
+import type { ListMine } from '../../core/requests/list-mine.js';
+import type { ListToDecide } from '../../core/requests/list-to-decide.js';
+import type { EndSignIns } from '../../core/sign-in/end-sign-ins.js';
+import type { AnswerDelivery } from '../../core/people/answer-delivery.js';
+import type { DoneDelivery } from '../../core/people/done-delivery.js';
+import type { OpenDelivery } from '../../core/people/open-delivery.js';
+import type { ReadInbox } from '../../core/people/read-inbox.js';
+export interface Context {
+    /** The Cookie header the console's server or the gateway's page forwarded. */
+    cookie: string | undefined;
+    /** The crew token a ship sent as its bearer token, if any. */
+    crewToken: string | undefined;
+    authenticateActor: AuthenticateActor;
+    isServed: IsServed;
+    /** The fleet's connection as the gateway holds it, without asking the fleet: what a fleet that is off reads. */
+    heldConnection: ReadConnection;
+    /** The installation token header the caller sent, if any. */
+    installationTokenSent: string | undefined;
+    installation: {
+        mode: InstallationMode;
+        token: string | undefined;
+    };
+    setFleetEnabled: SetFleetEnabled;
+    readFleet: ReadFleet;
+    deleteFleet: DeleteFleet;
+    endSignIns: EndSignIns;
+    readConnection: ReadConnection;
+    connect: Connect;
+    approveParty: ApproveParty;
+    crewParty: CrewParty;
+    listParties: ListParties;
+    retireParty: RetireParty;
+    changePartyOwner: ChangePartyOwner;
+    changePartyScopes: ChangePartyScopes;
+    readParty: ReadParty;
+    checkServer: CheckServer;
+    readPartyTools: ReadPartyTools;
+    stateParty: StateParty;
+    markTool: MarkTool;
+    registerClient: RegisterClient;
+    listToDecide: ListToDecide;
+    listMine: ListMine;
+    decideRequest: DecideRequest;
+    /** A person's own person ship's deliveries; unset where no pagasae signs anyone in. */
+    person?: {
+        readInbox: ReadInbox;
+        openDelivery: OpenDelivery;
+        answerDelivery: AnswerDelivery;
+        doneDelivery: DoneDelivery;
+    };
+    readOutsideParties: ReadOutsideParties;
+    setOutsideParties: SetOutsideParties;
+}
+/** What a caller reads of a failure: nothing of it, so no crew token, secret or query ever leaves; the log holds it whole. */
+export declare const INTERNAL_ERROR_MESSAGE = "Internal error";
+export declare const gatewayRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: Context;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    connection: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: Context;
+        meta: object;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: false;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        /** Whether the gateway is connected to the operator's fleet, as which ship, and the ship it was last connected as. */
+        status: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: {
+                enabled: boolean;
+                state: "not-connected" | "connected";
+                ship: {
+                    shipId: string;
+                    name: string;
+                } | null;
+                lastShipId: string | null;
+            };
+            meta: object;
+        }>;
+        /**
+         * Connects the gateway with its ship's secret, which the console's server
+         * hands over server to server: it registers with it and keeps only the
+         * crew token. Only while not connected, and while the gateway serves the
+         * fleet.
+         */
+        connect: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                shipId: unknown;
+                secret: string;
+            };
+            output: {
+                enabled: boolean;
+                state: "not-connected" | "connected";
+                ship: {
+                    shipId: string;
+                    name: string;
+                } | null;
+                lastShipId: string | null;
+            };
+            meta: object;
+        }>;
+    }>>;
+    parties: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: Context;
+        meta: object;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: false;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        /** The fleet's outside parties, by name, each with its proxy ship's owner and scopes from the fleet, read as the actor. Any actor reads them. */
+        list: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: ({
+                kind: "mcpServer";
+                url: string;
+                credentialKind: "bearer" | "clientCredentials";
+                concurrencyLimit: number;
+                ownerShipId: string | null;
+                scopes: string[] | null;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            } | {
+                kind: "mcpClient";
+                clientId: string;
+                ownerShipId: string | null;
+                scopes: string[] | null;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            })[];
+            meta: object;
+        }>;
+        /** One outside party, as the list shows it. */
+        get: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                name: string;
+            };
+            output: {
+                kind: "mcpServer";
+                url: string;
+                credentialKind: "bearer" | "clientCredentials";
+                concurrencyLimit: number;
+                ownerShipId: string | null;
+                scopes: string[] | null;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            } | {
+                kind: "mcpClient";
+                clientId: string;
+                ownerShipId: string | null;
+                scopes: string[] | null;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            };
+            meta: object;
+        }>;
+        /** An outside MCP server's tools, as the server lists them now, asked with the credential the gateway keeps. Any actor reads them. */
+        tools: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                name: string;
+            };
+            output: {
+                tools: {
+                    name: string;
+                    description?: string | undefined;
+                }[];
+            };
+            meta: object;
+        }>;
+        /**
+         * An actor holding fleet:manage checks an outside MCP server before
+         * approving it (F10): the tools it lists with the credential sent. The
+         * gateway keeps nothing and commissions nothing. A mutation, so the
+         * credential travels in the body, never in a URL.
+         */
+        check: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                url: string;
+                credential: {
+                    kind: "bearer";
+                    token: string;
+                } | {
+                    kind: "clientCredentials";
+                    clientId: string;
+                    clientSecret: string;
+                    issuer: string;
+                    scope?: string | undefined;
+                };
+            };
+            output: {
+                tools: {
+                    name: string;
+                    description?: string | undefined;
+                }[];
+            };
+            meta: object;
+        }>;
+        /**
+         * argo approves an outside MCP server as a party: the gateway commissions
+         * its app proxy ship owned by the owner argo picked, crews it, and keeps
+         * the credential in its vault (interop I-5). A repeat with the same
+         * request id picks up where the last one stopped.
+         */
+        approve: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                requestId: string;
+                name: string;
+                url: string;
+                credential: {
+                    kind: "bearer";
+                    token: string;
+                } | {
+                    kind: "clientCredentials";
+                    clientId: string;
+                    clientSecret: string;
+                    issuer: string;
+                    scope?: string | undefined;
+                };
+                ownerShipId: unknown;
+                concurrencyLimit?: number | undefined;
+            };
+            output: {
+                kind: "mcpServer";
+                url: string;
+                credentialKind: "bearer" | "clientCredentials";
+                concurrencyLimit: number;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            } | {
+                kind: "mcpClient";
+                clientId: string;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            };
+            meta: object;
+        }>;
+        /**
+         * An actor holding fleet:manage retires a party (decision 0056): its proxy
+         * ship is retired in the fleet as the actor, within its manage reach, and
+         * the gateway forgets the party. Adding it again is a new request.
+         */
+        /** An actor holding fleet:owner sets a party's owner: its proxy ship's, in the fleet, as the actor (decision 0056). */
+        changeOwner: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name: string;
+                ownerShipId: unknown;
+            };
+            output: Record<string, never>;
+            meta: object;
+        }>;
+        /** An actor holding scopes:grant grants and revokes a party's scopes, only scopes it holds: every scope its proxy ship holds now (decision 0056). */
+        changeScopes: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name: string;
+                grant: string[];
+                revoke: string[];
+            };
+            output: {
+                scopes: string[];
+            };
+            meta: object;
+        }>;
+        retire: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name: string;
+            };
+            output: Record<string, never>;
+            meta: object;
+        }>;
+        /** argo hands over a new secret, from a new starting prompt in the console, for a proxy ship that awaits crew. */
+        crew: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name: string;
+                secret: string;
+            };
+            output: {
+                kind: "mcpServer";
+                url: string;
+                credentialKind: "bearer" | "clientCredentials";
+                concurrencyLimit: number;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            } | {
+                kind: "mcpClient";
+                clientId: string;
+                name: string;
+                state: "awaitingCrew" | "crewed" | "commissioning";
+                proxyShipId: string | null;
+            };
+            meta: object;
+        }>;
+        /** The gateway states the party's proxy ship anew, from what its server lists now, with argo's marks. */
+        state: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name: string;
+            };
+            output: {
+                capabilities: string[];
+            };
+            meta: object;
+        }>;
+        /** argo marks a party's tool repeatable, or takes the mark off (interop 5.2): kept, then stated at once. */
+        markTool: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name: string;
+                tool: string;
+                isRepeatable: boolean;
+            };
+            output: {
+                capabilities: string[];
+            };
+            meta: object;
+        }>;
+    }>>;
+    people: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: Context;
+        meta: object;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: false;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        /** What waits for the person's own ship, by titles only (Q20). */
+        inbox: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: {
+                waiting: number;
+                deliveries: import("../../core/people/inbox-entry.js").InboxEntry[];
+            };
+            meta: object;
+        }>;
+        /** Opens one delivery, whole; the gateway acknowledges it for them. */
+        open: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                deliveryId: string;
+            };
+            output: import("../../core/people/open-delivery.js").OpenedView;
+            meta: object;
+        }>;
+        /** Answers a delivery they opened, to its sender. */
+        answer: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                deliveryId: string;
+                contentType: string;
+                payload: string;
+            };
+            output: import("../../core/people/opened-of.js").Dealt;
+            meta: object;
+        }>;
+        /** Is done with a delivery they opened, with no answer. */
+        done: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                deliveryId: string;
+            };
+            output: import("../../core/people/opened-of.js").Dealt;
+            meta: object;
+        }>;
+    }>>;
+    requests: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: Context;
+        meta: object;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: false;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        /** The requests the account asked, in any state, the newest first (decision 0056: Your requests). */
+        mine: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: {
+                fleetId: string;
+                requestId: string;
+                subject: {
+                    kind: "client";
+                    clientId: string;
+                    clientName: string;
+                } | {
+                    kind: "server";
+                    url: string;
+                };
+                requesters: {
+                    accountId: string;
+                    personShipId: string | null;
+                }[];
+                askedAt: string;
+                expiresAt: string;
+                state: "pending" | "approving" | "approved" | "denied" | "expired";
+                decidedBy: {
+                    kind: "ship";
+                    shipId: string;
+                } | {
+                    kind: "account";
+                    accountId: string;
+                } | {
+                    kind: "operator" | "viewer";
+                } | null;
+                decidedAt: string | null;
+            }[];
+            meta: object;
+        }>;
+        /** Every open request of the fleet, for an actor holding gateway:approve (decision 0056). */
+        toDecide: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: {
+                fleetId: string;
+                requestId: string;
+                subject: {
+                    kind: "client";
+                    clientId: string;
+                    clientName: string;
+                } | {
+                    kind: "server";
+                    url: string;
+                };
+                requesters: {
+                    accountId: string;
+                    personShipId: string | null;
+                }[];
+                askedAt: string;
+                expiresAt: string;
+                state: "pending" | "approving" | "approved" | "denied" | "expired";
+                decidedBy: {
+                    kind: "ship";
+                    shipId: string;
+                } | {
+                    kind: "account";
+                    accountId: string;
+                } | {
+                    kind: "operator" | "viewer";
+                } | null;
+                decidedAt: string | null;
+            }[];
+            meta: object;
+        }>;
+        /** Decides a pending request as the actor: the first decision counts. */
+        decide: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                requestId: string;
+                decision: {
+                    kind: "deny";
+                } | {
+                    kind: "approve";
+                    party: {
+                        name: string;
+                        ownerShipId: unknown;
+                        scopes: string[];
+                    };
+                    server?: {
+                        credential: {
+                            kind: "bearer";
+                            token: string;
+                        } | {
+                            kind: "clientCredentials";
+                            clientId: string;
+                            clientSecret: string;
+                            issuer: string;
+                            scope?: string | undefined;
+                        };
+                        concurrencyLimit: number;
+                    } | undefined;
+                };
+            };
+            output: {
+                state: "approved" | "denied";
+                party: {
+                    kind: "mcpServer";
+                    url: string;
+                    credentialKind: "bearer" | "clientCredentials";
+                    concurrencyLimit: number;
+                    name: string;
+                    state: "awaitingCrew" | "crewed" | "commissioning";
+                    proxyShipId: string | null;
+                } | {
+                    kind: "mcpClient";
+                    clientId: string;
+                    name: string;
+                    state: "awaitingCrew" | "crewed" | "commissioning";
+                    proxyShipId: string | null;
+                } | null;
+            };
+            meta: object;
+        }>;
+    }>>;
+    outsideParties: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: Context;
+        meta: object;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: false;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        /** Whether the fleet's outside parties are on (interop I-3). */
+        status: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: {
+                isOn: boolean;
+            };
+            meta: object;
+        }>;
+        /** Turns them on or off as an actor holding fleet:network; on in an open network needs its warning confirmed. */
+        set: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                isOn: boolean;
+                isOpenNetworkConfirmed: boolean;
+            };
+            output: {
+                isOn: boolean;
+            };
+            meta: object;
+        }>;
+    }>>;
+    oauth: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: Context;
+        meta: object;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: false;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        /**
+         * argo pre-registers an MCP client for its fleet: its name and redirect
+         * URIs, and whether it keeps a secret. The secret is answered this once.
+         */
+        registerClient: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                name: string;
+                redirectUris: string[];
+                isConfidential: boolean;
+            };
+            output: {
+                clientId: string;
+                clientSecret: string | null;
+            };
+            meta: object;
+        }>;
+    }>>;
+    installation: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: Context;
+        meta: object;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: false;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        /** Switches the gateway on or off for a fleet; off keeps everything of it. A replayed request id answers its first answer. */
+        setEnabled: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                requestId: string;
+                fleetId: unknown;
+                enabled: boolean;
+            };
+            output: {
+                fleetId: string;
+                enabled: boolean;
+            };
+            meta: object;
+        }>;
+        /** Whether the gateway serves the fleet, and whether it is connected to it. */
+        get: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                fleetId: unknown;
+            };
+            output: {
+                enabled: boolean;
+                connected: boolean;
+            };
+            meta: object;
+        }>;
+        /** Forgets everything the gateway holds of the fleet, telling the fleet nothing. A replayed request id answers its first answer. */
+        delete: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                requestId: string;
+                fleetId: unknown;
+            };
+            output: Record<string, never>;
+            meta: object;
+        }>;
+        /** pagasae disabled the account (decision 0055): every sign-in of it in the fleet ends, and its clients' tokens are revoked. Told again, it ends nothing more. */
+        accountDisabled: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                fleetId: unknown;
+                accountId: string;
+            };
+            output: Record<string, never>;
+            meta: object;
+        }>;
+    }>>;
+}>>;
+export type GatewayRouter = typeof gatewayRouter;