@frockbot/cloudflare 0.0.0 → 0.7.292

package/src/bot-capabilities.ts

@@ -0,0 +1,480 @@
+// The loopback CAPABILITIES service binding a Plugin worker sees.
+//
+// Minted once per User with the User as its only prop. Which Turn, Bot and
+// Plugin a call is for arrives on the call as its scope; the Bot Durable Object
+// it is routed to resolves that Turn's authority when it is called and refuses
+// a scope that is not the Turn it is running. So nothing here can go stale in
+// a cached worker, and nothing here can hand out authority the Bot does not
+// hold: the stub is an address, not a snapshot.
+import { WorkerEntrypoint } from "cloudflare:workers";
+import type {
+  IsolateCapabilityListOutcomeV1,
+  IsolateConnectionOutcomeV1,
+  IsolateDeviceCallOutcomeV1,
+  IsolateJevOutcomeV1,
+  IsolateMemoryOutcomeV1,
+  IsolateModelOutcomeV1,
+  IsolateEmailOutcomeV1,
+  IsolateScheduleOutcomeV1,
+  IsolateScopeV1,
+  IsolateSettingsOutcomeV1,
+  IsolateStorageListOutcomeV1,
+  IsolateStorageOutcomeV1,
+  IsolateWorkspaceOutcomeV1,
+  PluginModelTransportOutcomeV1,
+} from "@frockbot/core/contracts";
+import {
+  decodeIsolateCapabilityListV1,
+  decodeIsolateDeviceCallRequestV1,
+  decodeIsolateJevRequestV1,
+  decodeIsolateMemoryReadRequestV1,
+  decodeIsolateMemoryWriteRequestV1,
+  decodeIsolateModelInvocationV1,
+  decodeIsolateEmailRequestV1,
+  decodeIsolateScheduleRequestV1,
+  decodeIsolateScopeV1,
+  decodeIsolateStorageDeleteRequestV1,
+  decodeIsolateStorageGetRequestV1,
+  decodeIsolateStorageListRequestV1,
+  decodeIsolateStoragePutRequestV1,
+  decodeIsolateWorkspaceDeleteRequestV1,
+  decodeIsolateWorkspaceListRequestV1,
+  decodeIsolateWorkspacePathV1,
+  decodeIsolateWorkspaceWriteRequestV1,
+  decodeNormalizedModelRequestV1,
+} from "@frockbot/core/contracts";
+import type { BotCapabilitiesPropsV1 } from "@frockbot/app/isolates/capabilities";
+import type { BotState } from "./bot-state.js";
+
+function unavailable(reason: string): {
+  status: "unavailable";
+  reason: string;
+} {
+  return { status: "unavailable", reason };
+}
+
+export type { BotCapabilitiesPropsV1 };
+
+export interface BotCapabilitiesEnv {
+  BOT_STATES: DurableObjectNamespace<BotState>;
+}
+
+interface BotIsolateRpc {
+  isolateAuthority(input: unknown): Promise<unknown>;
+  isolateInvokeModel(input: unknown): Promise<unknown>;
+  isolateMemoryRead(input: unknown): Promise<IsolateMemoryOutcomeV1>;
+  isolateJevDecide(input: unknown): Promise<IsolateJevOutcomeV1>;
+  isolateMemoryWrite(input: unknown): Promise<IsolateMemoryOutcomeV1>;
+  isolateMemoryForget(input: unknown): Promise<IsolateMemoryOutcomeV1>;
+  isolateWorkspaceRead(input: unknown): Promise<IsolateWorkspaceOutcomeV1>;
+  isolateWorkspaceList(input: unknown): Promise<IsolateWorkspaceOutcomeV1>;
+  isolateWorkspaceStat(input: unknown): Promise<IsolateWorkspaceOutcomeV1>;
+  isolateWorkspaceWrite(input: unknown): Promise<IsolateWorkspaceOutcomeV1>;
+  isolateWorkspaceDelete(input: unknown): Promise<IsolateWorkspaceOutcomeV1>;
+  isolateConnection(input: unknown): Promise<IsolateConnectionOutcomeV1>;
+  isolateModelTransport(input: unknown): Promise<PluginModelTransportOutcomeV1>;
+  isolateSchedule(input: unknown): Promise<IsolateScheduleOutcomeV1>;
+  isolateEmail(input: unknown): Promise<IsolateEmailOutcomeV1>;
+  isolateDeviceCall(input: unknown): Promise<IsolateDeviceCallOutcomeV1>;
+  isolateStorageGet(input: unknown): Promise<IsolateStorageOutcomeV1>;
+  isolateStoragePut(input: unknown): Promise<IsolateStorageOutcomeV1>;
+  isolateStorageDelete(input: unknown): Promise<IsolateStorageOutcomeV1>;
+  isolateStorageList(input: unknown): Promise<IsolateStorageListOutcomeV1>;
+  isolateSettings(input: unknown): Promise<IsolateSettingsOutcomeV1>;
+}
+
+export class BotCapabilities extends WorkerEntrypoint<
+  BotCapabilitiesEnv,
+  BotCapabilitiesPropsV1
+> {
+  /** The Bot the scope names, which is always one of this User's. */
+  private rpc(scope: IsolateScopeV1): BotIsolateRpc {
+    const id = this.env.BOT_STATES.idFromName(
+      `${this.ctx.props.userId}:${scope.botId}`,
+    );
+    return this.env.BOT_STATES.get(id) as unknown as BotIsolateRpc;
+  }
+
+  /**
+   * The envelope every Bot RPC takes. The scope is decoded here — Plugin code
+   * wrote it, through the wrapper — and the User comes from the props, which
+   * Plugin code cannot forge.
+   */
+  private scoped(
+    rawScope: unknown,
+    request: unknown,
+  ): { rpc: BotIsolateRpc; envelope: Record<string, unknown> } {
+    const scope = decodeIsolateScopeV1(rawScope);
+    return {
+      rpc: this.rpc(scope),
+      envelope: {
+        schemaVersion: 1,
+        userId: this.ctx.props.userId,
+        botId: scope.botId,
+        runId: scope.runId,
+        sessionId: scope.sessionId,
+        turnId: scope.turnId,
+        packageId: scope.pluginId,
+        generationId: scope.generationId,
+        request,
+      },
+    };
+  }
+
+  async list(scope: unknown): Promise<IsolateCapabilityListOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(scope, null);
+      return decodeIsolateCapabilityListV1(
+        await rpc.isolateAuthority(envelope),
+      );
+    } catch {
+      return unavailable("capabilities are unavailable");
+    }
+  }
+
+  async invokeModel(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateModelOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeNormalizedModelRequestV1(request),
+      );
+      return decodeIsolateModelInvocationV1(
+        await rpc.isolateInvokeModel(envelope),
+      );
+    } catch {
+      return unavailable("the model request could not be served");
+    }
+  }
+
+  async jevDecide(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateJevOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateJevRequestV1(request),
+      );
+      return await rpc.isolateJevDecide(envelope);
+    } catch (error) {
+      // A malformed request is the Plugin's to fix; say what was wrong.
+      return unavailable(
+        error instanceof Error &&
+          error.message.startsWith("isolate Jev request")
+          ? error.message
+          : "Jev is unavailable",
+      );
+    }
+  }
+
+  async memoryRead(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateMemoryOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateMemoryReadRequestV1(request),
+      );
+      return await rpc.isolateMemoryRead(envelope);
+    } catch {
+      return unavailable("Memory is unavailable");
+    }
+  }
+
+  async memoryWrite(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateMemoryOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateMemoryWriteRequestV1(request),
+      );
+      return await rpc.isolateMemoryWrite(envelope);
+    } catch {
+      return unavailable("Memory is unavailable");
+    }
+  }
+
+  async memoryForget(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateMemoryOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateMemoryWriteRequestV1(request),
+      );
+      return await rpc.isolateMemoryForget(envelope);
+    } catch {
+      return unavailable("Memory is unavailable");
+    }
+  }
+
+  async workspaceRead(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateWorkspaceOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateWorkspacePathV1(request),
+      );
+      return await rpc.isolateWorkspaceRead(envelope);
+    } catch {
+      return unavailable("Workspace is unavailable");
+    }
+  }
+
+  async workspaceList(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateWorkspaceOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateWorkspaceListRequestV1(request),
+      );
+      return await rpc.isolateWorkspaceList(envelope);
+    } catch {
+      return unavailable("Workspace is unavailable");
+    }
+  }
+
+  async workspaceStat(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateWorkspaceOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateWorkspacePathV1(request),
+      );
+      return await rpc.isolateWorkspaceStat(envelope);
+    } catch {
+      return unavailable("Workspace is unavailable");
+    }
+  }
+
+  async workspaceWrite(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateWorkspaceOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateWorkspaceWriteRequestV1(request),
+      );
+      return await rpc.isolateWorkspaceWrite(envelope);
+    } catch {
+      return unavailable("Workspace is unavailable");
+    }
+  }
+
+  async workspaceDelete(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateWorkspaceOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateWorkspaceDeleteRequestV1(request),
+      );
+      return await rpc.isolateWorkspaceDelete(envelope);
+    } catch {
+      return unavailable("Workspace is unavailable");
+    }
+  }
+
+  /**
+   * One credentialed upstream call for a model provider Plugin (ADR 0032).
+   * The ticket is the host's own, minted for the dispatch this call belongs
+   * to; everything else is checked on the Bot object, which is the only
+   * place that holds the Connection and the credential.
+   */
+  async modelTransport(
+    scope: unknown,
+    request: unknown,
+  ): Promise<PluginModelTransportOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(scope, request);
+      return await rpc.isolateModelTransport(envelope);
+    } catch {
+      return {
+        status: "unavailable",
+        reason: "the model transport is unavailable",
+      };
+    }
+  }
+
+  async connection(
+    scope: unknown,
+    connectionId: unknown,
+  ): Promise<IsolateConnectionOutcomeV1> {
+    if (
+      typeof connectionId !== "string" ||
+      connectionId.length === 0 ||
+      connectionId.length > 256
+    ) {
+      return unavailable("the Connection is unavailable");
+    }
+    try {
+      const { rpc, envelope } = this.scoped(scope, connectionId);
+      return await rpc.isolateConnection(envelope);
+    } catch {
+      return unavailable("the Connection is unavailable");
+    }
+  }
+
+  async sendEmail(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateEmailOutcomeV1> {
+    // Decoded outside the call, because a request the kernel refuses and a
+    // deployment that cannot send mail are different facts: a draft naming
+    // something that is not an address is the draft's problem, and answering
+    // it with "unavailable" would tell the person this deployment sends no
+    // mail when it sends mail fine.
+    let decoded;
+    try {
+      decoded = decodeIsolateEmailRequestV1(request);
+    } catch (error) {
+      return unavailable(
+        `this email was refused: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+    let scoped;
+    try {
+      scoped = this.scoped(scope, decoded);
+    } catch {
+      return unavailable("sending email is unavailable");
+    }
+    try {
+      return await scoped.rpc.isolateEmail(scoped.envelope);
+    } catch {
+      // The Durable Object may have claimed the decision and handed the
+      // message over before this call lost its answer. Saying `unavailable`
+      // would tell the Plugin to try again; one decision sends one message.
+      return {
+        status: "unknown",
+        reason:
+          "the message may have been sent: the answer from the sender was lost",
+      };
+    }
+  }
+
+  async deviceCall(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateDeviceCallOutcomeV1> {
+    let scoped;
+    try {
+      scoped = this.scoped(scope, decodeIsolateDeviceCallRequestV1(request));
+    } catch (error) {
+      return {
+        ok: false,
+        outcome: "failed",
+        error: `this device call was refused: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+    try {
+      return await scoped.rpc.isolateDeviceCall(scoped.envelope);
+    } catch {
+      // The Bot's object may have sent the call before this answer was lost.
+      return {
+        ok: false,
+        outcome: "unknown",
+        error:
+          "the answer from the computer was lost; the call may have taken effect",
+      };
+    }
+  }
+
+  async schedule(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateScheduleOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateScheduleRequestV1(request),
+      );
+      return await rpc.isolateSchedule(envelope);
+    } catch {
+      return unavailable("durable scheduling is unavailable");
+    }
+  }
+
+  async storageGet(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateStorageOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateStorageGetRequestV1(request),
+      );
+      return await rpc.isolateStorageGet(envelope);
+    } catch {
+      return unavailable("storage is unavailable");
+    }
+  }
+
+  async storagePut(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateStorageOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateStoragePutRequestV1(request),
+      );
+      return await rpc.isolateStoragePut(envelope);
+    } catch {
+      return unavailable("storage is unavailable");
+    }
+  }
+
+  async storageDelete(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateStorageOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateStorageDeleteRequestV1(request),
+      );
+      return await rpc.isolateStorageDelete(envelope);
+    } catch {
+      return unavailable("storage is unavailable");
+    }
+  }
+
+  async storageList(
+    scope: unknown,
+    request: unknown,
+  ): Promise<IsolateStorageListOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(
+        scope,
+        decodeIsolateStorageListRequestV1(request ?? {}),
+      );
+      return await rpc.isolateStorageList(envelope);
+    } catch {
+      return unavailable("storage is unavailable");
+    }
+  }
+
+  async settings(scope: unknown): Promise<IsolateSettingsOutcomeV1> {
+    try {
+      const { rpc, envelope } = this.scoped(scope, null);
+      return await rpc.isolateSettings(envelope);
+    } catch {
+      return unavailable("settings are unavailable");
+    }
+  }
+}

package/src/bot-recovery.ts

@@ -0,0 +1 @@
+export * from "@frockbot/app/shell/backend-recovery";