@phosphorco/bb-identity 0.1.0

package/dist/server-runtime.js

@@ -0,0 +1,263 @@
+// @bun
+// model-runtime.ts
+var ID_MAX_LENGTH = 256;
+var ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/;
+function failure(code, message, retry = "never") {
+  return { code, message, retry };
+}
+function ok(value) {
+  return { ok: true, value };
+}
+function err(code, message, retry = "never") {
+  return { ok: false, error: failure(code, message, retry) };
+}
+function isBoundedString(value, maximum = ID_MAX_LENGTH) {
+  return typeof value === "string" && value.length > 0 && value.length <= maximum;
+}
+function idCodec(kind) {
+  return {
+    decode(input) {
+      const valid = kind === "server-session" ? isBoundedString(input, 4096) && !/[\u0000-\u0020\u007f]/.test(input) : isBoundedString(input) && ID_PATTERN.test(input);
+      if (!valid) {
+        return err("invalid-input", `Invalid ${kind} identifier.`);
+      }
+      return ok(input);
+    },
+    encode(value) {
+      return value;
+    }
+  };
+}
+var identityKeyCodec = {
+  decode(input) {
+    if (!isBoundedString(input, 512) || /[\u0000-\u001f\u007f]/.test(input)) {
+      return err("invalid-input", "Invalid identity key.");
+    }
+    return ok(input);
+  },
+  encode(value) {
+    return value;
+  }
+};
+
+// server-runtime.ts
+function sameExpectation(actor, stamp, expectedActor, expectedStamp) {
+  return actor === expectedActor && stamp === expectedStamp ? ok(undefined) : err("stale-context", "The request actor or session changed.", "after-refresh");
+}
+function isPerson(value) {
+  return value.kind === "person" || value.kind === "default-user";
+}
+function freezePerson(input) {
+  return input.kind === "person" ? Object.freeze({ kind: "person", key: input.key, issuer: input.issuer, subject: input.subject }) : Object.freeze({ kind: "default-user", key: input.key, instanceId: input.instanceId });
+}
+function freezeActorReference(input) {
+  return input.kind === "machine" ? Object.freeze({ kind: "machine", key: input.key, instanceId: input.instanceId, hostId: input.hostId }) : freezePerson(input);
+}
+function freezeActor(input) {
+  return Object.freeze({
+    identity: freezeActorReference(input.identity),
+    presentation: Object.freeze({
+      displayName: input.presentation.displayName,
+      handle: input.presentation.handle,
+      avatarUrl: input.presentation.avatarUrl
+    }),
+    evidence: input.evidence
+  });
+}
+function freezeExpected(input) {
+  return Object.freeze({ actor: input.actor, session: input.session });
+}
+function createIdentityServer(options) {
+  const { host } = options;
+  let disposed = false;
+  const dispose = () => {
+    disposed = true;
+  };
+  const commits = {
+    boundary: "same-process-synchronous",
+    validate(target, scope) {
+      if (typeof target !== "object" || target === null || target.intent !== "write" || typeof target.snapshot !== "function" || !(target.signal instanceof AbortSignal)) {
+        return err("invalid-input", "Write target does not have write intent.");
+      }
+      if (disposed || target.signal.aborted)
+        return err("expired", "The request context is no longer live.");
+      const addressIsConcrete = scope.collection.length > 0 && scope.recordId.length > 0 && Number.isInteger(scope.schemaVersion) && scope.schemaVersion >= 0;
+      try {
+        const snapshot = target.snapshot();
+        const capturedActor = snapshot.actor.identity.key;
+        const capturedSubject = snapshot.subject.key;
+        const capturedExpected = snapshot.expected;
+        const capturedFactsAreConsistent = capturedExpected.actor === capturedActor;
+        return addressIsConcrete && scope.instanceId === host.instanceId && scope.pluginId === host.pluginId && capturedFactsAreConsistent && scope.subject === capturedSubject && scope.expected.actor === capturedExpected.actor && scope.expected.session === capturedExpected.session ? ok(undefined) : err("stale-context", "Target does not match this live commit scope.", "after-refresh");
+      } catch {
+        return err("invalid-input", "Write target snapshot is unavailable.");
+      }
+    }
+  };
+  async function issueTarget(live, request, input) {
+    if (request.signal.aborted)
+      return err("expired", "The request context is no longer live.");
+    const currentRequest = live.validate(request.expected);
+    if (!currentRequest.ok)
+      return currentRequest;
+    const actor = freezeActor(request.actor);
+    let subject = freezeActorReference(actor.identity);
+    if (input.selection.kind === "person") {
+      if (input.policy.kind === "self-only")
+        return err("unsupported", "This operation only supports the acting person.");
+      const profiles = await host.directory.getMany({ keys: [input.selection.key] });
+      if (!profiles.ok)
+        return profiles;
+      const found = profiles.value[0];
+      if (!found || found.status !== "found" || !isPerson(found.profile.identity))
+        return err("not-found", "Selected person was not found.");
+      subject = freezePerson(found.profile.identity);
+    }
+    if (input.intent === "write") {
+      const current = sameExpectation(request.actor.identity.key, request.expected.session, input.expected.actor, input.expected.session);
+      if (!current.ok)
+        return current;
+      if (input.expectedSubject !== subject.key)
+        return err("stale-owner", "Selected subject changed.", "after-refresh");
+    }
+    const expected = freezeExpected({ actor: actor.identity.key, session: request.expected.session });
+    const snapshot = Object.freeze({
+      actor,
+      subject,
+      expected
+    });
+    const target = Object.freeze({
+      intent: input.intent,
+      snapshot: () => snapshot,
+      signal: request.signal
+    });
+    return ok(target);
+  }
+  const server = {
+    instanceId: host.instanceId,
+    directory: host.directory,
+    participants: host.participants,
+    history: host.history,
+    commits,
+    session: (context, readOptions) => host.session(context, readOptions),
+    selfProfile: (context, readOptions) => host.selfProfile(context, readOptions),
+    subscribe: (listener) => host.subscribe(listener),
+    async personRequest(context, readOptions) {
+      if (disposed)
+        return err("disposed", "Identity server is disposed.");
+      const opened = await host.openPersonRequest(context, readOptions);
+      if (!opened.ok)
+        return opened;
+      const live = opened.value;
+      let released = false;
+      let request;
+      async function target(input) {
+        return issueTarget(live, request, input);
+      }
+      request = {
+        actor: live.session.actor,
+        expected: { actor: live.session.actor.identity.key, session: live.session.stamp },
+        capabilities: live.session.capabilities,
+        signal: live.signal,
+        target,
+        async send(input, sendOptions) {
+          const valid = live.validate(input.expected);
+          if (!valid.ok)
+            return { status: "rejected", error: valid.error };
+          return host.send(live, input, sendOptions);
+        },
+        async callPlugin(input, callOptions) {
+          const valid = live.validate(request.expected);
+          if (!valid.ok)
+            return valid;
+          try {
+            return input.output.decode(await host.forward(live, input.pluginId, input.method, input.payload));
+          } catch {
+            return err("unavailable", "Destination plugin call failed.", callOptions?.signal?.aborted ? "never" : "after-reconnect");
+          }
+        },
+        dispose() {
+          if (released)
+            return;
+          released = true;
+          live.release();
+        }
+      };
+      return ok(request);
+    },
+    toolProvenance: (context) => disposed ? Promise.resolve(err("disposed", "Identity server is disposed.")) : host.readToolProvenance(context),
+    sendExternal: (author, input, readOptions) => disposed ? Promise.resolve({ status: "rejected", error: { code: "disposed", message: "Identity server is disposed.", retry: "never" } }) : host.sendExternal(author, input, readOptions),
+    lookupOperation: (operationId, readOptions) => disposed ? Promise.resolve(err("disposed", "Identity server is disposed.")) : host.lookupOperation(operationId, readOptions),
+    dispose
+  };
+  return server;
+}
+function createIdentityEndpoint(options) {
+  let disposed = false;
+  let stop = null;
+  const dispose = () => {
+    disposed = true;
+    const unsubscribe = stop;
+    stop = null;
+    unsubscribe?.();
+  };
+  const subscribed = options.server.subscribe((event) => {
+    if (disposed)
+      return;
+    try {
+      if (event.kind === "directory") {
+        const keys = event.keys.map((key) => identityKeyCodec.decode(key));
+        options.publish({ kind: "directory", keys: keys.every((key) => key.ok) ? keys.map((key) => key.value) : [], revision: null });
+      } else if (event.kind === "participants") {
+        const ids = event.threadIds.map((id) => idCodec("thread").decode(id));
+        if (ids.every((id) => id.ok))
+          options.publish({ kind: "participants", threadIds: ids.map((id) => id.value) });
+      } else if (event.kind === "session")
+        options.publish(event.reason === undefined ? { kind: "session" } : { kind: "session", reason: event.reason });
+      else if (event.kind === "reconnected" || event.kind === "disconnected")
+        options.publish({ kind: event.kind });
+      else if (event.kind === "disposed") {
+        dispose();
+        options.publish({ kind: "disconnected" });
+      }
+    } catch {}
+  });
+  if (disposed)
+    subscribed();
+  else
+    stop = subscribed;
+  const reject = () => Promise.resolve(err("disposed", "Identity endpoint is disposed."));
+  const fence = async (work) => {
+    try {
+      const result = await work;
+      return disposed ? err("disposed", "Identity endpoint is disposed.") : result;
+    } catch {
+      return err(disposed ? "disposed" : "unavailable", disposed ? "Identity endpoint is disposed." : "Identity endpoint read failed.");
+    }
+  };
+  return {
+    bootstrap(context, readOptions) {
+      return disposed ? reject() : fence(options.server.session(context, readOptions).then(ok));
+    },
+    selfProfile(context, readOptions) {
+      return disposed ? reject() : fence(options.server.selfProfile(context, readOptions));
+    },
+    search(context, input, readOptions) {
+      return disposed ? reject() : fence(options.server.directory.search(input, readOptions));
+    },
+    profiles(context, input, readOptions) {
+      return disposed ? reject() : fence(options.server.directory.getMany(input, readOptions));
+    },
+    participants(context, input, readOptions) {
+      return disposed ? reject() : fence(options.server.participants.list(input, readOptions));
+    },
+    participantPreviews(context, input, readOptions) {
+      return disposed ? reject() : fence(options.server.participants.previews(input, readOptions));
+    },
+    dispose
+  };
+}
+export {
+  createIdentityServer,
+  createIdentityEndpoint
+};