@aeolus-fleet/core 0.0.0 → 0.18.0

package/dist/adapters/trpc/router.js

@@ -0,0 +1,15 @@
+import { consoleRouter } from './console.js';
+import { fleetRouter } from './fleet.js';
+import { installationRouter } from './installation.js';
+import { shipRouter } from './ship.js';
+import { systemRouter } from './system.js';
+import { router } from './trpc.js';
+/** The single API door (ADR 0004). REST and MCP map onto its ship procedures (ship-contract.ts). */
+export const appRouter = router({
+    console: consoleRouter,
+    fleet: fleetRouter,
+    installation: installationRouter,
+    ship: shipRouter,
+    system: systemRouter,
+});
+//# sourceMappingURL=router.js.map

package/dist/adapters/trpc/router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.js","sourceRoot":"","sources":["../../../src/adapters/trpc/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC,oGAAoG;AACpG,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC;IAC9B,OAAO,EAAE,aAAa;IACtB,KAAK,EAAE,WAAW;IAClB,YAAY,EAAE,kBAAkB;IAChC,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,YAAY;CACrB,CAAC,CAAC"}

package/dist/adapters/trpc/ship-contract.d.ts

@@ -0,0 +1,107 @@
+/**
+ * The ship contract as the REST and MCP doors see it (ADR 0004): every
+ * procedure under `ship` in the router, then the fleet actions a ship with
+ * fleet scopes may call, read from the router itself. For each
+ * one: its name, what it says about itself, and the JSON Schema of its input
+ * and output, generated from the procedure's own Zod parsers. A call goes
+ * through the router with the raw input, so its middlewares and its input
+ * parsing run exactly as they do for `/trpc`; the doors hold no logic of
+ * their own.
+ */
+import { type TRPC_ERROR_CODE_KEY } from '@trpc/server';
+import { z } from 'zod';
+import { type LoggedFailure } from '../prisma/failure-log.js';
+import type { Context } from './context.js';
+import { ShipRefusalCode } from './trpc.js';
+type JsonValue = z.infer<ReturnType<typeof z.json>>;
+/** A JSON Schema for an object: what a ship call takes or answers. */
+export interface ObjectSchema {
+    type: 'object';
+    properties: Record<string, Record<string, JsonValue>>;
+    required: string[];
+    [keyword: string]: unknown;
+}
+/** One call of the ship contract, as a door offers it. */
+export interface ShipCall {
+    /** The name agents call it by, the MCP tool's: `send`, `ack`, or `fleet_list` for a fleet action. */
+    name: string;
+    /** Where REST serves it, under `/api/v1`: `/ship/send`, `/fleet/list`. */
+    route: string;
+    /** GET for a query without input, POST with a JSON body for the others. */
+    method: 'GET' | 'POST';
+    /** The procedure's path in the router, such as `ship.send`. */
+    path: string;
+    type: 'query' | 'mutation';
+    /** What it does and its rules, from the procedure's meta, with its example when it has one. */
+    description: string;
+    /** Arguments it takes as they stand, as JSON, when its procedure gives an example. */
+    example?: string;
+    /** How the caller says who it is: the ship secret in the input (`register`), or the crew token. */
+    credential: 'secret' | 'crewToken';
+    /** What it takes, if anything, and whether it may be left out (`receive`). */
+    input?: {
+        schema: ObjectSchema;
+        isRequired: boolean;
+    };
+    /** What it answers: an object, or a list for `fleet_list`. */
+    output: JsonSchema;
+}
+/** A JSON Schema of any shape: what a call answers. */
+export type JsonSchema = Record<string, unknown>;
+/**
+ * Every procedure under `ship`, in the router's order, then the fleet actions.
+ * Built once: the router never changes while the server runs.
+ */
+export declare const SHIP_CALLS: readonly ShipCall[];
+/**
+ * What a caller learns of a call that did not succeed: the code, its HTTP
+ * status and a message it may read. The code is tRPC's, or LEASE_ENDED for a
+ * crew whose ship was released.
+ */
+export interface ShipCallRefusal {
+    code: TRPC_ERROR_CODE_KEY | ShipRefusalCode['code'];
+    httpStatus: number;
+    message: string;
+    /** Only for a server failure: the request's id, under which the server log holds the whole failure. */
+    requestId?: string;
+}
+export type ShipCallResult = {
+    isOk: true;
+    output: unknown;
+} | {
+    isOk: false;
+    refusal: ShipCallRefusal;
+};
+/** Where a failure is logged whole: the request's own logger, which labels it with the request's id. */
+export interface FailureLog {
+    error(details: {
+        path?: string;
+    } & LoggedFailure, message: string): void;
+}
+/** A refusal as a JSON body: its code and message, and for a server failure the request's id. */
+export declare function refusalBody(refusal: ShipCallRefusal): {
+    code: string;
+    message: string;
+    requestId?: string;
+};
+/**
+ * A failure in a door itself, outside any procedure: the log holds it whole,
+ * under the request's id, and the caller learns only that it failed, as for
+ * a procedure's server failure.
+ */
+export declare function unexpectedFailure(thrown: unknown, request: {
+    log: FailureLog;
+    requestId: string;
+}): ShipCallRefusal;
+/**
+ * Calls the procedure with the raw input, as the context's caller. The
+ * credentials in the context are the door's: a bearer crew token for REST, the
+ * `crewToken` argument for MCP. A server failure goes to the log whole, as
+ * `/trpc` logs it; the caller learns only that it failed.
+ */
+export declare function callShip(call: ShipCall, request: {
+    ctx: Context;
+    input: unknown;
+    log: FailureLog;
+}): Promise<ShipCallResult>;
+export {};

package/dist/adapters/trpc/ship-contract.js

@@ -0,0 +1,165 @@
+/**
+ * The ship contract as the REST and MCP doors see it (ADR 0004): every
+ * procedure under `ship` in the router, then the fleet actions a ship with
+ * fleet scopes may call, read from the router itself. For each
+ * one: its name, what it says about itself, and the JSON Schema of its input
+ * and output, generated from the procedure's own Zod parsers. A call goes
+ * through the router with the raw input, so its middlewares and its input
+ * parsing run exactly as they do for `/trpc`; the doors hold no logic of
+ * their own.
+ */
+import { callTRPCProcedure, getTRPCErrorFromUnknown } from '@trpc/server';
+import { getHTTPStatusCodeFromError } from '@trpc/server/http';
+import { z } from 'zod';
+import { failureForLog } from '../prisma/failure-log.js';
+import { appRouter } from './router.js';
+import { INTERNAL_ERROR_MESSAGE, ShipRefusalCode } from './trpc.js';
+const objectSchema = z.looseObject({
+    type: z.literal('object'),
+    properties: z.record(z.string(), z.record(z.string(), z.json())).default({}),
+    required: z.array(z.string()).default([]),
+});
+const metaSchema = z.object({ description: z.string().min(1), example: z.record(z.string(), z.string()).optional() });
+/** A procedure's parser, which must be Zod so its JSON Schema can be generated. */
+function zodParser(parser) {
+    if (!(parser instanceof z.ZodType)) {
+        throw new TypeError('A ship procedure parses its input and output with Zod, so its JSON Schema can be generated');
+    }
+    return parser;
+}
+/** The JSON Schema of a procedure's parser: what it takes (`input`) or what it answers (`output`). */
+function jsonSchemaOf(parser, io) {
+    // JSON Schema 2020-12, the dialect of OpenAPI 3.1 and MCP alike; naming it is left to the document holding it.
+    const schema = { ...z.toJSONSchema(parser, { io }) };
+    delete schema.$schema;
+    return objectSchema.parse(schema);
+}
+/** What a procedure takes: none without an input parser; optional when its parser takes nothing at all. */
+function inputOf(parser) {
+    if (parser === undefined) {
+        return undefined;
+    }
+    const input = zodParser(parser);
+    return { schema: jsonSchemaOf(input, 'input'), isRequired: !input.safeParse(undefined).success };
+}
+/** What a procedure answers, as a JSON Schema of any shape. */
+function outputSchemaOf(parser) {
+    const schema = { ...z.toJSONSchema(parser, { io: 'output' }) };
+    delete schema.$schema;
+    return schema;
+}
+/**
+ * The fleet actions the doors offer a ship with fleet scopes (#85): reading
+ * the fleet and the actions that manage its ships. The router checks the
+ * scope of each; the other fleet procedures stay the console's.
+ */
+const FLEET_ACTIONS = [
+    'list',
+    'ship',
+    'commission',
+    'getStartingPrompt',
+    'release',
+    'recrew',
+    'retire',
+    'ping',
+    'follow',
+    'crewRequest',
+    'removeCrewRequest',
+    'assignCrew',
+    'explainCrewRequest',
+    'reportCrewStatus',
+    'confirmCrewRelease',
+    'assignedCrewRequests',
+];
+/** One procedure as a door offers it, under its tool name and REST route. */
+function callOf(procedure, at) {
+    const { type, inputs, meta } = procedure._def;
+    // The output parser is on the procedure at runtime, though tRPC's types leave it out.
+    const output = 'output' in procedure._def ? procedure._def.output : undefined;
+    const input = inputOf(inputs[0]);
+    const { description, example } = metaSchema.parse(meta);
+    const exampleJson = example === undefined ? undefined : JSON.stringify(example);
+    return {
+        ...at,
+        method: type === 'query' && input === undefined ? 'GET' : 'POST',
+        type,
+        description: exampleJson === undefined ? description : `${description} Example: ${exampleJson}`,
+        ...(exampleJson !== undefined && { example: exampleJson }),
+        input,
+        output: outputSchemaOf(zodParser(output)),
+    };
+}
+/**
+ * Every procedure under `ship`, in the router's order, then the fleet actions.
+ * Built once: the router never changes while the server runs.
+ */
+export const SHIP_CALLS = [
+    ...Object.entries(appRouter.ship).map(([name, procedure]) => callOf(procedure, { name, route: `/ship/${name}`, path: `ship.${name}`, credential: name === 'register' ? 'secret' : 'crewToken' })),
+    ...FLEET_ACTIONS.map((name) => callOf(appRouter.fleet[name], { name: `fleet_${name}`, route: `/fleet/${name}`, path: `fleet.${name}`, credential: 'crewToken' })),
+];
+/** A refusal as a JSON body: its code and message, and for a server failure the request's id. */
+export function refusalBody(refusal) {
+    const { code, message, requestId } = refusal;
+    return requestId === undefined ? { code, message } : { code, message, requestId };
+}
+/**
+ * A failure in a door itself, outside any procedure: the log holds it whole,
+ * under the request's id, and the caller learns only that it failed, as for
+ * a procedure's server failure.
+ */
+export function unexpectedFailure(thrown, request) {
+    const error = getTRPCErrorFromUnknown(thrown);
+    request.log.error(failureForLog(error), 'request failed');
+    return { code: 'INTERNAL_SERVER_ERROR', httpStatus: 500, message: INTERNAL_ERROR_MESSAGE, requestId: request.requestId };
+}
+/**
+ * What a caller reads of an error. A refusal keeps its code and message, an
+ * input that does not parse reads as one line per problem and field, then the
+ * call's example when it has one, and a server failure says only that it
+ * failed, with the request's id, as the router's error formatter does for
+ * `/trpc`.
+ */
+function refusalOf(error, at) {
+    const { call, requestId } = at;
+    const httpStatus = getHTTPStatusCodeFromError(error);
+    if (error.code === 'INTERNAL_SERVER_ERROR') {
+        return { code: error.code, httpStatus, message: INTERNAL_ERROR_MESSAGE, requestId };
+    }
+    const message = error.cause instanceof z.ZodError ? inputRefusalOf(error.cause, call) : error.message;
+    const code = error.cause instanceof ShipRefusalCode ? error.cause.code : error.code;
+    return { code, httpStatus, message };
+}
+/** Input that does not parse: one line per problem and field, then how the call takes it when it has an example. */
+function inputRefusalOf(error, call) {
+    const problems = z.prettifyError(error);
+    return call.example === undefined ? problems : `${problems}\nCall ${call.name} like this: ${call.example}`;
+}
+/**
+ * Calls the procedure with the raw input, as the context's caller. The
+ * credentials in the context are the door's: a bearer crew token for REST, the
+ * `crewToken` argument for MCP. A server failure goes to the log whole, as
+ * `/trpc` logs it; the caller learns only that it failed.
+ */
+export async function callShip(call, request) {
+    const { ctx, input, log } = request;
+    try {
+        const output = await callTRPCProcedure({
+            router: appRouter,
+            path: call.path,
+            type: call.type,
+            ctx,
+            getRawInput: () => Promise.resolve(input),
+            signal: undefined,
+            batchIndex: 0,
+        });
+        return { isOk: true, output };
+    }
+    catch (thrown) {
+        const error = getTRPCErrorFromUnknown(thrown);
+        if (error.code === 'INTERNAL_SERVER_ERROR') {
+            log.error({ path: call.path, ...failureForLog(error) }, 'procedure failed');
+        }
+        return { isOk: false, refusal: refusalOf(error, { call, requestId: ctx.requestId }) };
+    }
+}
+//# sourceMappingURL=ship-contract.js.map

package/dist/adapters/trpc/ship-contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ship-contract.js","sourceRoot":"","sources":["../../../src/adapters/trpc/ship-contract.ts"],"names":[],"mappings":"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"}

package/dist/adapters/trpc/ship-protocol.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The ship protocol: how a session crewing a ship uses the ship calls, and
+ * when. The MCP server sends it as its instructions when a client connects,
+ * and the OpenAPI spec opens with it, so both doors state it in one text
+ * (ADR 0004). It is one of three layers, and none repeats another: the
+ * starting prompt says which ship the session crews, this says how to crew
+ * it, and each call's description (ship.ts) states that call's own rules.
+ */
+export declare const SHIP_PROTOCOL: string;

package/dist/adapters/trpc/ship-protocol.js

@@ -0,0 +1,25 @@
+import { PING_CONTENT_TYPE } from '@aeolus-fleet/common';
+/**
+ * The ship protocol: how a session crewing a ship uses the ship calls, and
+ * when. The MCP server sends it as its instructions when a client connects,
+ * and the OpenAPI spec opens with it, so both doors state it in one text
+ * (ADR 0004). It is one of three layers, and none repeats another: the
+ * starting prompt says which ship the session crews, this says how to crew
+ * it, and each call's description (ship.ts) states that call's own rules.
+ */
+export const SHIP_PROTOCOL = [
+    'Aeolus carries messages between ships. You crew one of them.',
+    '',
+    '1. Call register once at the start, with your location and harness. Keep the crew token; every other call needs it.',
+    '2. Loop: receive, then ack each delivery. Act only if the ack succeeded.',
+    '3. To answer, send to its senderName with inReplyTo set to its messageId.',
+    '4. Every send states the model you are running now.',
+    '5. If the content is over 64 KB, send where it lives (a path, a URL, a PR link), not the content itself.',
+    `6. A ping (${PING_CONTENT_TYPE}): call pong with its deliveryId instead of ack. Don't act on it and don't reply.`,
+    '7. Report your status when it changes.',
+    '8. While you wait for an answer, keep receiving. An empty receive only means nothing has arrived yet.',
+    '9. When your work is done and you expect no answer, end your turn. Anything that arrives later waits for you.',
+    '10. Deregister only when this session ends for good, never between tasks.',
+    '11. LEASE_ENDED while passing your crew token: your ship was released. Stop calling the fleet and say so.',
+].join('\n');
+//# sourceMappingURL=ship-protocol.js.map

package/dist/adapters/trpc/ship-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ship-protocol.js","sourceRoot":"","sources":["../../../src/adapters/trpc/ship-protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEzD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,8DAA8D;IAC9D,EAAE;IACF,qHAAqH;IACrH,0EAA0E;IAC1E,2EAA2E;IAC3E,qDAAqD;IACrD,0GAA0G;IAC1G,cAAc,iBAAiB,mFAAmF;IAClH,wCAAwC;IACxC,uGAAuG;IACvG,+GAA+G;IAC/G,2EAA2E;IAC3E,2GAA2G;CAC5G,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC"}

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

@@ -0,0 +1,209 @@
+/**
+ * Ship procedures: the ship contract. `register` takes the ship's id and
+ * secret and returns a crew token; every later call carries that token as
+ * `Authorization: Bearer` (ADR 0015), or as the `crewToken` argument of an MCP
+ * tool. REST and MCP map onto these (ship-contract.ts).
+ *
+ * Each description speaks to the agent crewing a ship, who reads it on every
+ * call as an MCP tool or a REST operation: what the call does and its own
+ * rules. When to make each call is the ship protocol's (ship-protocol.ts),
+ * which no description repeats. It names the calls, never the door, since
+ * both doors show it.
+ */
+export declare const shipRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("./context.js").Context;
+    meta: import("./trpc.js").ProcedureMeta;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape | {
+        message: string;
+        data: {
+            requestId: string | undefined;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    /**
+     * Claims the ship for the calling session, which reports where it runs. The
+     * secret travels in the body, never as a bearer; the crew token comes back
+     * once. Only a wrong ship id or secret counts against the client's limit, so
+     * one address can start many sessions (ADR 0015); a client over it is
+     * refused before its secret is even checked.
+     */
+    register: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            shipId: unknown;
+            secret: string;
+            location: {
+                kind: "DEVICE" | "CLOUD" | "SERVER";
+            } | {
+                kind: "OTHER";
+                description: string;
+            };
+            harness: string;
+        };
+        output: {
+            crewToken: string;
+        };
+        meta: import("./trpc.js").ProcedureMeta;
+    }>;
+    /** The caller's ship: id, fleet, name and type. Any caller may ask about itself. */
+    whoami: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            shipId: `shp_${string}`;
+            fleetId: `flt_${string}`;
+            name: string;
+            type: string;
+        };
+        meta: import("./trpc.js").ProcedureMeta;
+    }>;
+    /**
+     * Sends a message from the calling ship, `argo` included, to a selector.
+     * Answers with the message's id only once the message and its delivery are
+     * stored (ADR 0003); a repeat of the idempotency key answers with the
+     * original id.
+     */
+    send: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            selector: {
+                kind: "ship";
+                shipId: unknown;
+            } | {
+                kind: "ship";
+                name: string;
+            } | {
+                kind: "type";
+                type: string;
+            };
+            payload: string;
+            idempotencyKey: string;
+            contentType?: string | undefined;
+            model?: string | undefined;
+            inReplyTo?: unknown;
+        };
+        output: {
+            messageId: `msg_${string}`;
+        };
+        meta: import("./trpc.js").ProcedureMeta;
+    }>;
+    /**
+     * Hands the crew up to `max` deliveries, 1 to 10, one by default: its own
+     * in flight first, then the oldest pending for its ship or its type. Waits
+     * about 25 seconds when none is there, then answers with none. A mutation:
+     * every delivery it returns is claimed.
+     */
+    receive: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            max?: number | undefined;
+        } | undefined;
+        output: {
+            deliveries: {
+                deliveryId: `dlv_${string}`;
+                messageId: `msg_${string}`;
+                senderShipId: `shp_${string}`;
+                senderName: string;
+                senderType: string;
+                recipient: {
+                    kind: "ship";
+                    shipId: `shp_${string}`;
+                } | {
+                    kind: "type";
+                    type: string;
+                };
+                payload: string;
+                contentType: string;
+                model: string | null;
+                inReplyTo: `msg_${string}` | null;
+                sentAt: string;
+                attempts: number;
+            }[];
+        };
+        meta: import("./trpc.js").ProcedureMeta;
+    }>;
+    /** Acknowledges a delivery the ship received: it is done. Acknowledging it again is OK. */
+    ack: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            deliveryId: unknown;
+        };
+        output: Record<string, never>;
+        meta: import("./trpc.js").ProcedureMeta;
+    }>;
+    /**
+     * Answers a ping the ship received: acknowledges it and marks the session
+     * seen at that moment, so the operator sees the ship's model is working.
+     */
+    pong: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            deliveryId: unknown;
+        };
+        output: Record<string, never>;
+        meta: import("./trpc.js").ProcedureMeta;
+    }>;
+    /**
+     * The crew says what it is doing: working, blocked or idle, with a short
+     * note and optionally its details, set whole or merge-patched. A check-in:
+     * an event only when the state, note or details change.
+     */
+    report: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            state: "working" | "blocked" | "idle";
+            note?: string | undefined;
+            details?: Record<string, import("zod").JSONType> | null | undefined;
+            detailsPatch?: Record<string, import("zod").JSONType> | null | undefined;
+        };
+        output: Record<string, never>;
+        meta: import("./trpc.js").ProcedureMeta;
+    }>;
+    /**
+     * The crew's own report whole, details included, and the last report of
+     * the ship's previous crew, read-only. No scope beyond being the crew.
+     */
+    reportLog: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            report: {
+                state: "working" | "blocked" | "idle";
+                note: string | null;
+                reportedAt: string;
+                detailsVersion: number;
+                details: Record<string, import("zod").JSONType> | null;
+            } | null;
+            previousCrew: {
+                state: "working" | "blocked" | "idle";
+                note: string | null;
+                reportedAt: string;
+                detailsVersion: number;
+                details: Record<string, import("zod").JSONType> | null;
+            } | null;
+        };
+        meta: import("./trpc.js").ProcedureMeta;
+    }>;
+    /**
+     * How many deliveries wait for the crew: what its next receive would hand
+     * it. Claims nothing. With waitSeconds (0 to 25) it waits while none does.
+     * A mutation only so that REST takes its body; it changes nothing.
+     */
+    inbox: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            waitSeconds?: number | undefined;
+        } | undefined;
+        output: {
+            waiting: number;
+        };
+        meta: import("./trpc.js").ProcedureMeta;
+    }>;
+    /**
+     * Ends the calling crew's own lease, and with it its crew token: the ship
+     * awaits a new crew, its secret stops working, and what it held in flight
+     * returns to pending for the next crew. Needs only the crew token.
+     */
+    deregister: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: Record<string, never>;
+        meta: import("./trpc.js").ProcedureMeta;
+    }>;
+}>>;