@dxos/plugin-space 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/dist/lib/browser/cli/index.mjs

@@ -0,0 +1,852 @@
+import {
+  IdentityCreated,
+  OperationResolver
+} from "../chunk-J5F4LUJD.mjs";
+import {
+  SpaceEvents
+} from "../chunk-USN5QKRV.mjs";
+import {
+  meta
+} from "../chunk-HSMQFM57.mjs";
+
+// src/cli/plugin.ts
+import * as Effect17 from "effect/Effect";
+import { ActivationEvents, Capability, Plugin as Plugin2 } from "@dxos/app-framework";
+import { AppPlugin } from "@dxos/app-toolkit";
+import { Tag } from "@dxos/echo";
+import { Collection as Collection2 } from "@dxos/echo";
+import { ClientEvents } from "@dxos/plugin-client/types";
+import { DataTypes } from "@dxos/schema";
+import { AnchoredTo, Employer, Event, HasConnection, HasRelationship, HasSubject, Organization, Person, Pipeline, Task } from "@dxos/types";
+
+// src/cli/commands/database/index.ts
+import * as Command5 from "@effect/cli/Command";
+
+// src/cli/commands/database/add.ts
+import * as Command from "@effect/cli/Command";
+import * as Options from "@effect/cli/Options";
+import * as Prompt from "@effect/cli/Prompt";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Plugin } from "@dxos/app-framework";
+import { AppActivationEvents, AppCapabilities } from "@dxos/app-toolkit";
+import { CommandConfig, Common, flushAndSync, print, spaceLayer } from "@dxos/cli-util";
+import { SpaceProperties } from "@dxos/client/echo";
+import { Database, Filter, Obj, Ref, Type } from "@dxos/echo";
+import { Collection } from "@dxos/echo";
+import { EntityKind, getTypeAnnotation } from "@dxos/echo/internal";
+
+// src/cli/commands/database/util.ts
+import { FormBuilder } from "@dxos/cli-util";
+import { Entity } from "@dxos/echo";
+var printObject = (obj) => {
+  const typename = Entity.getTypename(obj) ?? "<unknown>";
+  return FormBuilder.make({
+    title: Entity.getLabel(obj) ?? typename
+  }).pipe(FormBuilder.set("id", obj.id), FormBuilder.set("typename", typename), FormBuilder.build);
+};
+var printStats = (typename, count) => FormBuilder.make({
+  title: typename
+}).pipe(FormBuilder.set("count", count), FormBuilder.build);
+var printObjectRemoved = (count) => FormBuilder.make({
+  title: "Objects removed"
+}).pipe(FormBuilder.set("count", count), FormBuilder.build);
+
+// src/cli/commands/database/add.ts
+var add = Command.make("add", {
+  spaceId: Common.spaceId.pipe(Options.optional),
+  typename: Options.text("typename").pipe(Options.withDescription("The typename to create."), Options.optional)
+}, ({ typename }) => Effect.gen(function* () {
+  const { json } = yield* CommandConfig;
+  const manager = yield* Plugin.Service;
+  const { db } = yield* Database.Service;
+  yield* manager.activate(AppActivationEvents.SetupMetadata);
+  const resolve = (typename2) => {
+    const metadata2 = manager.capabilities.getAll(AppCapabilities.Metadata).find(({ id }) => id === typename2)?.metadata;
+    return metadata2?.createObject ? metadata2 : void 0;
+  };
+  const [properties] = yield* Database.runQuery(Filter.type(SpaceProperties));
+  const collection = yield* Database.load(properties[Collection.Collection.typename]);
+  const selectedTypename = yield* Option.match(typename, {
+    onNone: () => selectTypename(resolve),
+    onSome: (t) => Effect.succeed(t)
+  });
+  const metadata = resolve(selectedTypename);
+  if (!metadata) {
+    return yield* Effect.fail(new Error(`Unknown typename: ${selectedTypename}`));
+  }
+  const object = yield* metadata.createObject({}, {
+    db
+  });
+  if (!Obj.isObject(object)) {
+    return yield* Effect.fail(new Error(`Invalid object: ${object}`));
+  }
+  const objectRef = Ref.make(object);
+  Obj.change(collection, (c) => {
+    c.objects.push(objectRef);
+  });
+  if (json) {
+    yield* Console.log(JSON.stringify(object, null, 2));
+  } else {
+    yield* Console.log(print(printObject(object)));
+  }
+  yield* flushAndSync({
+    indexes: true
+  });
+})).pipe(Command.withDescription("Add an object to a space."), Command.provide(({ spaceId }) => spaceLayer(spaceId, true)));
+var selectTypename = Effect.fn(function* (resolve) {
+  const schemas = yield* Database.runSchemaQuery({
+    location: [
+      "database",
+      "runtime"
+    ],
+    includeSystem: false
+  }).pipe(Effect.map((schemas2) => schemas2.filter((schema2) => getTypeAnnotation(schema2)?.kind !== EntityKind.Relation)), Effect.map((schemas2) => schemas2.filter((schema2) => !!resolve(Type.getTypename(schema2)))));
+  const choices = schemas.map((schema2) => ({
+    // TODO(wittjosiah): Translations.
+    title: Type.getTypename(schema2),
+    value: Type.getTypename(schema2),
+    description: Type.getTypename(schema2)
+  }));
+  const selected = yield* Prompt.select({
+    message: "Select a type:",
+    choices
+  });
+  return selected;
+});
+
+// src/cli/commands/database/query/query.ts
+import * as Command2 from "@effect/cli/Command";
+import * as Options2 from "@effect/cli/Options";
+import * as Console2 from "effect/Console";
+import * as Effect2 from "effect/Effect";
+import * as Option2 from "effect/Option";
+import { CommandConfig as CommandConfig2, Common as Common2, printList, spaceLayer as spaceLayer2 } from "@dxos/cli-util";
+import { Database as Database2, Filter as Filter2 } from "@dxos/echo";
+var handler = ({ typename }) => Effect2.gen(function* () {
+  const { json } = yield* CommandConfig2;
+  const filter = Option2.match(typename, {
+    onNone: () => Filter2.everything(),
+    onSome: (typename2) => Filter2.typename(typename2)
+  });
+  const objects = yield* Database2.runQuery(filter);
+  if (json) {
+    yield* Console2.log(JSON.stringify(objects, null, 2));
+  } else {
+    const formatted = objects.map(printObject);
+    yield* Console2.log(printList(formatted));
+  }
+});
+var query = Command2.make("query", {
+  spaceId: Common2.spaceId.pipe(Options2.optional),
+  typename: Options2.text("typename").pipe(Options2.optional, Options2.withDescription("The typename to query."))
+}, handler).pipe(Command2.withDescription("Query objects."), Command2.provide(({ spaceId }) => spaceLayer2(spaceId, true)));
+
+// src/cli/commands/database/remove.ts
+import * as Command3 from "@effect/cli/Command";
+import * as Options3 from "@effect/cli/Options";
+import * as Console3 from "effect/Console";
+import * as Effect3 from "effect/Effect";
+import * as Option3 from "effect/Option";
+import { CommandConfig as CommandConfig3, Common as Common3, print as print2, spaceLayer as spaceLayer3 } from "@dxos/cli-util";
+import { Database as Database3, Filter as Filter3, Query } from "@dxos/echo";
+var remove = Command3.make("remove", {
+  spaceId: Common3.spaceId.pipe(Options3.optional),
+  typename: Options3.text("typename").pipe(Options3.withDescription("The typename to query."), Options3.optional),
+  id: Options3.text("id").pipe(Options3.withDescription("The object ID."), Options3.optional)
+}, ({ typename, id }) => Effect3.gen(function* () {
+  const { json } = yield* CommandConfig3;
+  if (Option3.isSome(id) && Option3.isSome(typename)) {
+    throw new Error("Cannot specify both typename and id");
+  }
+  let query3;
+  if (Option3.isSome(id)) {
+    query3 = Query.select(Filter3.id(id.value));
+  } else if (Option3.isSome(typename)) {
+    query3 = Query.select(Filter3.typename(typename.value));
+  } else {
+    throw new Error("Must specify typename or id");
+  }
+  const objects = yield* Database3.runQuery(query3);
+  for (const object of objects) {
+    yield* Database3.remove(object);
+  }
+  if (json) {
+    yield* Console3.log(JSON.stringify({
+      removed: objects.length
+    }, null, 2));
+  } else {
+    yield* Console3.log(print2(printObjectRemoved(objects.length)));
+  }
+})).pipe(Command3.withDescription("Remove an object from a space."), Command3.provide(({ spaceId }) => spaceLayer3(spaceId, true)));
+
+// src/cli/commands/database/stats.ts
+import * as Command4 from "@effect/cli/Command";
+import * as Options4 from "@effect/cli/Options";
+import * as Array from "effect/Array";
+import * as Console4 from "effect/Console";
+import * as Effect4 from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Record from "effect/Record";
+import { CommandConfig as CommandConfig4, Common as Common4, printList as printList2, spaceLayer as spaceLayer4 } from "@dxos/cli-util";
+import { Obj as Obj2 } from "@dxos/echo";
+import { Database as Database4, Filter as Filter4, Query as Query2 } from "@dxos/echo";
+var stats = Command4.make("stats", {
+  spaceId: Common4.spaceId.pipe(Options4.optional)
+}, () => Effect4.gen(function* () {
+  const { json } = yield* CommandConfig4;
+  const objects = yield* Database4.runQuery(Query2.select(Filter4.everything()));
+  const stats2 = Function.pipe(objects, Array.groupBy((obj) => Obj2.getTypename(obj) ?? "<empty>"), Record.map((objs) => objs.length));
+  if (json) {
+    yield* Console4.log(JSON.stringify(stats2, null, 2));
+  } else {
+    const formatted = Record.toEntries(stats2).map(([typename, count]) => printStats(typename, count));
+    yield* Console4.log(printList2(formatted));
+  }
+})).pipe(Command4.withDescription("Query objects."), Command4.provide(({ spaceId }) => spaceLayer4(spaceId, true)));
+
+// src/cli/commands/database/index.ts
+var database = Command5.make("database").pipe(Command5.withDescription("Database access."), Command5.withSubcommands([
+  add,
+  query,
+  remove,
+  stats
+]));
+
+// src/cli/commands/queue/index.ts
+import * as Command7 from "@effect/cli/Command";
+
+// src/cli/commands/queue/query.ts
+import * as Command6 from "@effect/cli/Command";
+import * as Options5 from "@effect/cli/Options";
+import * as Console5 from "effect/Console";
+import * as Effect5 from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { CommandConfig as CommandConfig5, printList as printList3 } from "@dxos/cli-util";
+import { ClientService } from "@dxos/client";
+import { DXN } from "@dxos/keys";
+
+// src/cli/commands/queue/util.ts
+import { FormBuilder as FormBuilder2 } from "@dxos/cli-util";
+import { Entity as Entity2 } from "@dxos/echo";
+var printQueueObject = (obj) => {
+  const typename = Entity2.getTypename(obj) ?? "<unknown>";
+  return FormBuilder2.make({
+    title: typename
+  }).pipe(FormBuilder2.set("id", obj.id), FormBuilder2.set("typename", typename), FormBuilder2.build);
+};
+
+// src/cli/commands/queue/query.ts
+var DXNSchema = Schema.String.pipe(Schema.transform(Schema.instanceOf(DXN), {
+  decode: (value) => DXN.parse(value),
+  encode: (value) => value.toString()
+}));
+var query2 = Command6.make("query", {
+  dxn: Options5.text("dxn").pipe(Options5.withDescription("DXN of the queue."), Options5.withSchema(DXNSchema))
+}, Effect5.fnUntraced(function* ({ dxn }) {
+  const { json } = yield* CommandConfig5;
+  const client = yield* ClientService;
+  const queue2 = yield* Effect5.promise(() => client.graph.createRefResolver({}).resolve(dxn));
+  const objects = yield* Effect5.promise(() => queue2.queryObjects());
+  if (json) {
+    yield* Console5.log(JSON.stringify(objects, null, 2));
+  } else {
+    const formatted = objects.map(printQueueObject);
+    yield* Console5.log(printList3(formatted));
+  }
+})).pipe(Command6.withDescription("Query objects in a queue."));
+
+// src/cli/commands/queue/index.ts
+var queue = Command7.make("queue").pipe(Command7.withDescription("Manage queues."), Command7.withSubcommands([
+  query2
+]));
+
+// src/cli/commands/space/index.ts
+import * as Command19 from "@effect/cli/Command";
+
+// src/cli/commands/space/close/close.ts
+import * as Command8 from "@effect/cli/Command";
+import * as Options6 from "@effect/cli/Options";
+import * as Console6 from "effect/Console";
+import * as Effect6 from "effect/Effect";
+import { CommandConfig as CommandConfig6, Common as Common5, getSpace, waitForSync } from "@dxos/cli-util";
+import { ClientService as ClientService2 } from "@dxos/client";
+var handler2 = ({ spaceId }) => Effect6.gen(function* () {
+  const { json } = yield* CommandConfig6;
+  const client = yield* ClientService2;
+  const space2 = yield* getSpace(spaceId);
+  yield* Effect6.tryPromise(() => space2.db.flush({
+    indexes: true
+  }));
+  yield* waitForSync(space2);
+  yield* Effect6.tryPromise(() => space2.close());
+  if (json) {
+    yield* Console6.log(JSON.stringify({
+      success: true,
+      spaceId
+    }, null, 2));
+  } else {
+    yield* Console6.log(`Space ${spaceId} closed successfully.`);
+  }
+});
+var close = Command8.make("close", {
+  spaceId: Common5.spaceId.pipe(Options6.withDescription("Space ID to close."))
+}, handler2).pipe(Command8.withDescription("Close a space."));
+
+// src/cli/commands/space/create/create.ts
+import * as Command9 from "@effect/cli/Command";
+import * as Options7 from "@effect/cli/Options";
+import * as Console7 from "effect/Console";
+import * as Effect7 from "effect/Effect";
+import * as Option4 from "effect/Option";
+import { CommandConfig as CommandConfig7 } from "@dxos/cli-util";
+import { print as print3, waitForSync as waitForSync2 } from "@dxos/cli-util";
+import { FormBuilder as FormBuilder3 } from "@dxos/cli-util";
+import { ClientService as ClientService3 } from "@dxos/client";
+import { Obj as Obj3 } from "@dxos/echo";
+var handler3 = Effect7.fn(function* ({ name }) {
+  const { json } = yield* CommandConfig7;
+  const client = yield* ClientService3;
+  const space2 = yield* Effect7.tryPromise(() => client.spaces.create());
+  yield* Effect7.tryPromise(() => space2.waitUntilReady());
+  if (Option4.isSome(name)) {
+    Obj3.change(space2.properties, (p) => {
+      p.name = Option4.getOrUndefined(name);
+    });
+  }
+  if (json) {
+    yield* Console7.log(JSON.stringify({
+      key: space2.key.toHex(),
+      ...space2.properties.name ? {
+        name: space2.properties.name
+      } : {}
+    }, null, 2));
+  } else {
+    const builder = FormBuilder3.make({
+      title: "Created Space"
+    }).pipe(FormBuilder3.set("key", space2.key.truncate()), FormBuilder3.set("name", space2.properties.name ?? "<none>"));
+    yield* Console7.log(print3(FormBuilder3.build(builder)));
+  }
+  yield* Effect7.tryPromise(() => space2.db.flush({
+    indexes: true
+  }));
+  yield* waitForSync2(space2);
+});
+var create = Command9.make("create", {
+  name: Options7.text("name").pipe(Options7.withDescription("The name of the space."), Options7.optional)
+}, handler3).pipe(Command9.withDescription("Create a new space."));
+
+// src/cli/commands/space/info/info.ts
+import * as Command10 from "@effect/cli/Command";
+import * as Options8 from "@effect/cli/Options";
+import * as Console8 from "effect/Console";
+import * as Effect8 from "effect/Effect";
+import { CommandConfig as CommandConfig8, Common as Common6, formatSpace, getSpace as getSpace2, print as print4, printSpace, spaceIdWithDefault } from "@dxos/cli-util";
+import { ClientService as ClientService4 } from "@dxos/client";
+var handler4 = Effect8.fn(function* ({ spaceId }) {
+  const { json } = yield* CommandConfig8;
+  const client = yield* ClientService4;
+  const resolvedSpaceId = yield* spaceIdWithDefault(spaceId);
+  const space2 = yield* getSpace2(resolvedSpaceId);
+  const formatted = yield* formatSpace(space2);
+  if (json) {
+    yield* Console8.log(JSON.stringify(formatted, null, 2));
+  } else {
+    yield* Console8.log(print4(printSpace(formatted)));
+  }
+});
+var info = Command10.make("info", {
+  spaceId: Common6.spaceId.pipe(Options8.optional)
+}, handler4).pipe(Command10.withDescription("Show space info."));
+
+// src/cli/commands/space/join/join.ts
+import * as Args from "@effect/cli/Args";
+import * as Command11 from "@effect/cli/Command";
+import * as Options9 from "@effect/cli/Options";
+import * as Prompt2 from "@effect/cli/Prompt";
+import * as Console9 from "effect/Console";
+import * as Duration from "effect/Duration";
+import * as Effect10 from "effect/Effect";
+import * as Option5 from "effect/Option";
+import { CommandConfig as CommandConfig9 } from "@dxos/cli-util";
+import { print as print5, waitForSync as waitForSync3 } from "@dxos/cli-util";
+import { FormBuilder as FormBuilder4 } from "@dxos/cli-util";
+import { ClientService as ClientService5 } from "@dxos/client";
+
+// src/cli/commands/space/join/util.ts
+import * as Effect9 from "effect/Effect";
+import * as Queue from "effect/Queue";
+import { Invitation } from "@dxos/client/invitations";
+import { runAndForwardErrors } from "@dxos/effect";
+import { invariant } from "@dxos/invariant";
+import { AlreadyJoinedError } from "@dxos/protocols";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-space/src/cli/commands/space/join/util.ts";
+var acceptInvitation = ({ observable, callbacks }) => Effect9.gen(function* () {
+  const doneQueue = yield* Queue.unbounded();
+  const runCallback = (effect) => {
+    if (effect) {
+      runAndForwardErrors(effect).catch(() => {
+      });
+    }
+  };
+  const subscription = observable.subscribe((invitation2) => {
+    switch (invitation2.state) {
+      case Invitation.State.CONNECTING: {
+        runCallback(callbacks?.onConnecting?.(invitation2));
+        break;
+      }
+      case Invitation.State.READY_FOR_AUTHENTICATION: {
+        if (invitation2.authMethod === Invitation.AuthMethod.SHARED_SECRET) {
+          const callbackEffect = callbacks?.onReadyForAuth?.(invitation2) ?? Effect9.succeed(void 0);
+          Effect9.gen(function* () {
+            const callbackResult = yield* callbackEffect;
+            const code = invitation2.authCode ?? callbackResult;
+            invariant(code, "No code provided", {
+              F: __dxlog_file,
+              L: 52,
+              S: this,
+              A: [
+                "code",
+                "'No code provided'"
+              ]
+            });
+            yield* Effect9.tryPromise(() => observable.authenticate(code));
+          }).pipe(runAndForwardErrors).catch(() => {
+          });
+        }
+        break;
+      }
+      case Invitation.State.SUCCESS: {
+        runCallback(callbacks?.onSuccess?.(invitation2));
+        runAndForwardErrors(Queue.offer(doneQueue, invitation2)).catch(() => {
+        });
+        break;
+      }
+    }
+  }, (err) => {
+    if (err instanceof AlreadyJoinedError) {
+      runAndForwardErrors(Queue.offer(doneQueue, observable.get())).catch(() => {
+      });
+      return;
+    }
+    throw err;
+  });
+  const invitation = yield* Queue.take(doneQueue);
+  subscription.unsubscribe();
+  return invitation;
+});
+
+// src/cli/commands/space/join/join.ts
+var handler5 = Effect10.fn(function* ({ invitationCode, authCode }) {
+  const { json } = yield* CommandConfig9;
+  const client = yield* ClientService5;
+  let encoded = invitationCode;
+  if (encoded.startsWith("http") || encoded.startsWith("socket")) {
+    const searchProps = new URL(encoded).searchParams;
+    encoded = searchProps.get("spaceInvitationCode") ?? encoded;
+  }
+  const invitation = yield* acceptInvitation({
+    observable: client.spaces.join(encoded),
+    callbacks: {
+      onReadyForAuth: (invitation2) => {
+        if (Option5.isSome(authCode)) {
+          return Effect10.succeed(Option5.getOrUndefined(authCode) ?? void 0);
+        }
+        return Prompt2.text({
+          message: "Enter the authentication code"
+        }).pipe(Prompt2.run).pipe(Effect10.mapError(() => void 0)).pipe(Effect10.catchAll(() => Effect10.succeed(void 0)));
+      }
+    }
+  });
+  const spaceKey = invitation.spaceKey;
+  if (!spaceKey) {
+    if (json) {
+      yield* Console9.log(JSON.stringify({
+        error: "No space key in invitation"
+      }, null, 2));
+    } else {
+      yield* Console9.log("No space key in invitation.");
+    }
+    return;
+  }
+  let space2 = client.spaces.get(spaceKey);
+  if (!space2) {
+    const maxRetries = 5;
+    const retryDelays = [
+      0.5,
+      1,
+      1.5,
+      2,
+      2.5
+    ].map((s) => Duration.seconds(s));
+    for (let i = 0; i < maxRetries; i++) {
+      yield* Effect10.sleep(retryDelays[i]);
+      space2 = client.spaces.get(spaceKey);
+      if (space2) {
+        break;
+      }
+    }
+  }
+  if (!space2) {
+    if (json) {
+      yield* Console9.log(JSON.stringify({
+        error: "Space not found after joining"
+      }, null, 2));
+    } else {
+      yield* Console9.log("Space not found after joining.");
+    }
+    return;
+  }
+  yield* Effect10.tryPromise(() => space2.db.flush({
+    indexes: true
+  }));
+  yield* waitForSync3(space2);
+  if (json) {
+    yield* Console9.log(JSON.stringify({
+      spaceId: space2.id,
+      state: space2.state.get()
+    }, null, 2));
+  } else {
+    const builder = FormBuilder4.make({
+      title: "Joined Space"
+    }).pipe(FormBuilder4.set("spaceId", space2.id), FormBuilder4.set("key", space2.key.truncate()), FormBuilder4.set("name", space2.properties.name ?? "<none>"));
+    yield* Console9.log(print5(FormBuilder4.build(builder)));
+  }
+});
+var join = Command11.make("join", {
+  invitationCode: Args.text({
+    name: "invitationCode"
+  }).pipe(Args.withDescription("The invitation code.")),
+  authCode: Options9.text("authCode").pipe(Options9.withDescription("The authentication code."), Options9.optional)
+}, handler5).pipe(Command11.withDescription("Join a space via invitation."));
+
+// src/cli/commands/space/list/list.ts
+import * as Command12 from "@effect/cli/Command";
+import * as Console10 from "effect/Console";
+import * as Effect11 from "effect/Effect";
+import { CommandConfig as CommandConfig10, formatSpace as formatSpace2, printSpace as printSpace2 } from "@dxos/cli-util";
+import { printList as printList4 } from "@dxos/cli-util";
+import { ClientService as ClientService6 } from "@dxos/client";
+var handler6 = Effect11.fn(function* () {
+  const { json } = yield* CommandConfig10;
+  const client = yield* ClientService6;
+  const spaces = client.spaces.get();
+  const formattedSpaces = yield* Effect11.all(spaces.map(formatSpace2));
+  if (json) {
+    yield* Console10.log(JSON.stringify(formattedSpaces, null, 2));
+  } else {
+    const formatted = formattedSpaces.map(printSpace2);
+    yield* Console10.log(printList4(formatted));
+  }
+});
+var list = Command12.make("list", {}, handler6).pipe(Command12.withDescription("List all spaces available on this device."));
+
+// src/cli/commands/space/members/members.ts
+import * as Command13 from "@effect/cli/Command";
+import * as Options10 from "@effect/cli/Options";
+import * as Console11 from "effect/Console";
+import * as Effect12 from "effect/Effect";
+import { CommandConfig as CommandConfig11, Common as Common7, getSpace as getSpace3, printList as printList5, spaceIdWithDefault as spaceIdWithDefault2 } from "@dxos/cli-util";
+import { ClientService as ClientService7 } from "@dxos/client";
+
+// src/cli/commands/space/members/util.ts
+import { FormBuilder as FormBuilder5 } from "@dxos/cli-util";
+import { SpaceMember } from "@dxos/client/echo";
+var maybeTruncateKey = (key, truncate = false) => truncate ? key.truncate() : key.toHex();
+var mapMembers = (members2, truncateKeys = false) => {
+  return members2.map((member) => ({
+    key: maybeTruncateKey(member.identity.identityKey, truncateKeys),
+    name: member.identity.profile?.displayName,
+    presence: member.presence === SpaceMember.PresenceState.ONLINE ? "Online" : "Offline"
+  }));
+};
+var printMember = (member) => FormBuilder5.make({
+  title: member.identity.profile?.displayName ?? member.identity.identityKey.truncate()
+}).pipe(FormBuilder5.set("identityKey", member.identity.identityKey.truncate()), FormBuilder5.set("displayName", member.identity.profile?.displayName ?? "<none>"), FormBuilder5.set("presence", member.presence === SpaceMember.PresenceState.ONLINE ? "Online" : "Offline"), FormBuilder5.build);
+var printMembers = (members2) => {
+  return members2.map(printMember);
+};
+
+// src/cli/commands/space/members/members.ts
+var handler7 = Effect12.fn(function* ({ spaceId }) {
+  const { json } = yield* CommandConfig11;
+  const client = yield* ClientService7;
+  const resolvedSpaceId = yield* spaceIdWithDefault2(spaceId);
+  const space2 = yield* getSpace3(resolvedSpaceId);
+  const members2 = space2.members.get();
+  if (json) {
+    yield* Console11.log(JSON.stringify(mapMembers(members2), null, 2));
+  } else {
+    const formatted = printMembers(members2);
+    yield* Console11.log(printList5(formatted));
+  }
+});
+var members = Command13.make("members", {
+  spaceId: Common7.spaceId.pipe(Options10.optional)
+}, handler7).pipe(Command13.withDescription("List space members."));
+
+// src/cli/commands/space/open/open.ts
+import * as Command14 from "@effect/cli/Command";
+import * as Options11 from "@effect/cli/Options";
+import * as Console12 from "effect/Console";
+import * as Effect13 from "effect/Effect";
+import { CommandConfig as CommandConfig12, Common as Common8, getSpace as getSpace4, waitForSync as waitForSync4 } from "@dxos/cli-util";
+import { ClientService as ClientService8 } from "@dxos/client";
+var handler8 = ({ spaceId }) => Effect13.gen(function* () {
+  const { json } = yield* CommandConfig12;
+  const client = yield* ClientService8;
+  const space2 = yield* getSpace4(spaceId);
+  yield* Effect13.tryPromise(() => space2.open());
+  yield* Effect13.tryPromise(() => space2.db.flush({
+    indexes: true
+  }));
+  yield* waitForSync4(space2);
+  if (json) {
+    yield* Console12.log(JSON.stringify({
+      success: true,
+      spaceId
+    }, null, 2));
+  } else {
+    yield* Console12.log(`Space ${spaceId} opened successfully.`);
+  }
+});
+var open = Command14.make("open", {
+  spaceId: Common8.spaceId.pipe(Options11.withDescription("Space ID to open."))
+}, handler8).pipe(Command14.withDescription("Open a space."));
+
+// src/cli/commands/space/schema/index.ts
+import * as Command16 from "@effect/cli/Command";
+
+// src/cli/commands/space/schema/list/list.ts
+import * as Command15 from "@effect/cli/Command";
+import * as Options12 from "@effect/cli/Options";
+import * as Console13 from "effect/Console";
+import * as Effect14 from "effect/Effect";
+import * as Option6 from "effect/Option";
+import { CommandConfig as CommandConfig13, Common as Common9, getSpace as getSpace5, printList as printList6, spaceIdWithDefault as spaceIdWithDefault3 } from "@dxos/cli-util";
+import { ClientService as ClientService9 } from "@dxos/client";
+import { getTypeAnnotation as getTypeAnnotation2 } from "@dxos/echo/internal";
+
+// src/cli/commands/space/schema/list/util.ts
+import { FormBuilder as FormBuilder6 } from "@dxos/cli-util";
+var mapSchemas = (schemas) => {
+  return schemas.map((schema2) => ({
+    id: schema2.id,
+    typename: schema2.typename,
+    version: schema2.version
+  }));
+};
+var printSchema = (schema2) => FormBuilder6.make({
+  title: schema2.typename
+}).pipe(FormBuilder6.set("id", schema2.id ?? "<none>"), FormBuilder6.set("typename", schema2.typename), FormBuilder6.set("version", schema2.version), FormBuilder6.build);
+var printSchemas = (schemas) => {
+  return schemas.map(printSchema);
+};
+var createTypenameFilter = (typenameFilter) => {
+  if (!typenameFilter) {
+    return () => true;
+  }
+  return (schema2) => schema2.typename.toLowerCase().includes(typenameFilter.toLowerCase());
+};
+
+// src/cli/commands/space/schema/list/list.ts
+var handler9 = Effect14.fn(function* ({ spaceId, typename }) {
+  const { json } = yield* CommandConfig13;
+  const client = yield* ClientService9;
+  const resolvedSpaceId = yield* spaceIdWithDefault3(spaceId);
+  const space2 = yield* getSpace5(resolvedSpaceId);
+  const echoSchema = yield* Effect14.tryPromise(() => space2.db.schemaRegistry.query().run());
+  const runtimeSchema = space2.internal.db.graph.schemaRegistry.schemas;
+  const schemas = [
+    ...echoSchema.map((schema2) => ({
+      id: schema2.id,
+      typename: schema2.typename,
+      version: schema2.version
+    })),
+    ...runtimeSchema.map((schema2) => {
+      const schemaAnnotation = getTypeAnnotation2(schema2);
+      return {
+        typename: schemaAnnotation.typename,
+        version: schemaAnnotation.version
+      };
+    })
+  ].filter(createTypenameFilter(Option6.getOrUndefined(typename)));
+  if (json) {
+    yield* Console13.log(JSON.stringify(mapSchemas(schemas), null, 2));
+  } else {
+    const formatted = printSchemas(schemas);
+    yield* Console13.log(printList6(formatted));
+  }
+});
+var list2 = Command15.make("list", {
+  spaceId: Common9.spaceId.pipe(Options12.optional),
+  typename: Options12.text("typename").pipe(Options12.withDescription("Filter schemas by typename."), Options12.optional)
+}, handler9).pipe(Command15.withDescription("List space schemas."));
+
+// src/cli/commands/space/schema/index.ts
+var schema = Command16.make("schema").pipe(Command16.withDescription("Manage space schemas."), Command16.withSubcommands([
+  list2
+]));
+
+// src/cli/commands/space/share/share.ts
+import * as Command17 from "@effect/cli/Command";
+import * as Options13 from "@effect/cli/Options";
+import * as Console14 from "effect/Console";
+import * as Effect15 from "effect/Effect";
+import { CommandConfig as CommandConfig14, Common as Common10, copyToClipboard, getSpace as getSpace6, openBrowser, print as print6, spaceIdWithDefault as spaceIdWithDefault4 } from "@dxos/cli-util";
+import { FormBuilder as FormBuilder7 } from "@dxos/cli-util";
+import { ClientService as ClientService10 } from "@dxos/client";
+import { Invitation as Invitation2, InvitationEncoder, hostInvitation } from "@dxos/client/invitations";
+var handler10 = Effect15.fn(function* ({ spaceId, multiple, open: open2, host }) {
+  const { json } = yield* CommandConfig14;
+  const client = yield* ClientService10;
+  const resolvedSpaceId = yield* spaceIdWithDefault4(spaceId);
+  const space2 = yield* getSpace6(resolvedSpaceId);
+  const observable = space2.share({
+    authMethod: Invitation2.AuthMethod.SHARED_SECRET,
+    persistent: true,
+    multiUse: multiple
+  });
+  const invitation = yield* hostInvitation({
+    observable,
+    callbacks: {
+      onConnecting: (invitation2) => Effect15.gen(function* () {
+        const invitationCode = InvitationEncoder.encode(invitation2);
+        const authCode = invitation2.authCode;
+        yield* copyToClipboard(authCode).pipe(Effect15.catchAll(() => Effect15.void));
+        if (!json) {
+          yield* Console14.log(`
+Secret: ${authCode} (copied to clipboard)
+`);
+        }
+        if (open2) {
+          const url = new URL(host);
+          url.searchParams.append("spaceInvitationCode", invitationCode);
+          yield* openBrowser(url.toString()).pipe(Effect15.catchAll(() => Effect15.void));
+        } else if (!json) {
+          yield* Console14.log(`
+Invitation: ${invitationCode}
+`);
+        }
+      })
+    },
+    waitForSuccess: true
+  });
+  if (json) {
+    yield* Console14.log(JSON.stringify({
+      invitationCode: InvitationEncoder.encode(invitation),
+      authCode: invitation.authCode,
+      state: Invitation2.State[invitation.state]
+    }, null, 2));
+  } else {
+    const builder = FormBuilder7.make({
+      title: "Space Invitation"
+    }).pipe(FormBuilder7.set("invitationCode", InvitationEncoder.encode(invitation)), FormBuilder7.set("authCode", invitation.authCode ?? "<none>"), FormBuilder7.set("state", Invitation2.State[invitation.state]));
+    yield* Console14.log(print6(FormBuilder7.build(builder)));
+  }
+});
+var share = Command17.make("share", {
+  spaceId: Common10.spaceId.pipe(Options13.optional),
+  multiple: Options13.boolean("multiple", {
+    ifPresent: true
+  }).pipe(Options13.withDescription("Create a multi-use invitation.")),
+  open: Options13.boolean("open", {
+    ifPresent: true
+  }).pipe(Options13.withDescription("Open browser with invitation.")),
+  host: Options13.text("host").pipe(Options13.withDescription("Application Host URL."), Options13.withDefault("https://composer.space"))
+}, handler10).pipe(Command17.withDescription("Create space invitation."));
+
+// src/cli/commands/space/sync/sync.ts
+import * as Command18 from "@effect/cli/Command";
+import * as Options14 from "@effect/cli/Options";
+import * as Duration2 from "effect/Duration";
+import * as Effect16 from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import { Common as Common11, getSpace as getSpace7, spaceIdWithDefault as spaceIdWithDefault5, waitForSync as waitForSync5, withTimeout } from "@dxos/cli-util";
+var sync = Command18.make("sync", {
+  spaceId: Common11.spaceId.pipe(Options14.optional),
+  spaceTimeout: Options14.integer("spaceTimeout").pipe(Options14.withDescription("The timeout to wait for the space to be available in milliseconds."), Options14.withDefault(5e3))
+}, ({ spaceId, spaceTimeout }) => Effect16.gen(function* () {
+  const resolvedSpaceId = yield* spaceIdWithDefault5(spaceId);
+  const space2 = yield* getSpace7(resolvedSpaceId).pipe(Effect16.retry(Schedule.fixed("100 millis")), Effect16.timeout(Duration2.millis(spaceTimeout)));
+  yield* waitForSync5(space2);
+}).pipe(withTimeout)).pipe(Command18.withDescription("Wait for a space to be fully synchronized with EDGE."));
+
+// src/cli/commands/space/index.ts
+var space = Command19.make("space").pipe(Command19.withDescription("Manage ECHO spaces."), Command19.withSubcommands([
+  close,
+  create,
+  info,
+  join,
+  list,
+  members,
+  open,
+  schema,
+  share,
+  sync
+]));
+
+// src/cli/plugin.ts
+var SpacePlugin = Plugin2.define(meta).pipe(
+  // TODO(wittjosiah): Could some of these commands make use of operations?
+  AppPlugin.addCommandModule({
+    commands: [
+      database,
+      queue,
+      space
+    ]
+  }),
+  AppPlugin.addMetadataModule({
+    metadata: {
+      id: Collection2.Collection.typename,
+      metadata: {
+        createObject: (props) => Effect17.sync(() => Collection2.make(props)),
+        addToCollectionOnCreate: true
+      }
+    }
+  }),
+  AppPlugin.addSchemaModule({
+    schema: [
+      ...DataTypes,
+      AnchoredTo.AnchoredTo,
+      Employer.Employer,
+      Event.Event,
+      HasConnection.HasConnection,
+      HasRelationship.HasRelationship,
+      HasSubject.HasSubject,
+      Organization.Organization,
+      Person.Person,
+      Pipeline.Pipeline,
+      Tag.Tag,
+      Task.Task
+    ]
+  }),
+  Plugin2.addModule(({ shareableLinkOrigin = "http://localhost:5173", invitationPath = "/", invitationProp = "spaceInvitationCode" }) => {
+    const createInvitationUrl = (invitationCode) => {
+      const baseUrl = new URL(invitationPath || "/", shareableLinkOrigin);
+      baseUrl.searchParams.set(invitationProp, invitationCode);
+      return baseUrl.toString();
+    };
+    return {
+      id: Capability.getModuleTag(OperationResolver),
+      activatesOn: ActivationEvents.SetupOperationResolver,
+      activate: () => OperationResolver({
+        createInvitationUrl,
+        observability: false
+      })
+    };
+  }),
+  Plugin2.addModule({
+    activatesOn: ClientEvents.IdentityCreated,
+    activatesAfter: [
+      SpaceEvents.DefaultSpaceReady
+    ],
+    activate: IdentityCreated
+  }),
+  Plugin2.make
+);
+export {
+  SpacePlugin
+};
+//# sourceMappingURL=index.mjs.map