@fungi.computer/oyster 0.4.1 → 0.5.0

package/dist/machine-link/link.js

@@ -4,8 +4,16 @@ import * as Schema from "effect/Schema";
 import { BirdDogMailSchema } from "@fungi.computer/bird-dog/effect";
 import { agentMailAddressSchema, machineAgentOperationSchema, MachineLinkPostUnavailable, } from "@fungi.computer/seam/machine-link-protocol";
 import { machineLinkFenceFactSchema, machineLinkIdentitySchema, machineLinkName, MachineLinkRefused, } from "./authority.js";
+import { machineLinkDisposition } from "./disposition.js";
 import { MachineLinkHost } from "./host.js";
 const pinKey = "machine-link:identity";
+function isRetainedRelayFence(target, relay, fence) {
+    return (relay.teamId === target.teamId &&
+        relay.deviceId !== target.deviceId &&
+        fence !== null &&
+        fence.teamId === relay.teamId &&
+        fence.deviceId === relay.deviceId);
+}
 /**
  * One device's link inside its own Durable Object. The host's DO class
  * delegates every entry point here. Identity is pinned on the first live
@@ -60,6 +68,12 @@ export function createMachineLink(state, options) {
         })(envelope.event);
         return { address, mail: body };
     };
+    const deliverUndeliverable = async (identity, rawOriginal, rawReply) => {
+        const checked = machineLinkDisposition(identity, rawOriginal, rawReply);
+        if (checked === undefined)
+            return "refused";
+        return await authority.deliverUndeliverable(identity, checked.original, checked.reply);
+    };
     /**
      * The link's own sender check, whatever the host answered: the facts must
      * name the caller and actor it saw, a hosted caller must be hosted, and a
@@ -94,6 +108,8 @@ export function createMachineLink(state, options) {
         if (envelope.kind !== "agentMail")
             return "refused";
         const { address, mail: body } = mail(envelope);
+        if (body.from.kind !== "agent")
+            return "refused";
         const caller = {
             kind: "device",
             deviceId: identity.deviceId,
@@ -118,6 +134,7 @@ export function createMachineLink(state, options) {
             replay: openReplayStore,
             directory: () => authority.directory(identity),
             receive: (_device, envelope) => receive(identity, envelope),
+            disposition: (original, reply) => deliverUndeliverable(identity, original, reply),
             scheduleWake: (at) => state.storage.setAlarm(at),
             report: options.report,
         }));
@@ -149,16 +166,45 @@ export function createMachineLink(state, options) {
                 return "refused";
             const { address, mail: body } = mail(envelope);
             const facts = await checkedTarget(device, caller, agentId, null);
+            const senderMatches = body.from.kind === "agent" && body.from.agentId === facts.callerAgentId;
+            const systemOfflineDisposition = body.from.kind === "system" &&
+                body.reply?.outcome === "undeliverable" &&
+                body.reply.reason === "recipient_offline" &&
+                body.to.agentId === facts.targetAgentId;
             if (facts.targetHome.kind !== "machine" ||
                 facts.targetHome.deviceId !== device.deviceId ||
                 envelope.key !== body.key ||
                 address.scopeId !== facts.teamId ||
                 address.agentId !== facts.targetAgentId ||
                 body.to.agentId !== facts.targetAgentId ||
-                body.from.agentId !== facts.callerAgentId)
+                (!senderMatches && !systemOfflineDisposition))
                 return "refused";
             return await hostFor(device).deliver(device.deviceId, envelope);
         },
+        /** A relay's typed terminal reply to an Agent homed on this device. */
+        async deliverRelayDisposition(input, relayInput, original, reply) {
+            const device = await current(input);
+            const relay = machineLinkIdentitySchema.parse(relayInput);
+            const retainedRelay = await authority.currentFence(relay);
+            if (!isRetainedRelayFence(device, relay, retainedRelay))
+                return "refused";
+            const checked = machineLinkDisposition(device, original, reply);
+            if (checked === undefined)
+                return "refused";
+            if (!(await authority.verifyRelayDisposition(relay, checked.original, checked.reply)))
+                return "refused";
+            const home = await authority.agentHome(device, checked.reply.address.agentId);
+            if (home?.kind !== "machine" || home.deviceId !== device.deviceId)
+                return "refused";
+            return await hostFor(device).deliver(device.deviceId, checked.reply, {
+                refuseDuplicate: true,
+            });
+        },
+        /** Attest a still-pending disposition in this device's own Post outbox. */
+        async hasStagedDisposition(input, original, reply) {
+            const device = await current(input);
+            return await hostFor(device).hasStagedDisposition(device.deviceId, original, reply);
+        },
         /** One finite Agent operation on this device, returning its receipt. */
         async operation(input, caller, agentId, raw) {
             const device = await current(input);