@frockbot/plugin-composio 0.0.0 → 0.1.1

package/src/dependency-coordination.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test } from "bun:test";
+import type { ConnectionView } from "@frockbot/configuration-core";
+import {
+  acknowledgeDependentAssignment,
+  claimDependentAssignment,
+  compensateDependentAssignment,
+  releaseDependentAssignment,
+} from "./dependency-coordination.js";
+
+function assignmentConnection(): ConnectionView {
+  return {
+    connectionId: "connection-1",
+    packageId: "composio",
+    connectionTypeId: "gmail",
+    displayName: "Gmail",
+    state: "ready",
+    safeMetadata: {},
+  };
+}
+
+describe("Connection dependency coordination", () => {
+  test("records intent before acknowledgement and rejects revocation races", () => {
+    const claimed = claimDependentAssignment(
+      assignmentConnection(),
+      "bot-1",
+      "generation-1",
+    );
+    expect(claimed?.safeMetadata.dependentAssignments).toEqual([
+      { botId: "bot-1", generation: "generation-1", status: "pending" },
+    ]);
+    expect(
+      acknowledgeDependentAssignment(claimed!, "bot-1", "generation-1")
+        ?.safeMetadata.dependentAssignments,
+    ).toEqual([
+      {
+        botId: "bot-1",
+        generation: "generation-1",
+        status: "acknowledged",
+      },
+    ]);
+    expect(
+      claimDependentAssignment(
+        {
+          ...assignmentConnection(),
+          state: "revoking",
+          safeMetadata: {
+            ...assignmentConnection().safeMetadata,
+            revocationRequested: true,
+          },
+        },
+        "bot-1",
+        "generation-1",
+      ),
+    ).toBeUndefined();
+  });
+
+  test("keeps two same-Bot Assignment generations independent on one Connection", () => {
+    const acknowledged = {
+      ...assignmentConnection(),
+      state: "ready" as const,
+      safeMetadata: {
+        dependentAssignments: [
+          {
+            botId: "bot-1",
+            generation: "generation-1",
+            status: "acknowledged",
+          },
+        ],
+      },
+    };
+    const claimed = claimDependentAssignment(
+      acknowledged,
+      "bot-1",
+      "generation-2",
+    );
+
+    expect(claimed?.safeMetadata.dependentAssignments).toEqual([
+      {
+        botId: "bot-1",
+        generation: "generation-1",
+        status: "acknowledged",
+      },
+      { botId: "bot-1", generation: "generation-2", status: "pending" },
+    ]);
+    expect(
+      compensateDependentAssignment(claimed!, "bot-1", "generation-2")
+        ?.safeMetadata.dependentAssignments,
+    ).toEqual([
+      {
+        botId: "bot-1",
+        generation: "generation-1",
+        status: "acknowledged",
+      },
+    ]);
+    const bothAcknowledged = acknowledgeDependentAssignment(
+      claimed!,
+      "bot-1",
+      "generation-2",
+    );
+    expect(bothAcknowledged?.safeMetadata.dependentAssignments).toEqual([
+      {
+        botId: "bot-1",
+        generation: "generation-1",
+        status: "acknowledged",
+      },
+      {
+        botId: "bot-1",
+        generation: "generation-2",
+        status: "acknowledged",
+      },
+    ]);
+
+    const firstReleased = releaseDependentAssignment(
+      bothAcknowledged!,
+      "bot-1",
+      "generation-1",
+    );
+    expect(firstReleased?.safeMetadata.dependentAssignments).toEqual([
+      {
+        botId: "bot-1",
+        generation: "generation-2",
+        status: "acknowledged",
+      },
+    ]);
+    expect(
+      releaseDependentAssignment(bothAcknowledged!, "bot-1", "generation-2")
+        ?.safeMetadata.dependentAssignments,
+    ).toEqual([
+      {
+        botId: "bot-1",
+        generation: "generation-1",
+        status: "acknowledged",
+      },
+    ]);
+  });
+});

package/src/dependency-coordination.ts

@@ -0,0 +1,140 @@
+import type { ConnectionView } from "@frockbot/configuration-core";
+
+export function claimDependentAssignment(
+  connection: ConnectionView,
+  botId: string,
+  generation: string,
+): ConnectionView | undefined {
+  if (
+    connection.state === "revoking" ||
+    connection.state === "revoked" ||
+    connection.state === "failed" ||
+    connection.safeMetadata.revocationRequested === true
+  ) {
+    return undefined;
+  }
+  if (connection.state !== "ready") {
+    return undefined;
+  }
+  const existing = Array.isArray(connection.safeMetadata.dependentAssignments)
+    ? connection.safeMetadata.dependentAssignments.filter(
+        (candidate) =>
+          candidate &&
+          typeof candidate === "object" &&
+          !Array.isArray(candidate) &&
+          typeof (candidate as Record<string, unknown>).botId === "string",
+      )
+    : [];
+  return {
+    ...connection,
+    safeMetadata: {
+      ...connection.safeMetadata,
+      dependentAssignments: [
+        ...existing.filter(
+          (candidate) =>
+            (candidate as Record<string, unknown>).botId !== botId ||
+            (candidate as Record<string, unknown>).generation !== generation,
+        ),
+        { botId, generation, status: "pending" },
+      ],
+    },
+  };
+}
+
+export function acknowledgeDependentAssignment(
+  connection: ConnectionView,
+  botId: string,
+  generation: string,
+): ConnectionView | undefined {
+  if (
+    connection.state === "revoking" ||
+    connection.state === "revoked" ||
+    connection.safeMetadata.revocationRequested === true
+  ) {
+    return undefined;
+  }
+  const dependencies = Array.isArray(
+    connection.safeMetadata.dependentAssignments,
+  )
+    ? connection.safeMetadata.dependentAssignments
+    : [];
+  let matched = false;
+  const acknowledged = dependencies.map((candidate) => {
+    if (
+      candidate &&
+      typeof candidate === "object" &&
+      !Array.isArray(candidate) &&
+      (candidate as Record<string, unknown>).botId === botId &&
+      (candidate as Record<string, unknown>).generation === generation
+    ) {
+      matched = true;
+      return { ...candidate, status: "acknowledged" };
+    }
+    return candidate;
+  });
+  if (!matched) return undefined;
+  return {
+    ...connection,
+    safeMetadata: {
+      ...connection.safeMetadata,
+      dependentAssignments: acknowledged,
+    },
+  };
+}
+
+export function releaseDependentAssignment(
+  connection: ConnectionView,
+  botId: string,
+  generation: string,
+): ConnectionView | undefined {
+  const dependencies = Array.isArray(
+    connection.safeMetadata.dependentAssignments,
+  )
+    ? connection.safeMetadata.dependentAssignments
+    : [];
+  const remaining = dependencies.filter(
+    (candidate) =>
+      !candidate ||
+      typeof candidate !== "object" ||
+      Array.isArray(candidate) ||
+      (candidate as Record<string, unknown>).botId !== botId ||
+      (candidate as Record<string, unknown>).generation !== generation,
+  );
+  if (remaining.length === dependencies.length) return undefined;
+  return {
+    ...connection,
+    safeMetadata: {
+      ...connection.safeMetadata,
+      dependentAssignments: remaining,
+    },
+  };
+}
+
+export function compensateDependentAssignment(
+  connection: ConnectionView,
+  botId: string,
+  generation: string,
+): ConnectionView | undefined {
+  const dependencies = Array.isArray(
+    connection.safeMetadata.dependentAssignments,
+  )
+    ? connection.safeMetadata.dependentAssignments
+    : [];
+  const remaining = dependencies.filter(
+    (candidate) =>
+      !candidate ||
+      typeof candidate !== "object" ||
+      Array.isArray(candidate) ||
+      (candidate as Record<string, unknown>).botId !== botId ||
+      (candidate as Record<string, unknown>).generation !== generation ||
+      (candidate as Record<string, unknown>).status !== "pending",
+  );
+  if (remaining.length === dependencies.length) return undefined;
+  return {
+    ...connection,
+    safeMetadata: {
+      ...connection.safeMetadata,
+      dependentAssignments: remaining,
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from "./agent.js";
+export * from "./backend.js";
+export * from "./composio-client.js";
+export * from "./connection-recovery.js";
+export * from "./connections.js";
+export * from "./dependency-coordination.js";
+export * from "./provider-reconciliation.js";

package/src/manifest.ts

@@ -0,0 +1,3 @@
+import manifest from "../frockbot.json" with { type: "json" };
+
+export default manifest;

package/src/provider-reconciliation.ts

@@ -0,0 +1,71 @@
+import {
+  ComposioRequestError,
+  type ComposioClient,
+  type ConnectedAccountSummary,
+} from "./composio-client.js";
+
+export type ComposioProviderReconciliationRequest =
+  | {
+      operation: "link";
+      userId: string;
+      providerAlias: string;
+      toolkitSlug: string;
+    }
+  | {
+      operation: "revoke";
+      userId: string;
+      connectedAccountId: string;
+    };
+
+export type ComposioProviderReconciliationResult =
+  | { status: "active"; account: ConnectedAccountSummary }
+  | { status: "failed"; account: ConnectedAccountSummary }
+  | { status: "revoked"; account?: ConnectedAccountSummary }
+  | { status: "absent" }
+  | { status: "pending"; account?: ConnectedAccountSummary };
+
+export function linkReconciliationDisposition(
+  result: ComposioProviderReconciliationResult,
+): "ready" | "pending" | "failed" {
+  if (result.status === "active") return "ready";
+  if (result.status === "pending" || result.status === "absent") {
+    return "pending";
+  }
+  return "failed";
+}
+
+export async function reconcileComposioProviderConnection(
+  client: ComposioClient,
+  request: ComposioProviderReconciliationRequest,
+): Promise<ComposioProviderReconciliationResult> {
+  if (request.operation === "link") {
+    const account = (await client.listConnectedAccounts(request.userId)).find(
+      (candidate) =>
+        candidate.alias === request.providerAlias &&
+        candidate.toolkitSlug === request.toolkitSlug,
+    );
+    if (!account) return { status: "absent" };
+    if (account.status === "ACTIVE") return { status: "active", account };
+    if (account.status === "REVOKED") return { status: "revoked", account };
+    if (account.status === "FAILED" || account.status === "EXPIRED") {
+      return { status: "failed", account };
+    }
+    return { status: "pending", account };
+  }
+
+  let account: ConnectedAccountSummary;
+  try {
+    account = await client.getConnectedAccount(request.connectedAccountId);
+  } catch (error) {
+    if (error instanceof ComposioRequestError && error.status === 404) {
+      return { status: "absent" };
+    }
+    throw error;
+  }
+  if (account.userId !== request.userId) {
+    throw new Error("Composio connected account does not belong to the User");
+  }
+  return account.status === "REVOKED"
+    ? { status: "revoked", account }
+    : { status: "pending", account };
+}