@frockbot/plugin-shell 0.1.3 → 0.1.4

package/src/shared.ts

@@ -7,8 +7,6 @@ import type {
   BotProfile,
   BotProfilePatchV1,
   BotSettingsViewV1,
-  CapabilityAssignmentView,
-  ModelAssignment,
   UserSettingsViewV1,
 } from "@frockbot/configuration-core";
 import type {
@@ -206,19 +204,8 @@ export interface FrockBotWebData {
     namedBy?: BotNameProvenanceV1,
   ): Promise<void>;
   saveBotNotifications(notifications: BotNotificationPolicy): Promise<void>;
-  assignCapability(
-    assignment: Omit<CapabilityAssignmentView, "state">,
-  ): Promise<void>;
-  replaceCapability(
-    assignment: Omit<CapabilityAssignmentView, "state">,
-  ): Promise<void>;
-  unassignCapability(assignmentId: string): Promise<void>;
-  saveBotModel(model: ModelAssignment): Promise<void>;
-  clearBotModel(): Promise<void>;
   loadUserSettings(): Promise<void>;
   saveUserProfile(profile: { name: string; email?: string }): Promise<void>;
-  /** The model every Bot uses unless it overrides it. */
-  saveDefaultModel(model: ModelAssignment | undefined): Promise<void>;
   loadPluginCatalog(): Promise<void>;
   /** Refreshes {@link FrockBotWebData.mcpServers}. */
   loadMcpServers(): Promise<void>;

package/src/backend-assignment.test.ts

@@ -1,161 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  nextAssignmentPhase,
-  requireStoredAssignmentSaga,
-  settleAssignmentSaga,
-  type AssignmentSagaEffects,
-  type StoredAssignmentSaga,
-} from "./backend-assignment.js";
-
-function saga(
-  phase: StoredAssignmentSaga["phase"],
-  input: Partial<StoredAssignmentSaga> = {},
-): StoredAssignmentSaga {
-  return {
-    schemaVersion: 1,
-    commandId: "command-1",
-    commandFingerprint: "configuration-command-v1:test",
-    userId: "user-1",
-    botId: "bot-1",
-    operation: "replacing",
-    assignmentId: "mail",
-    generation: "generation-1",
-    phase,
-    target: {
-      assignmentId: "mail",
-      packageId: "mail",
-      capabilityId: "send",
-      connectionId: "new-connection",
-    },
-    previous: {
-      assignmentId: "mail",
-      packageId: "mail",
-      capabilityId: "send",
-      connectionId: "old-connection",
-      state: "enabled",
-    },
-    previousGeneration: "old-generation",
-    deadlineAt: Date.now() + 60_000,
-    ...input,
-    acceptedReceipt: input.acceptedReceipt ?? {
-      schemaVersion: 1,
-      commandId: "command-1",
-      revision: 0,
-      status: "pending",
-    },
-  };
-}
-
-function effects(log: string[], acknowledge = true): AssignmentSagaEffects {
-  return {
-    acknowledge: () => {
-      log.push("acknowledge");
-      return Promise.resolve(acknowledge);
-    },
-    compensate: () => {
-      log.push("compensate");
-      return Promise.resolve();
-    },
-    release: () => {
-      log.push("release");
-      return Promise.resolve(true);
-    },
-    rejectCommitted: () => {
-      log.push("reject-committed");
-      return Promise.resolve();
-    },
-  };
-}
-
-describe("Assignment saga transitions", () => {
-  test("orders Replace as claim, commit, acknowledge, release", () => {
-    const committed = nextAssignmentPhase(saga("claiming"), "claimed")!;
-    const acknowledged = nextAssignmentPhase(committed, "committed")!;
-    const releasing = nextAssignmentPhase(acknowledged, "acknowledged")!;
-    expect([committed.phase, acknowledged.phase, releasing.phase]).toEqual([
-      "committing",
-      "acknowledging",
-      "releasing",
-    ]);
-    expect(nextAssignmentPhase(releasing, "released")).toBeUndefined();
-  });
-
-  test("finishes a connection-free Assign after commit", () => {
-    expect(
-      nextAssignmentPhase(
-        saga("committing", {
-          operation: "assigning",
-          target: {
-            assignmentId: "clock",
-            packageId: "clock",
-            capabilityId: "time",
-          },
-          previous: undefined,
-          previousGeneration: undefined,
-        }),
-        "committed",
-      ),
-    ).toBeUndefined();
-  });
-
-  test("strictly decodes durable saga state", () => {
-    expect(requireStoredAssignmentSaga(saga("claiming"))).toMatchObject({
-      operation: "replacing",
-      phase: "claiming",
-    });
-    expect(() =>
-      requireStoredAssignmentSaga({ ...saga("claiming"), extra: true }),
-    ).toThrow("invalid fields");
-    const hidden = saga("claiming") as StoredAssignmentSaga & { hidden?: true };
-    Object.defineProperty(hidden, "hidden", { value: true });
-    expect(() => requireStoredAssignmentSaga(hidden)).toThrow("invalid fields");
-    expect(() =>
-      requireStoredAssignmentSaga({
-        ...saga("claiming"),
-        [Symbol("extra")]: true,
-      }),
-    ).toThrow("invalid fields");
-    expect(() =>
-      requireStoredAssignmentSaga({
-        ...saga("claiming"),
-        acceptedReceipt: {
-          schemaVersion: 1,
-          commandId: "command-1",
-          revision: 0,
-          status: "applied",
-        },
-      }),
-    ).toThrow("accepted receipt is invalid");
-  });
-
-  test("rejects out-of-order advancement", () => {
-    expect(() => nextAssignmentPhase(saga("claiming"), "released")).toThrow(
-      "cannot apply released while claiming",
-    );
-  });
-
-  test("compensates a claiming saga and rejects an unacknowledged commit", async () => {
-    const compensated: string[] = [];
-    await expect(
-      settleAssignmentSaga(saga("claiming"), effects(compensated)),
-    ).resolves.toBe("compensated");
-    expect(compensated).toEqual(["compensate"]);
-
-    const acknowledged: string[] = [];
-    await expect(
-      settleAssignmentSaga(saga("acknowledging"), effects(acknowledged)),
-    ).resolves.toBe("acknowledged");
-    expect(acknowledged).toEqual(["acknowledge"]);
-
-    const log: string[] = [];
-    await expect(
-      settleAssignmentSaga(saga("acknowledging"), effects(log, false)),
-    ).resolves.toBe("rejected");
-    expect(log).toEqual([
-      "acknowledge",
-      "compensate",
-      "release",
-      "reject-committed",
-    ]);
-  });
-});

package/src/backend-assignment.ts

@@ -1,274 +0,0 @@
-import {
-  decodeConnectionDependencyRequirementV1,
-  decodeModelAssignmentV1,
-  decodeOperationReceiptV1,
-  isPublicIdentifier,
-  type CapabilityAssignmentView,
-  type ConnectionDependencyRequirementV1,
-  type ModelAssignment,
-  type OperationReceiptV1,
-} from "@frockbot/configuration-core";
-
-export type AssignmentOperationKind = "assigning" | "replacing" | "unassigning";
-
-export type AssignmentSagaPhase =
-  "claiming" | "committing" | "acknowledging" | "releasing";
-
-/** Durable Bot-owned coordinator state, separate from its stable Assignment. */
-export interface StoredAssignmentSaga {
-  schemaVersion: 1;
-  commandId: string;
-  commandFingerprint: string;
-  userId: string;
-  botId: string;
-  operation: AssignmentOperationKind;
-  assignmentId: string;
-  generation: string;
-  phase: AssignmentSagaPhase;
-  target?: Omit<CapabilityAssignmentView, "state">;
-  claimDispatched?: boolean;
-  acknowledgeDispatched?: boolean;
-  releaseDispatched?: boolean;
-  targetRequirement?: ConnectionDependencyRequirementV1;
-  previous?: CapabilityAssignmentView;
-  previousGeneration?: string;
-  /**
-   * The Bot model this Assignment carries. It commits inside the saga's commit
-   * phase, so the Connection dependency claim and the model binding are one
-   * durable, idempotent unit rather than two commands that can disagree.
-   */
-  model?: ModelAssignment;
-  /** The Assignment's removal also unbinds the Bot's model. */
-  clearModel?: boolean;
-  deadlineAt: number;
-  acceptedReceipt: OperationReceiptV1;
-  receipt?: OperationReceiptV1;
-}
-
-function exact(
-  value: Record<PropertyKey, unknown>,
-  required: readonly string[],
-  optional: readonly string[] = [],
-): void {
-  const allowed = new Set<PropertyKey>([...required, ...optional]);
-  if (
-    !required.every((key) => Object.hasOwn(value, key)) ||
-    !Reflect.ownKeys(value).every((key) => allowed.has(key))
-  ) {
-    throw new Error("Stored Assignment saga has invalid fields");
-  }
-}
-
-function identifier(value: unknown, label: string): string {
-  if (typeof value !== "string" || !isPublicIdentifier(value)) {
-    throw new Error(`Stored Assignment saga ${label} is invalid`);
-  }
-  return value;
-}
-
-export function requireStoredAssignmentSaga(
-  input: unknown,
-): StoredAssignmentSaga {
-  if (!input || typeof input !== "object" || Array.isArray(input)) {
-    throw new Error("Stored Assignment saga is invalid");
-  }
-  const value = input as Record<PropertyKey, unknown>;
-  exact(
-    value,
-    [
-      "schemaVersion",
-      "commandId",
-      "commandFingerprint",
-      "userId",
-      "botId",
-      "operation",
-      "assignmentId",
-      "generation",
-      "phase",
-      "deadlineAt",
-      "acceptedReceipt",
-    ],
-    [
-      "target",
-      "model",
-      "clearModel",
-      "targetRequirement",
-      "previous",
-      "previousGeneration",
-      "claimDispatched",
-      "acknowledgeDispatched",
-      "releaseDispatched",
-      "receipt",
-    ],
-  );
-  if (
-    value.schemaVersion !== 1 ||
-    (value.operation !== "assigning" &&
-      value.operation !== "replacing" &&
-      value.operation !== "unassigning") ||
-    (value.phase !== "claiming" &&
-      value.phase !== "committing" &&
-      value.phase !== "acknowledging" &&
-      value.phase !== "releasing") ||
-    typeof value.deadlineAt !== "number" ||
-    !Number.isFinite(value.deadlineAt)
-  ) {
-    throw new Error("Stored Assignment saga is invalid");
-  }
-  for (const key of [
-    "claimDispatched",
-    "acknowledgeDispatched",
-    "releaseDispatched",
-    "clearModel",
-  ] as const) {
-    if (value[key] !== undefined && typeof value[key] !== "boolean") {
-      throw new Error(`Stored Assignment saga ${key} is invalid`);
-    }
-  }
-  const target = (candidate: unknown, state: boolean) => {
-    if (
-      !candidate ||
-      typeof candidate !== "object" ||
-      Array.isArray(candidate)
-    ) {
-      throw new Error("Stored Assignment saga target is invalid");
-    }
-    const item = candidate as Record<PropertyKey, unknown>;
-    exact(
-      item,
-      state
-        ? ["assignmentId", "packageId", "capabilityId", "state"]
-        : ["assignmentId", "packageId", "capabilityId"],
-      ["connectionId"],
-    );
-    if (
-      state &&
-      item.state !== "enabled" &&
-      item.state !== "disabled" &&
-      item.state !== "unavailable"
-    ) {
-      throw new Error("Stored Assignment saga target state is invalid");
-    }
-    return {
-      assignmentId: identifier(item.assignmentId, "assignmentId"),
-      packageId: identifier(item.packageId, "packageId"),
-      capabilityId: identifier(item.capabilityId, "capabilityId"),
-      connectionId:
-        item.connectionId === undefined
-          ? undefined
-          : identifier(item.connectionId, "connectionId"),
-      ...(state
-        ? { state: item.state as CapabilityAssignmentView["state"] }
-        : {}),
-    };
-  };
-  const acceptedReceipt = decodeOperationReceiptV1(value.acceptedReceipt);
-  if (
-    acceptedReceipt.status !== "pending" ||
-    acceptedReceipt.commandId !== value.commandId
-  ) {
-    throw new Error("Stored Assignment saga accepted receipt is invalid");
-  }
-  return {
-    schemaVersion: 1,
-    commandId: identifier(value.commandId, "commandId"),
-    commandFingerprint:
-      typeof value.commandFingerprint === "string" &&
-      value.commandFingerprint.length <= 2_000
-        ? value.commandFingerprint
-        : (() => {
-            throw new Error("Stored Assignment saga fingerprint is invalid");
-          })(),
-    userId: identifier(value.userId, "userId"),
-    botId: identifier(value.botId, "botId"),
-    operation: value.operation,
-    assignmentId: identifier(value.assignmentId, "assignmentId"),
-    generation: identifier(value.generation, "generation"),
-    phase: value.phase,
-    target:
-      value.target === undefined
-        ? undefined
-        : (target(value.target, false) as Omit<
-            CapabilityAssignmentView,
-            "state"
-          >),
-    model:
-      value.model === undefined
-        ? undefined
-        : decodeModelAssignmentV1(value.model),
-    clearModel: value.clearModel as boolean | undefined,
-    targetRequirement:
-      value.targetRequirement === undefined
-        ? undefined
-        : decodeConnectionDependencyRequirementV1(value.targetRequirement),
-    previous:
-      value.previous === undefined
-        ? undefined
-        : (target(value.previous, true) as CapabilityAssignmentView),
-    previousGeneration:
-      value.previousGeneration === undefined
-        ? undefined
-        : identifier(value.previousGeneration, "previousGeneration"),
-    claimDispatched: value.claimDispatched as boolean | undefined,
-    acknowledgeDispatched: value.acknowledgeDispatched as boolean | undefined,
-    releaseDispatched: value.releaseDispatched as boolean | undefined,
-    deadlineAt: value.deadlineAt,
-    acceptedReceipt,
-    receipt:
-      value.receipt === undefined
-        ? undefined
-        : decodeOperationReceiptV1(value.receipt),
-  };
-}
-
-export function nextAssignmentPhase(
-  saga: StoredAssignmentSaga,
-  event: "claimed" | "committed" | "acknowledged" | "released",
-): StoredAssignmentSaga | undefined {
-  if (saga.phase === "claiming" && event === "claimed") {
-    return { ...saga, phase: "committing" };
-  }
-  if (saga.phase === "committing" && event === "committed") {
-    if (saga.target?.connectionId) {
-      return { ...saga, phase: "acknowledging" };
-    }
-    if (saga.previous?.connectionId) {
-      return { ...saga, phase: "releasing" };
-    }
-    return undefined;
-  }
-  if (saga.phase === "acknowledging" && event === "acknowledged") {
-    return saga.previous?.connectionId
-      ? { ...saga, phase: "releasing" }
-      : undefined;
-  }
-  if (saga.phase === "releasing" && event === "released") return undefined;
-  throw new Error(`Assignment saga cannot apply ${event} while ${saga.phase}`);
-}
-
-export type AssignmentSagaSettlement =
-  "acknowledged" | "compensated" | "rejected";
-
-export interface AssignmentSagaEffects {
-  acknowledge(saga: StoredAssignmentSaga): Promise<boolean>;
-  compensate(saga: StoredAssignmentSaga): Promise<void>;
-  release(saga: StoredAssignmentSaga): Promise<boolean>;
-  rejectCommitted(saga: StoredAssignmentSaga): Promise<void>;
-}
-
-export async function settleAssignmentSaga(
-  saga: StoredAssignmentSaga,
-  effects: AssignmentSagaEffects,
-): Promise<AssignmentSagaSettlement> {
-  if (saga.phase === "claiming") {
-    await effects.compensate(saga);
-    return "compensated";
-  }
-  if (await effects.acknowledge(saga)) return "acknowledged";
-  await effects.compensate(saga);
-  if (!(await effects.release(saga))) {
-    throw new Error("Rejected Connection dependency was not released");
-  }
-  await effects.rejectCommitted(saga);
-  return "rejected";
-}