@dxos/halo-adapter-client 0.0.0

package/LICENSE

@@ -0,0 +1,105 @@
+# Functional Source License, Version 1.1, ALv2 Future License
+
+## Abbreviation
+
+FSL-1.1-Apache-2.0
+
+## Notice
+
+Copyright 2026 DXOS
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following
+will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

package/README.md

@@ -0,0 +1,21 @@
+# @dxos/halo-adapter-client
+
+Implements the `@dxos/halo` services (`Identity`, `Space`, `Invitation`) as Effect `Layer`s
+backed by a `@dxos/client` instance. This is the composition-root adapter that lets application
+code depend on the `@dxos/halo` service interfaces instead of `@dxos/client` directly.
+
+```ts
+import { layerClient } from '@dxos/halo-adapter-client';
+import { Identity } from '@dxos/halo';
+
+const program = Identity.current;
+Effect.runPromise(Effect.provide(program, layerClient(client)));
+```
+
+## DXOS Resources
+
+- [Website](https://dxos.org)
+- [Developer Documentation](https://docs.dxos.org)
+- Talk to us on [Discord](https://dxos.org/discord)
+
+License: [FSL-1.1-Apache-2.0](./LICENSE) Copyright 2026 © DXOS

package/dist/lib/neutral/index.mjs

@@ -0,0 +1,479 @@
+import "@dxos/node-std/globals";
+
+// src/index.ts
+import * as Layer3 from "effect/Layer";
+
+// src/identity.ts
+import * as Effect2 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Stream2 from "effect/Stream";
+import { InvitationEncoder as InvitationEncoder2 } from "@dxos/client/invitations";
+import { Identity as HaloIdentity, IdentityError } from "@dxos/halo";
+import { IdentityDid } from "@dxos/keys";
+import { DeviceKind } from "@dxos/protocols/proto/dxos/client/services";
+
+// src/util.ts
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { AuthenticatingInvitationObservable, Invitation as ClientInvitation, InvitationEncoder } from "@dxos/client/invitations";
+import { InvitationError } from "@dxos/halo";
+import { SpaceMember } from "@dxos/protocols/proto/dxos/client/services";
+import { SpaceMember as HaloSpaceMember } from "@dxos/protocols/proto/dxos/halo/credentials";
+var streamFromObservable = (observable) => Stream.async((emit) => {
+  const subscription = observable.subscribe((value) => void emit.single(value), (err) => void emit.fail(err));
+  return Effect.sync(() => subscription.unsubscribe());
+}).pipe(Stream.orDie);
+var TERMINAL_STATES = /* @__PURE__ */ new Set([
+  ClientInvitation.State.SUCCESS,
+  ClientInvitation.State.CANCELLED,
+  ClientInvitation.State.TIMEOUT,
+  ClientInvitation.State.ERROR,
+  ClientInvitation.State.EXPIRED
+]);
+var toEvent = (invitation) => {
+  switch (invitation.state) {
+    case ClientInvitation.State.CONNECTING:
+      return {
+        _tag: "connecting"
+      };
+    case ClientInvitation.State.CONNECTED:
+      return {
+        _tag: "connected"
+      };
+    case ClientInvitation.State.READY_FOR_AUTHENTICATION:
+      return {
+        _tag: "readyForAuthentication",
+        authCode: invitation.authCode
+      };
+    case ClientInvitation.State.AUTHENTICATING:
+      return {
+        _tag: "authenticating"
+      };
+    case ClientInvitation.State.SUCCESS:
+      return {
+        _tag: "success",
+        result: {}
+      };
+    case ClientInvitation.State.CANCELLED:
+      return {
+        _tag: "cancelled"
+      };
+    case ClientInvitation.State.TIMEOUT:
+    case ClientInvitation.State.ERROR:
+    case ClientInvitation.State.EXPIRED:
+      return {
+        _tag: "error",
+        message: `Invitation ${ClientInvitation.State[invitation.state]}`
+      };
+    default:
+      return void 0;
+  }
+};
+var invitationEvents = (observable) => Stream.async((emit) => {
+  const subscription = observable.subscribe((invitation) => {
+    const event = toEvent(invitation);
+    if (event) {
+      void emit.single(event);
+      if (TERMINAL_STATES.has(invitation.state)) {
+        void emit.end();
+      }
+    }
+  }, (err) => {
+    void emit.single({
+      _tag: "error",
+      message: err.message
+    });
+    void emit.end();
+  });
+  return Effect.sync(() => subscription.unsubscribe());
+});
+var makeFlow = (observable, kind) => ({
+  id: observable.get().invitationId,
+  kind,
+  events: invitationEvents(observable),
+  authenticate: (code) => observable instanceof AuthenticatingInvitationObservable ? Effect.tryPromise({
+    try: () => observable.authenticate(code),
+    catch: (error) => new InvitationError({
+      context: {
+        error
+      }
+    })
+  }) : Effect.fail(new InvitationError({
+    context: {
+      reason: "flow is not awaiting authentication"
+    }
+  })),
+  cancel: () => Effect.promise(() => observable.cancel()),
+  code: Effect.sync(() => InvitationEncoder.encode(observable.get()))
+});
+var toShareOptions = (options) => ({
+  authMethod: toAuthMethod(options?.authMethod),
+  type: toType(options?.type),
+  ...options?.multiUse !== void 0 ? {
+    multiUse: options.multiUse
+  } : {},
+  ...options?.target !== void 0 ? {
+    target: options.target
+  } : {}
+});
+var toAuthMethod = (method) => {
+  switch (method) {
+    case "shared-secret":
+      return ClientInvitation.AuthMethod.SHARED_SECRET;
+    case "known-public-key":
+      return ClientInvitation.AuthMethod.KNOWN_PUBLIC_KEY;
+    case "none":
+    default:
+      return ClientInvitation.AuthMethod.NONE;
+  }
+};
+var toType = (type) => {
+  switch (type) {
+    case "delegated":
+      return ClientInvitation.Type.DELEGATED;
+    case "multiuse":
+      return ClientInvitation.Type.MULTIUSE;
+    case "interactive":
+    default:
+      return ClientInvitation.Type.INTERACTIVE;
+  }
+};
+var toAccess = (role) => {
+  switch (role) {
+    case HaloSpaceMember.Role.OWNER:
+    case HaloSpaceMember.Role.ADMIN:
+      return "admin";
+    case HaloSpaceMember.Role.EDITOR:
+      return "edit";
+    case HaloSpaceMember.Role.READER:
+      return "read";
+    default:
+      return void 0;
+  }
+};
+var fromAccess = (access) => {
+  switch (access) {
+    case "admin":
+      return HaloSpaceMember.Role.ADMIN;
+    case "edit":
+      return HaloSpaceMember.Role.EDITOR;
+    case "read":
+      return HaloSpaceMember.Role.READER;
+    default:
+      return void 0;
+  }
+};
+var isOnline = (member) => member.presence === SpaceMember.PresenceState.ONLINE;
+
+// src/identity.ts
+var toInfo = (identity) => ({
+  did: IdentityDid.make(identity.did),
+  identityKey: identity.identityKey?.toHex(),
+  displayName: identity.profile?.displayName,
+  data: identity.profile?.data
+});
+var toDeviceInfo = (device) => ({
+  key: device.deviceKey.toHex(),
+  label: device.profile?.label,
+  current: device.kind === DeviceKind.CURRENT
+});
+var toCredential = (credential) => ({
+  id: credential.id?.toHex(),
+  type: credential.subject.assertion["@type"],
+  issuanceDate: credential.issuanceDate
+});
+var makeIdentityService = (client) => ({
+  identity: streamFromObservable(client.halo.identity).pipe(Stream2.map((identity) => identity ? Option.some(toInfo(identity)) : Option.none())),
+  getSnapshot: () => {
+    const identity = client.halo.identity.get();
+    return identity ? Option.some(toInfo(identity)) : Option.none();
+  },
+  subscribe: (callback) => {
+    const subscription = client.halo.identity.subscribe((identity) => callback(identity ? Option.some(toInfo(identity)) : Option.none()));
+    return () => subscription.unsubscribe();
+  },
+  create: (options) => Effect2.tryPromise({
+    try: async () => toInfo(await client.halo.createIdentity(options?.displayName !== void 0 ? {
+      displayName: options.displayName
+    } : {}, options?.deviceLabel !== void 0 ? {
+      label: options.deviceLabel
+    } : void 0)),
+    catch: (error) => new IdentityError({
+      context: {
+        error
+      }
+    })
+  }),
+  recover: (args) => Effect2.tryPromise({
+    try: async () => toInfo(await client.halo.recoverIdentity(args)),
+    catch: (error) => new IdentityError({
+      context: {
+        error
+      }
+    })
+  }),
+  updateProfile: (profile) => Effect2.tryPromise({
+    try: async () => toInfo(await client.halo.updateProfile(profile)),
+    catch: (error) => new IdentityError({
+      context: {
+        error
+      }
+    })
+  }),
+  devices: streamFromObservable(client.halo.devices).pipe(Stream2.map((devices) => devices.map(toDeviceInfo))),
+  getDevicesSnapshot: () => client.halo.devices.get().map(toDeviceInfo),
+  credentials: streamFromObservable(client.halo.credentials).pipe(Stream2.map((credentials) => credentials.map(toCredential))),
+  grantServiceAccess: (options) => Effect2.tryPromise({
+    try: async () => {
+      const identityKey = client.halo.identity.get()?.identityKey;
+      if (!identityKey) {
+        throw new Error("No identity.");
+      }
+      await client.halo.writeCredentials([
+        {
+          issuer: identityKey,
+          issuanceDate: /* @__PURE__ */ new Date(),
+          subject: {
+            id: identityKey,
+            assertion: {
+              "@type": "dxos.halo.credentials.ServiceAccess",
+              "serverName": options.serverName,
+              "serverKey": identityKey,
+              identityKey,
+              "capabilities": [
+                ...options.capabilities
+              ]
+            }
+          }
+        }
+      ]);
+    },
+    catch: (error) => new IdentityError({
+      context: {
+        error
+      }
+    })
+  }),
+  share: (options) => Effect2.try({
+    try: () => makeFlow(client.halo.share(toShareOptions(options)), "device"),
+    catch: (error) => new IdentityError({
+      context: {
+        error
+      }
+    })
+  }),
+  join: (code) => Effect2.try({
+    try: () => makeFlow(client.halo.join(InvitationEncoder2.decode(code)), "device"),
+    catch: (error) => new IdentityError({
+      context: {
+        error
+      }
+    })
+  }),
+  invitations: streamFromObservable(client.halo.invitations).pipe(Stream2.map((invitations) => invitations.map((invitation) => makeFlow(invitation, "device"))))
+});
+var layerIdentity = (client) => Layer.succeed(HaloIdentity.Service, makeIdentityService(client));
+
+// src/space.ts
+import * as Effect3 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import * as Option2 from "effect/Option";
+import * as Stream3 from "effect/Stream";
+import { SpaceState } from "@dxos/client/echo";
+import { Space as HaloSpace, SpaceError } from "@dxos/halo";
+import { IdentityDid as IdentityDid2 } from "@dxos/keys";
+import { SpaceArchive } from "@dxos/protocols/proto/dxos/client/services";
+import { EdgeReplicationSetting } from "@dxos/protocols/proto/dxos/echo/metadata";
+import { SpaceMember as HaloSpaceMember2, MembershipPolicy } from "@dxos/protocols/proto/dxos/halo/credentials";
+var toState = (state) => {
+  switch (state) {
+    case SpaceState.SPACE_READY:
+      return "ready";
+    case SpaceState.SPACE_CLOSED:
+      return "closed";
+    default:
+      return "inactive";
+  }
+};
+var toSpaceInfo = (space) => ({
+  id: space.id,
+  name: space.state.get() === SpaceState.SPACE_READY ? space.properties.name : void 0,
+  state: toState(space.state.get())
+});
+var toMembers = (members) => members.flatMap((member) => {
+  const role = toAccess(member.role);
+  if (role === void 0) {
+    return [];
+  }
+  return [
+    {
+      did: member.identity?.did !== void 0 ? IdentityDid2.make(member.identity.did) : void 0,
+      identityKey: member.identity?.identityKey?.toHex(),
+      displayName: member.identity?.profile?.displayName,
+      data: member.identity?.profile?.data,
+      role,
+      online: isOnline(member)
+    }
+  ];
+});
+var toMembershipPolicy = (policy) => policy === "locked" ? MembershipPolicy.LOCKED : MembershipPolicy.INVITE;
+var toEdgeReplicationSetting = (setting) => setting === "enabled" ? EdgeReplicationSetting.ENABLED : EdgeReplicationSetting.DISABLED;
+var resolveSpace = (client, id) => {
+  const space = client.spaces.get(id);
+  if (!space) {
+    throw new Error(`Space not found: ${id}`);
+  }
+  return space;
+};
+var setMemberRole = async (client, id, subject, newRole) => {
+  const space = resolveSpace(client, id);
+  const member = space.members.get().find((entry) => entry.identity?.did === subject);
+  if (!member) {
+    throw new Error(`Member not found: ${subject}`);
+  }
+  await space.updateMemberRole({
+    memberKey: member.identity.identityKey,
+    newRole
+  });
+};
+var makeSpaceService = (client) => ({
+  spaces: streamFromObservable(client.spaces).pipe(Stream3.map((spaces) => (spaces ?? []).map(toSpaceInfo))),
+  get: (id) => Effect3.sync(() => {
+    const space = client.spaces.get(id);
+    return space ? Option2.some(toSpaceInfo(space)) : Option2.none();
+  }),
+  create: (options) => Effect3.tryPromise({
+    try: async () => {
+      const createOptions = {};
+      if (options?.tags !== void 0) {
+        createOptions.tags = [
+          ...options.tags
+        ];
+      }
+      if (options?.membershipPolicy !== void 0) {
+        createOptions.membershipPolicy = toMembershipPolicy(options.membershipPolicy);
+      }
+      return toSpaceInfo(await client.spaces.create(options?.name !== void 0 ? {
+        name: options.name
+      } : {}, createOptions));
+    },
+    catch: (error) => new SpaceError({
+      context: {
+        error
+      }
+    })
+  }),
+  waitReady: (id) => Effect3.tryPromise({
+    try: async () => {
+      await resolveSpace(client, id).waitUntilReady();
+    },
+    catch: (error) => new SpaceError({
+      context: {
+        error
+      }
+    })
+  }),
+  setEdgeReplication: (id, setting) => Effect3.tryPromise({
+    try: async () => {
+      await resolveSpace(client, id).internal.setEdgeReplicationPreference(toEdgeReplicationSetting(setting));
+    },
+    catch: (error) => new SpaceError({
+      context: {
+        error
+      }
+    })
+  }),
+  members: (id) => {
+    const space = client.spaces.get(id);
+    return space ? streamFromObservable(space.members).pipe(Stream3.map(toMembers)) : Stream3.empty;
+  },
+  updateMemberRole: (id, subject, role) => Effect3.tryPromise({
+    try: async () => {
+      const newRole = fromAccess(role);
+      if (newRole === void 0) {
+        throw new Error(`No legacy role for access level: ${role}`);
+      }
+      await setMemberRole(client, id, subject, newRole);
+    },
+    catch: (error) => new SpaceError({
+      context: {
+        error
+      }
+    })
+  }),
+  removeMember: (id, subject) => Effect3.tryPromise({
+    try: () => setMemberRole(client, id, subject, HaloSpaceMember2.Role.REMOVED),
+    catch: (error) => new SpaceError({
+      context: {
+        error
+      }
+    })
+  }),
+  share: (id, options) => Effect3.try({
+    try: () => makeFlow(resolveSpace(client, id).share(toShareOptions(options)), "space"),
+    catch: (error) => new SpaceError({
+      context: {
+        error
+      }
+    })
+  }),
+  join: (code) => Effect3.try({
+    try: () => makeFlow(client.spaces.join(code), "space"),
+    catch: (error) => new SpaceError({
+      context: {
+        error
+      }
+    })
+  }),
+  invitations: (id) => {
+    const space = client.spaces.get(id);
+    return space ? streamFromObservable(space.invitations).pipe(Stream3.map((invitations) => invitations.map((invitation) => makeFlow(invitation, "space")))) : Stream3.empty;
+  },
+  export: (id) => Effect3.tryPromise({
+    try: async () => {
+      const archive = await resolveSpace(client, id).internal.export();
+      return {
+        filename: archive.filename,
+        contents: archive.contents
+      };
+    },
+    catch: (error) => new SpaceError({
+      context: {
+        error
+      }
+    })
+  }),
+  import: (archive, options) => Effect3.tryPromise({
+    try: async () => {
+      const format = archive.filename.endsWith(".json") ? SpaceArchive.Format.JSON : SpaceArchive.Format.BINARY;
+      const space = await client.spaces.import({
+        filename: archive.filename,
+        contents: archive.contents,
+        format
+      }, options?.tags !== void 0 ? {
+        tags: [
+          ...options.tags
+        ]
+      } : void 0);
+      return toSpaceInfo(space);
+    },
+    catch: (error) => new SpaceError({
+      context: {
+        error
+      }
+    })
+  })
+});
+var layerSpace = (client) => Layer2.succeed(HaloSpace.Service, makeSpaceService(client));
+
+// src/index.ts
+var layerClient = (client) => Layer3.mergeAll(layerIdentity(client), layerSpace(client));
+export {
+  layerClient,
+  layerIdentity,
+  layerSpace,
+  makeIdentityService,
+  makeSpaceService
+};
+//# sourceMappingURL=index.mjs.map