@aeolus-fleet/gateway 0.32.2 → 0.34.0

package/dist/core/slack/gateway-bot.js

@@ -0,0 +1,22 @@
+import { err, ok } from '../shared/result.js';
+import { gatewayBotDescription } from './slack-app.js';
+/**
+ * The fleet's own bot (B5): the one kept, or made now from its manifest and
+ * kept, with the configuration access token given. Slack's refusal is
+ * answered as is, and nothing is kept.
+ */
+export async function gatewayBotOf(deps, made) {
+    const kept = await deps.apps.gatewayBot(made.fleetId);
+    if (kept !== undefined) {
+        return ok(kept);
+    }
+    const description = gatewayBotDescription(made.fleetName, deps.addresses);
+    const app = await deps.slack.makeApp(made.accessToken, description);
+    if (!app.isOk) {
+        return err(app.error);
+    }
+    const bot = { fleetId: made.fleetId, shipId: null, ...app.value, name: description.name, madeAt: deps.clock.now(), installStartedAt: null, bot: null, removedInSlackAt: null };
+    await deps.apps.save(bot);
+    return ok(bot);
+}
+//# sourceMappingURL=gateway-bot.js.map

package/dist/core/slack/gateway-bot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-bot.js","sourceRoot":"","sources":["../../../src/core/slack/gateway-bot.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,GAAG,EAAE,EAAE,EAAe,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAE,qBAAqB,EAAsC,MAAM,gBAAgB,CAAC;AAE3F;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,IAAqI,EACrI,IAAkE;IAElE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACtD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;IAClB,CAAC;IACD,MAAM,WAAW,GAAG,qBAAqB,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IAC1E,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IACpE,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACd,OAAO,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IACD,MAAM,GAAG,GAAa,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,gBAAgB,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAAC;IACzL,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC1B,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;AACjB,CAAC"}

package/dist/core/slack/kept-slack-event.d.ts

@@ -0,0 +1,32 @@
+import type { DeliveryId, FleetId, MessageId, ShipId } from '@aeolus-fleet/common';
+/**
+ * A linked person's message from Slack, kept by Slack's event id until core
+ * stored or refused it (gateway scopes 9.4 step 3, P-B2): the bot's app,
+ * the ship it goes to, the person ship it is sent as, where it was written
+ * in Slack, and the Markdown it is sent as. An answer in the thread under a
+ * posted delivery goes to its sender in reply to its message, and hands the
+ * delivery (9.5 step 4); one written before the gateway kept that
+ * delivery's Slack message is matched to it as it is sent. Once core took
+ * it, only its event id stays, for an hour, to answer Slack's retries.
+ */
+export interface KeptSlackEvent {
+    readonly fleetId: FleetId;
+    readonly eventId: string;
+    readonly appId: string;
+    /** None through the gateway's own bot for an answer in a thread not matched yet: it goes only as an answer. */
+    readonly shipId: ShipId | null;
+    readonly personShipId: ShipId;
+    readonly channel: string;
+    readonly ts: string;
+    readonly threadTs: string | null;
+    readonly markdown: string;
+    readonly inReplyTo: MessageId | null;
+    /** The delivery the message answers, handled once core stored it. */
+    readonly deliveryId: DeliveryId | null;
+    readonly receivedAt: Date;
+    readonly takenAt: Date | null;
+}
+/** How long a taken event's id stays, to answer Slack's retries (at most 3, within about 5 minutes). */
+export declare const TAKEN_KEPT_MS: number;
+/** How long an event core has not taken stays before it is deleted and the person told. */
+export declare const UNTAKEN_KEPT_MS: number;

package/dist/core/slack/kept-slack-event.js

@@ -0,0 +1,5 @@
+/** How long a taken event's id stays, to answer Slack's retries (at most 3, within about 5 minutes). */
+export const TAKEN_KEPT_MS = 60 * 60 * 1000;
+/** How long an event core has not taken stays before it is deleted and the person told. */
+export const UNTAKEN_KEPT_MS = 24 * 60 * 60 * 1000;
+//# sourceMappingURL=kept-slack-event.js.map

package/dist/core/slack/kept-slack-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kept-slack-event.js","sourceRoot":"","sources":["../../../src/core/slack/kept-slack-event.ts"],"names":[],"mappings":"AA8BA,wGAAwG;AACxG,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE5C,2FAA2F;AAC3F,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC"}

package/dist/core/slack/list-exposable.d.ts

@@ -0,0 +1,25 @@
+import type { ShipId } from '@aeolus-fleet/common';
+import type { Actor } from '../actors/authenticate-actor.js';
+import type { ActorCredential, CredentialOf } from '../actors/credential-of.js';
+import { type DomainError } from '../shared/errors.js';
+import { type Result } from '../shared/result.js';
+import type { ProxyShipKinds, SlackApps, SlackShips } from './ports.js';
+export type ListExposable = (input: {
+    actor: Actor;
+    as: ActorCredential;
+}) => Promise<Result<{
+    shipId: ShipId;
+    name: string;
+}[], DomainError<'FLEET_UNAVAILABLE'>>>;
+/**
+ * Use case: the ships Expose a ship… offers (gateway scopes 9.2, P-B3): the
+ * agent ships and outside A2A agents' proxy ships the actor reads, not
+ * retired and not yet bots, by name. Whether the actor manages one is the
+ * fleet's to answer as it is exposed.
+ */
+export declare function createListExposable(deps: {
+    ships: Pick<SlackShips, 'list'>;
+    apps: Pick<SlackApps, 'all'>;
+    proxyShips: ProxyShipKinds;
+    credentialOf: CredentialOf;
+}): ListExposable;

package/dist/core/slack/list-exposable.js

@@ -0,0 +1,32 @@
+import { refuse } from '../shared/errors.js';
+import { ok } from '../shared/result.js';
+/**
+ * Use case: the ships Expose a ship… offers (gateway scopes 9.2, P-B3): the
+ * agent ships and outside A2A agents' proxy ships the actor reads, not
+ * retired and not yet bots, by name. Whether the actor manages one is the
+ * fleet's to answer as it is exposed.
+ */
+export function createListExposable(deps) {
+    return async ({ actor, as }) => {
+        const credential = await deps.credentialOf(actor, as);
+        if (!credential.isOk) {
+            return credential;
+        }
+        const listed = await deps.ships.list(credential.value);
+        if (!listed.isOk) {
+            return refuse('FLEET_UNAVAILABLE', `The fleet did not list its ships: ${listed.error.message}`);
+        }
+        const exposed = new Set((await deps.apps.all(actor.fleetId)).map(({ shipId }) => shipId));
+        const offered = [];
+        for (const ship of listed.value) {
+            if (ship.status === 'retired' || exposed.has(ship.shipId)) {
+                continue;
+            }
+            if (ship.kind === 'agent' || (ship.kind === 'app' && (await deps.proxyShips.kindOf(actor.fleetId, ship.shipId)) === 'a2aAgent')) {
+                offered.push({ shipId: ship.shipId, name: ship.name });
+            }
+        }
+        return ok(offered.sort((first, second) => first.name.localeCompare(second.name)));
+    };
+}
+//# sourceMappingURL=list-exposable.js.map

package/dist/core/slack/list-exposable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-exposable.js","sourceRoot":"","sources":["../../../src/core/slack/list-exposable.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAoB,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,EAAE,EAAe,MAAM,qBAAqB,CAAC;AAKtD;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAA+H;IACjK,OAAO,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE;QAC7B,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACtD,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;YACrB,OAAO,UAAU,CAAC;QACpB,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACvD,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YACjB,OAAO,MAAM,CAAC,mBAAmB,EAAE,qCAAqC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAClG,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;QAC1F,MAAM,OAAO,GAAG,EAAE,CAAC;QACnB,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;YAChC,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC1D,SAAS;YACX,CAAC;YACD,IAAI,IAAI,CAAC,IAAI,KAAK,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,UAAU,CAAC,EAAE,CAAC;gBAChI,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;YACzD,CAAC;QACH,CAAC;QACD,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACpF,CAAC,CAAC;AACJ,CAAC"}

package/dist/core/slack/ports.d.ts

@@ -0,0 +1,287 @@
+import type { FleetId, MessageId, ShipId } from '@aeolus-fleet/common';
+import type { ActorCredential } from '../actors/credential-of.js';
+import type { FleetRefusal } from '../connection/ports.js';
+import type { Result } from '../shared/result.js';
+import type { KeptSlackEvent } from './kept-slack-event.js';
+import type { SlackApp, SlackAppDescription } from './slack-app.js';
+import type { SlackLink } from './slack-link.js';
+import type { SlackPost } from './slack-post.js';
+import type { ConfigurationToken, SlackWorkspace } from './slack-workspace.js';
+/**
+ * Why Slack did not do what the gateway asked: refused, with Slack's own
+ * error code (invalid_refresh_token, token_revoked, ...); rate limited, to
+ * ask again after Retry-After; or no answer came.
+ */
+export type SlackRefusal = {
+    readonly kind: 'refused';
+    readonly error: string;
+} | {
+    readonly kind: 'rateLimited';
+    readonly retryAfterSeconds: number;
+} | {
+    readonly kind: 'unavailable';
+    readonly message: string;
+};
+/** What Slack gives for a new app: its id, its credentials and its install screen. */
+export interface MadeApp {
+    readonly appId: string;
+    readonly clientId: string;
+    readonly clientSecret: string;
+    readonly signingSecret: string;
+    readonly installUrl: string;
+}
+/** What Slack gives for an install: the workspace it went into and the app's bot. */
+export interface Install {
+    readonly appId: string;
+    readonly teamId: string;
+    readonly teamName: string;
+    readonly botToken: string;
+    readonly botUserId: string;
+}
+/** Outbound port: Slack's app management and install calls, as the gateway makes them. */
+export interface SlackTooling {
+    /** Spends the refresh token for the next configuration token (tooling.tokens.rotate), naming the workspace it is of. */
+    rotateConfigurationToken(refreshToken: string): Promise<Result<{
+        token: ConfigurationToken;
+        teamId: string;
+    }, SlackRefusal>>;
+    /** Makes an app from a manifest (apps.manifest.create). */
+    makeApp(accessToken: string, description: SlackAppDescription): Promise<Result<MadeApp, SlackRefusal>>;
+    /** Gives an app the configuration token made its whole manifest anew, as a rename does (apps.manifest.update). */
+    renameApp(accessToken: string, app: {
+        appId: string;
+        description: SlackAppDescription;
+    }): Promise<Result<undefined, SlackRefusal>>;
+    /** Removes an app the configuration token made (apps.manifest.delete). */
+    removeApp(accessToken: string, appId: string): Promise<Result<undefined, SlackRefusal>>;
+    /** Turns the code Slack's install screen sent back into the app's bot token (oauth.v2.access). */
+    completeInstall(install: {
+        clientId: string;
+        clientSecret: string;
+        code: string;
+        redirectUrl: string;
+    }): Promise<Result<Install, SlackRefusal>>;
+}
+/** Outbound port: each fleet's Slack workspace, in the gateway's vault. */
+export interface SlackWorkspaces {
+    find(fleetId: FleetId): Promise<SlackWorkspace | undefined>;
+    /** Every fleet connected to a workspace whose configuration token Slack has not refused: the ones to rotate. */
+    rotatable(): Promise<FleetId[]>;
+    save(workspace: SlackWorkspace): Promise<void>;
+    /**
+     * Runs the change holding the fleet's workspace, and keeps what it
+     * answers: one change at a time spends a single-use refresh token. None
+     * while the fleet is connected to no workspace.
+     */
+    change(fleetId: FleetId, change: (workspace: SlackWorkspace) => Promise<SlackWorkspace>): Promise<SlackWorkspace | undefined>;
+    /** Forgets the fleet's workspace and every app the gateway made in it. */
+    remove(fleetId: FleetId): Promise<void>;
+}
+/** Outbound port: the Slack apps the gateway made, in its vault. */
+export interface SlackApps {
+    /** The gateway's own bot in the fleet's workspace, once made. */
+    gatewayBot(fleetId: FleetId): Promise<SlackApp | undefined>;
+    /** Every app the gateway made in the fleet's workspace. */
+    all(fleetId: FleetId): Promise<SlackApp[]>;
+    find(fleetId: FleetId, appId: string): Promise<SlackApp | undefined>;
+    /** The app by its id alone, as Slack names it in an event; one id is one app across fleets. */
+    findByAppId(appId: string): Promise<SlackApp | undefined>;
+    /** The bot of the ship, once exposed. */
+    ofShip(fleetId: FleetId, shipId: ShipId): Promise<SlackApp | undefined>;
+    save(app: SlackApp): Promise<void>;
+    remove(fleetId: FleetId, appId: string): Promise<void>;
+}
+/** What an install's state names: the app it is for, sealed so Slack's redirect can not be forged or replayed past its expiry. */
+export interface InstallState {
+    readonly fleetId: FleetId;
+    readonly appId: string;
+    readonly expiresAt: Date;
+}
+/** Outbound port: seals an install's state into Slack's install address, and opens it again. */
+export interface InstallStates {
+    seal(state: InstallState): string;
+    /** The state a sealed text holds; none for one the gateway did not seal. */
+    open(sealed: string): InstallState | undefined;
+}
+/** Outbound port: a ship's name as the fleet answers it now, read as the gateway's ship; none when the fleet does not answer. */
+export interface ShipNames {
+    nameOf(fleetId: FleetId, shipId: ShipId): Promise<string | undefined>;
+}
+/** A ship of the fleet as Slack's part of the gateway reads it: what it is, and its statement's summary (0047), none while it states none. */
+export interface ShipToExpose {
+    readonly shipId: ShipId;
+    readonly name: string;
+    readonly kind: 'operator' | 'agent' | 'viewer' | 'person' | 'app' | 'plugin';
+    readonly status: 'awaitingCrew' | 'crewed' | 'retired';
+    readonly summary: string | null;
+}
+/** Outbound port: the fleet's ships as Slack's part of the gateway needs them. */
+export interface SlackShips {
+    /** A ship as the gateway's ship reads it now. */
+    read(fleetId: FleetId, shipId: ShipId): Promise<Result<ShipToExpose, FleetRefusal>>;
+    /** The ships the actor reads (fleet.list as the actor), within its read reach. */
+    list(as: ActorCredential): Promise<Result<Omit<ShipToExpose, 'summary'>[], FleetRefusal>>;
+    /** Whether the actor manages the ship now (fleet.checkManage): OK, or the fleet's refusal, which names the ship. */
+    checkManage(as: ActorCredential, shipId: ShipId): Promise<Result<undefined, FleetRefusal>>;
+}
+/** Outbound port: which outside party a ship is the proxy ship of, if any: an outside MCP server's takes tool calls, not a person's words (P-B3). */
+export interface ProxyShipKinds {
+    kindOf(fleetId: FleetId, shipId: ShipId): Promise<'mcpServer' | 'mcpClient' | 'a2aClient' | 'a2aAgent' | undefined>;
+}
+/** Outbound port: whether Slack signed a request's body at its timestamp with the app's signing secret. */
+export interface SlackSignatures {
+    isSigned(signed: {
+        secret: string;
+        timestamp: string;
+        body: string;
+        signature: string;
+    }): boolean;
+}
+/** Who Sign in with Slack says signed in: the workspace and the user, and the person's name there. */
+export interface SlackIdentity {
+    readonly teamId: string;
+    readonly userId: string;
+    readonly name: string;
+}
+/** Outbound port: Sign in with Slack (OpenID Connect), through the fleet's own bot's app. */
+export interface SlackSignIn {
+    /** Slack's sign-in screen for the app, for the workspace, carrying the state. */
+    authorizeUrl(asked: {
+        clientId: string;
+        redirectUrl: string;
+        state: string;
+        teamId: string;
+    }): string;
+    /** Turns the code Slack's sign-in sent back into who signed in (openid.connect.token). */
+    complete(asked: {
+        clientId: string;
+        clientSecret: string;
+        code: string;
+        redirectUrl: string;
+    }): Promise<Result<SlackIdentity, SlackRefusal>>;
+}
+/** What a link's state names: the account and person ship it is for, in which fleet, sealed until it expires. */
+export interface LinkState {
+    readonly fleetId: FleetId;
+    readonly accountId: string;
+    readonly personShipId: ShipId;
+    readonly expiresAt: Date;
+}
+/** Outbound port: seals a link's state into Slack's sign-in address, and opens it again. */
+export interface LinkStates {
+    seal(state: LinkState): string;
+    open(sealed: string): LinkState | undefined;
+}
+/** Outbound port: the Slack links of each fleet, in the gateway's database. */
+export interface SlackLinks {
+    /** The link of the Slack user in the workspace, in the fleet. */
+    find(fleetId: FleetId, slack: {
+        teamId: string;
+        userId: string;
+    }): Promise<SlackLink | undefined>;
+    ofAccount(fleetId: FleetId, accountId: string): Promise<SlackLink | undefined>;
+    ofPersonShip(fleetId: FleetId, personShipId: ShipId): Promise<SlackLink | undefined>;
+    /** Turns Show everything that waits in Slack on or off for the account's link (B5). */
+    showAll(fleetId: FleetId, shown: {
+        accountId: string;
+        isOn: boolean;
+    }): Promise<void>;
+    /** Keeps a new link; none when the Slack user or the account is linked already, as two links at once find. */
+    add(link: SlackLink): Promise<'added' | 'taken'>;
+    remove(fleetId: FleetId, accountId: string): Promise<void>;
+    /** Stops the account's link, as when the account is disabled. */
+    stop(fleetId: FleetId, stopped: {
+        accountId: string;
+        at: Date;
+    }): Promise<void>;
+}
+/** Outbound port: a bot's posts and reactions in Slack, with its bot token. */
+export interface SlackMessages {
+    /** A message only one person sees, in a conversation (chat.postEphemeral), with a button that opens an address. */
+    postOnlyTo(botToken: string, message: {
+        channel: string;
+        user: string;
+        text: string;
+        button?: {
+            text: string;
+            url: string;
+        };
+    }): Promise<Result<undefined, SlackRefusal>>;
+    /**
+     * A message in a conversation, or a thread of it, with a button per option
+     * to answer (chat.postMessage): the Slack message it is. A press of a
+     * button names the fleet message it shows, so a press is matched before
+     * the gateway keeps the Slack message.
+     */
+    post(botToken: string, message: {
+        messageId: MessageId;
+        channel: string;
+        threadTs: string | null;
+        text: string;
+        buttons: readonly SlackButton[];
+    }): Promise<Result<{
+        channel: string;
+        ts: string;
+    }, SlackRefusal>>;
+    /** A message in a message's thread, everyone in the conversation sees (chat.postMessage). */
+    postInThread(botToken: string, message: {
+        channel: string;
+        threadTs: string;
+        text: string;
+    }): Promise<Result<undefined, SlackRefusal>>;
+    /** A reaction on a message (reactions.add); one already there is no refusal. */
+    react(botToken: string, reaction: {
+        channel: string;
+        ts: string;
+        name: string;
+    }): Promise<Result<undefined, SlackRefusal>>;
+}
+/**
+ * Outbound port: the linked people's messages from Slack, kept until core
+ * takes them (gateway scopes 9.4 step 3); temporary, so nothing builds up.
+ */
+export interface SlackEvents {
+    /** Keeps the event by its fleet and Slack's event id; one kept already, as on Slack's retry, is known and changes nothing. */
+    keep(event: KeptSlackEvent): Promise<'kept' | 'known'>;
+    /**
+     * Hands each event core has not taken yet to send, up to the limit, held
+     * so one gateway instance at a time sends it. An event sent as taken keeps
+     * only its id from then, taken at the time given.
+     */
+    sendDue(send: (event: KeptSlackEvent) => Promise<'taken' | 'later'>, page: {
+        limit: number;
+        at: Date;
+    }): Promise<void>;
+    /** Forgets the ids of the events taken before the time given. */
+    forgetTaken(before: Date): Promise<void>;
+    /** The events core has not taken that were received before the time given. */
+    untakenSince(before: Date): Promise<KeptSlackEvent[]>;
+    remove(fleetId: FleetId, eventId: string): Promise<void>;
+}
+/** A button under a posted question: its option's label, and the option it answers. */
+export interface SlackButton {
+    readonly text: string;
+    readonly option: number;
+}
+/** Outbound port: the fleet messages in Slack, by person ship. */
+export interface SlackPosts {
+    /** Keeps the post by its fleet, person ship and message, as it is now. */
+    save(post: SlackPost): Promise<void>;
+    ofMessage(fleetId: FleetId, post: {
+        personShipId: ShipId;
+        messageId: MessageId;
+    }): Promise<SlackPost | undefined>;
+    /** The latest delivery posted to the person ship in the thread, the thread's first message included. */
+    lastInThread(fleetId: FleetId, thread: {
+        personShipId: ShipId;
+        appId: string;
+        channel: string;
+        threadTs: string;
+    }): Promise<SlackPost | undefined>;
+    /** The person ship's posts of deliveries the gateway did not finish. */
+    unfinished(fleetId: FleetId, personShipId: ShipId): Promise<SlackPost[]>;
+    remove(fleetId: FleetId, post: {
+        personShipId: ShipId;
+        messageId: MessageId;
+    }): Promise<void>;
+}

package/dist/core/slack/ports.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ports.js.map

package/dist/core/slack/ports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports.js","sourceRoot":"","sources":["../../../src/core/slack/ports.ts"],"names":[],"mappings":""}

package/dist/core/slack/read-slack-link.d.ts

@@ -0,0 +1,23 @@
+import type { Actor } from '../actors/authenticate-actor.js';
+import type { SlackApps, SlackLinks, SlackWorkspaces } from './ports.js';
+/** A person's Slack link as the Overview shows it: the workspace, and the Slack name linked, none while unlinked. */
+export interface ShownSlackLink {
+    readonly workspaceName: string;
+    readonly link: {
+        readonly slackName: string;
+        readonly isShowingAll: boolean;
+    } | null;
+}
+export type ReadSlackLink = (input: {
+    actor: Actor;
+}) => Promise<ShownSlackLink | null>;
+/**
+ * Use case: the person's Slack link on the Overview (gateway scopes 9.6),
+ * offered once the fleet's own bot is in the fleet's workspace, which then
+ * has its name; nothing to an account with no person ship in the fleet.
+ */
+export declare function createReadSlackLink(deps: {
+    workspaces: Pick<SlackWorkspaces, 'find'>;
+    apps: Pick<SlackApps, 'gatewayBot'>;
+    links: Pick<SlackLinks, 'ofAccount'>;
+}): ReadSlackLink;

package/dist/core/slack/read-slack-link.js

@@ -0,0 +1,20 @@
+/**
+ * Use case: the person's Slack link on the Overview (gateway scopes 9.6),
+ * offered once the fleet's own bot is in the fleet's workspace, which then
+ * has its name; nothing to an account with no person ship in the fleet.
+ */
+export function createReadSlackLink(deps) {
+    return async ({ actor }) => {
+        if (actor.kind !== 'account' || actor.personShipId === null) {
+            return null;
+        }
+        const workspace = await deps.workspaces.find(actor.fleetId);
+        const bot = await deps.apps.gatewayBot(actor.fleetId);
+        if (workspace === undefined || bot === undefined || bot.bot === null || workspace.teamName === null) {
+            return null;
+        }
+        const link = await deps.links.ofAccount(actor.fleetId, actor.accountId);
+        return { workspaceName: workspace.teamName, link: link === undefined ? null : { slackName: link.slackName, isShowingAll: link.isShowingAll } };
+    };
+}
+//# sourceMappingURL=read-slack-link.js.map

package/dist/core/slack/read-slack-link.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-slack-link.js","sourceRoot":"","sources":["../../../src/core/slack/read-slack-link.ts"],"names":[],"mappings":"AAWA;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAA8H;IAChK,OAAO,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;QACzB,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,YAAY,KAAK,IAAI,EAAE,CAAC;YAC5D,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC5D,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACtD,IAAI,SAAS,KAAK,SAAS,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,CAAC,GAAG,KAAK,IAAI,IAAI,SAAS,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;YACpG,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;QACxE,OAAO,EAAE,aAAa,EAAE,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,EAAE,CAAC;IACjJ,CAAC,CAAC;AACJ,CAAC"}

package/dist/core/slack/read-slack.d.ts

@@ -0,0 +1,42 @@
+import type { ShipId } from '@aeolus-fleet/common';
+import type { Actor } from '../actors/authenticate-actor.js';
+import type { SlackApps, SlackShips, SlackWorkspaces } from './ports.js';
+import { type BotState } from './slack-app.js';
+/**
+ * The Slack page's state (gateway scopes 9.6): connected or not, the
+ * workspace by its name once Slack named it, who connected it, the
+ * configuration token fresh or refused by Slack, the gateway's bot and
+ * each exposed ship's bot.
+ * canChange: whether the actor holds gateway:slack; others read only.
+ */
+export type SlackView = {
+    readonly state: 'notConnected';
+    readonly canChange: boolean;
+} | {
+    readonly state: 'connected';
+    readonly workspace: {
+        readonly teamId: string;
+        readonly name: string | null;
+    };
+    readonly connectedBy: string;
+    readonly connectedAt: Date;
+    readonly tokenState: 'fresh' | 'refused';
+    readonly gatewayBot: 'notMade' | 'made' | 'installed';
+    readonly bots: readonly ShownBot[];
+    readonly canChange: boolean;
+};
+/** An exposed ship's bot, by the ship's id: its name in the fleet now and in Slack, which differ until the gateway renames it there. */
+export interface ShownBot {
+    readonly appId: string;
+    readonly shipId: ShipId;
+    readonly shipName: string;
+    readonly botName: string;
+    readonly state: BotState;
+}
+export type ReadSlack = (actor: Actor) => Promise<SlackView>;
+/** Use case: the fleet's Slack, as the Slack page shows it to the actor. */
+export declare function createReadSlack(deps: {
+    workspaces: Pick<SlackWorkspaces, 'find'>;
+    apps: Pick<SlackApps, 'gatewayBot' | 'all'>;
+    ships: Pick<SlackShips, 'read'>;
+}): ReadSlack;

package/dist/core/slack/read-slack.js

@@ -0,0 +1,35 @@
+import { SLACK_SCOPE } from './connect-slack.js';
+import { botStateOf } from './slack-app.js';
+/** Use case: the fleet's Slack, as the Slack page shows it to the actor. */
+export function createReadSlack(deps) {
+    return async (actor) => {
+        const canChange = actor.scopes.includes(SLACK_SCOPE);
+        const [workspace, bot, apps] = await Promise.all([deps.workspaces.find(actor.fleetId), deps.apps.gatewayBot(actor.fleetId), deps.apps.all(actor.fleetId)]);
+        if (workspace === undefined) {
+            return { state: 'notConnected', canChange };
+        }
+        const bots = await Promise.all(apps.flatMap((app) => {
+            const { shipId } = app;
+            if (shipId === null) {
+                return [];
+            }
+            return [
+                (async () => {
+                    const ship = await deps.ships.read(actor.fleetId, shipId);
+                    return { appId: app.appId, shipId, shipName: ship.isOk ? ship.value.name : app.name, botName: app.name, state: botStateOf(app) };
+                })(),
+            ];
+        }));
+        return {
+            state: 'connected',
+            workspace: { teamId: workspace.teamId, name: workspace.teamName },
+            connectedBy: workspace.connectedBy.name,
+            connectedAt: workspace.connectedAt,
+            tokenState: workspace.isTokenRefused ? 'refused' : 'fresh',
+            gatewayBot: bot === undefined ? 'notMade' : bot.bot === null ? 'made' : 'installed',
+            bots,
+            canChange,
+        };
+    };
+}
+//# sourceMappingURL=read-slack.js.map

package/dist/core/slack/read-slack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-slack.js","sourceRoot":"","sources":["../../../src/core/slack/read-slack.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,OAAO,EAAE,UAAU,EAAiB,MAAM,gBAAgB,CAAC;AAiC3D,4EAA4E;AAC5E,MAAM,UAAU,eAAe,CAAC,IAAiI;IAC/J,OAAO,KAAK,EAAE,KAAK,EAAE,EAAE;QACrB,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QACrD,MAAM,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAC3J,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,CAAC;QAC9C,CAAC;QACD,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,GAAG,CAC5B,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YACnB,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;YACvB,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;gBACpB,OAAO,EAAE,CAAC;YACZ,CAAC;YACD,OAAO;gBACL,CAAC,KAAK,IAAI,EAAE;oBACV,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;oBAC1D,OAAO,EAAE,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBACnI,CAAC,CAAC,EAAE;aACL,CAAC;QACJ,CAAC,CAAC,CACH,CAAC;QACF,OAAO;YACL,KAAK,EAAE,WAAW;YAClB,SAAS,EAAE,EAAE,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,QAAQ,EAAE;YACjE,WAAW,EAAE,SAAS,CAAC,WAAW,CAAC,IAAI;YACvC,WAAW,EAAE,SAAS,CAAC,WAAW;YAClC,UAAU,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO;YAC1D,UAAU,EAAE,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW;YACnF,IAAI;YACJ,SAAS;SACV,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC"}

package/dist/core/slack/remove-bot.d.ts

@@ -0,0 +1,24 @@
+import type { Actor } from '../actors/authenticate-actor.js';
+import type { ActorCredential, CredentialOf } from '../actors/credential-of.js';
+import { type DomainError } from '../shared/errors.js';
+import { type Result } from '../shared/result.js';
+import type { SlackApps, SlackShips, SlackTooling } from './ports.js';
+import { type TakeAccessToken } from './take-access-token.js';
+export type RemoveBot = (input: {
+    actor: Actor;
+    as: ActorCredential;
+    appId: string;
+}) => Promise<Result<undefined, DomainError<'SLACK_SCOPE_NOT_HELD' | 'NO_SUCH_BOT' | 'NOT_REACHABLE' | 'FLEET_UNAVAILABLE' | 'SLACK_NOT_CONNECTED' | 'SLACK_TOKEN_REFUSED' | 'SLACK_UNAVAILABLE'>>>;
+/**
+ * Use case: an actor holding gateway:slack, within manage reach of the ship,
+ * removes the ship's bot after the page's confirm (gateway scopes 9.2): its
+ * app is deleted in Slack, then forgotten. An app Slack refuses to delete is
+ * one it no longer knows.
+ */
+export declare function createRemoveBot(deps: {
+    slack: Pick<SlackTooling, 'removeApp'>;
+    apps: Pick<SlackApps, 'find' | 'remove'>;
+    ships: SlackShips;
+    takeAccessToken: TakeAccessToken;
+    credentialOf: CredentialOf;
+}): RemoveBot;

package/dist/core/slack/remove-bot.js

@@ -0,0 +1,33 @@
+import { refuse } from '../shared/errors.js';
+import { ok } from '../shared/result.js';
+import { SLACK_SCOPE } from './connect-slack.js';
+import { managedShipBot } from './ship-bot.js';
+import { slackUnavailableMessage } from './take-access-token.js';
+/**
+ * Use case: an actor holding gateway:slack, within manage reach of the ship,
+ * removes the ship's bot after the page's confirm (gateway scopes 9.2): its
+ * app is deleted in Slack, then forgotten. An app Slack refuses to delete is
+ * one it no longer knows.
+ */
+export function createRemoveBot(deps) {
+    return async ({ actor, as, appId }) => {
+        if (!actor.scopes.includes(SLACK_SCOPE)) {
+            return refuse('SLACK_SCOPE_NOT_HELD', `Removing a Slack bot needs ${SLACK_SCOPE}`);
+        }
+        const bot = await managedShipBot(deps, { actor, as, appId });
+        if (!bot.isOk) {
+            return bot;
+        }
+        const accessToken = await deps.takeAccessToken(actor.fleetId);
+        if (!accessToken.isOk) {
+            return accessToken;
+        }
+        const removed = await deps.slack.removeApp(accessToken.value, appId);
+        if (!removed.isOk && removed.error.kind !== 'refused') {
+            return refuse('SLACK_UNAVAILABLE', slackUnavailableMessage(removed.error));
+        }
+        await deps.apps.remove(actor.fleetId, appId);
+        return ok(undefined);
+    };
+}
+//# sourceMappingURL=remove-bot.js.map

package/dist/core/slack/remove-bot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-bot.js","sourceRoot":"","sources":["../../../src/core/slack/remove-bot.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAoB,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,EAAE,EAAe,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,uBAAuB,EAAwB,MAAM,wBAAwB,CAAC;AAMvF;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,IAA2K;IACzM,OAAO,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;QACpC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;YACxC,OAAO,MAAM,CAAC,sBAAsB,EAAE,8BAA8B,WAAW,EAAE,CAAC,CAAC;QACrF,CAAC;QACD,MAAM,GAAG,GAAG,MAAM,cAAc,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QAC7D,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YACd,OAAO,GAAG,CAAC;QACb,CAAC;QACD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC9D,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;YACtB,OAAO,WAAW,CAAC;QACrB,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACrE,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YACtD,OAAO,MAAM,CAAC,mBAAmB,EAAE,uBAAuB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;QAC7E,CAAC;QACD,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC7C,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC;IACvB,CAAC,CAAC;AACJ,CAAC"}

package/dist/core/slack/rotate-configuration-tokens.d.ts

@@ -0,0 +1,13 @@
+import type { SlackWorkspaces } from './ports.js';
+import type { TakeAccessToken } from './take-access-token.js';
+export type RotateConfigurationTokens = () => Promise<void>;
+/**
+ * Use case: one pass of the gateway keeping each fleet's configuration
+ * token alive (gateway scopes 9.1): every token Slack has not refused is
+ * taken, which rotates it within its last hour. Run often enough that no
+ * token's 12 hours end between two passes.
+ */
+export declare function createRotateConfigurationTokens(deps: {
+    workspaces: Pick<SlackWorkspaces, 'rotatable'>;
+    takeAccessToken: TakeAccessToken;
+}): RotateConfigurationTokens;