@dxos/plugin-space 0.10.0 → 0.11.1

package/PLUGIN.mdl

@@ -468,6 +468,17 @@ feat F-5: Collections
   req F-5.1: A Collection is an ordered list of references to ECHO objects.
   req F-5.2: CollectionArticle renders collection contents with drag-to-reorder support.
   req F-5.3: op:CollectionOperation.Create creates an empty Collection in the active space.
+  req F-5.4: An object's collection ancestry is its canonical location: `resolveCollectionObjectPath`
+             walks the space's collection tree to the root collection and yields
+             `content/collections/<ancestors…>/<objectId>`. Both URL resolution (the `object` url key)
+             and the plugin's NavigationTargetResolver answer with it, so a link to an object lands
+             where the nav tree shows it.
+  req F-5.5: The plugin's NavigationTargetResolver offers the collection path first, then the type-section
+             path for types whose graph extension declares a static section (derived from the builder's
+             url bindings — see `type-section-path.ts` — so no per-plugin wiring), and the database path
+             (`system/database/<type>/<objectId>`) last, declared via `position: Position.last` — every
+             object has the latter, but it names a hidden node, so it is only used for objects the tree
+             shows nowhere else.
 ```
 
 ```mdl

package/dist/lib/SpacePlugin.mjs

@@ -0,0 +1,2 @@
+import { t as SpacePlugin } from "./chunk-SpacePlugin.mjs";
+export { SpacePlugin, SpacePlugin as default };

package/dist/lib/SpacePlugin.node.mjs

@@ -0,0 +1,628 @@
+import { n as SpaceNotReadyError } from "./chunk-errors.mjs";
+import { ActivationEvents, Capability, Plugin } from "@dxos/app-framework";
+import { meta } from "#meta";
+import { AppActivationEvents, AppAnnotation, AppPlugin } from "@dxos/app-toolkit";
+import * as Effect from "effect/Effect";
+import { SpaceMember, SpaceProperties } from "@dxos/client/echo";
+import { Annotation, Database, Entity, Filter, Obj, Query, Scope, Tag, Type } from "@dxos/echo";
+import { Invitation, InvitationEncoder, hostInvitation } from "@dxos/client/invitations";
+import { SpaceArchive } from "@dxos/protocols/proto/dxos/client/services";
+import { ClientEvents } from "@dxos/plugin-client";
+import { DataTypes } from "@dxos/schema";
+import { AnchoredTo, Employer, Event, HasConnection, HasRelationship, HasSubject, Organization, Person, Pipeline, Task } from "@dxos/types";
+import { CreateObject, IdentityCreated, OperationHandler, UndoMappings } from "#capabilities";
+import { SpaceCapabilities, SpaceEvents } from "#types";
+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 Option from "effect/Option";
+import { CommandConfig, Common, FormBuilder, copyToClipboard, flushAndSync, formatBytes, formatSpace, getSpace as getSpace$1, openBrowser, print, printList, printSpace, spaceIdWithDefault, spaceLayer, waitForSync, withTimeout } from "@dxos/cli-util";
+import { HiddenAnnotation, getTypeAnnotation } from "@dxos/echo/Annotation";
+import { Kind } from "@dxos/echo/Entity";
+import { DXN as DXN$1, EID } from "@dxos/keys";
+import * as Array from "effect/Array";
+import * as Function from "effect/Function";
+import * as Record from "effect/Record";
+import { ClientService } from "@dxos/client";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import * as Duration from "effect/Duration";
+import * as Match from "effect/Match";
+import * as Args from "@effect/cli/Args";
+import * as Queue from "effect/Queue";
+import { EffectEx } from "@dxos/effect";
+import { invariant } from "@dxos/invariant";
+import { AlreadyJoinedError } from "@dxos/protocols";
+import * as Schedule from "effect/Schedule";
+//#region src/commands/database/util.ts
+/**
+* Pretty prints an object with ANSI colors.
+*/
+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);
+};
+/**
+* Pretty prints object stats with ANSI colors.
+*/
+var printStats = (typename, count) => FormBuilder.make({ title: typename }).pipe(FormBuilder.set("count", count), FormBuilder.build);
+/**
+* Pretty prints object removal result with ANSI colors.
+*/
+var printObjectRemoved = (count) => FormBuilder.make({ title: "Objects removed" }).pipe(FormBuilder.set("count", count), FormBuilder.build);
+//#endregion
+//#region src/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.SetupSchema);
+	const resolve = (typename) => {
+		return manager.capabilities.getAll(SpaceCapabilities.CreateObjectEntry).find(({ id }) => id === typename) ?? void 0;
+	};
+	const [properties] = yield* Database.query(Filter.type(SpaceProperties)).run;
+	const rootCollectionRef = Annotation.get(properties, AppAnnotation.RootCollectionAnnotation).pipe(Option.getOrUndefined);
+	const collection = rootCollectionRef ? yield* Database.load(rootCollectionRef) : void 0;
+	const selectedTypename = yield* Option.match(typename, {
+		onNone: () => selectTypename(resolve),
+		onSome: (t) => Effect.succeed(t)
+	});
+	const metadata = resolve(selectedTypename);
+	if (!metadata) return yield* Effect.fail(/* @__PURE__ */ new Error(`Unknown typename: ${selectedTypename}`));
+	const object = (yield* metadata.createObject({}, {
+		db,
+		target: collection ?? db
+	})).object;
+	if (!Obj.isObject(object)) return yield* Effect.fail(/* @__PURE__ */ new Error(`Invalid object: ${object}`));
+	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)));
+/**
+* Prompts for typename selection if not provided.
+*/
+var selectTypename = Effect.fn(function* (resolve) {
+	const { db } = yield* Database.Service;
+	const choices = (yield* Database.query(Query.select(Filter.type(Type.Type)).from(Scope.space(), Scope.registry())).run).filter((schema) => !HiddenAnnotation.get(Type.getSchema(schema)).pipe(Option.getOrElse(() => false))).filter((schema) => getTypeAnnotation(Type.getSchema(schema))?.kind !== Kind.Relation).filter((schema) => !!resolve(Type.getTypename(schema))).map((schema) => ({
+		title: Type.getTypename(schema),
+		value: Type.getTypename(schema),
+		description: Type.getTypename(schema)
+	}));
+	return yield* Prompt.select({
+		message: "Select a type:",
+		choices
+	});
+});
+//#endregion
+//#region src/commands/database/query/query.ts
+var handler$11 = ({ typename }) => Effect.gen(function* () {
+	const { json } = yield* CommandConfig;
+	const filter = Option.match(typename, {
+		onNone: () => Filter.everything(),
+		onSome: (typename) => Filter.type(DXN$1.make(typename))
+	});
+	const objects = yield* Database.query(filter).run;
+	if (json) yield* Console.log(JSON.stringify(objects, null, 2));
+	else {
+		const formatted = objects.map(printObject);
+		yield* Console.log(printList(formatted));
+	}
+});
+var query$1 = Command.make("query", {
+	spaceId: Common.spaceId.pipe(Options.optional),
+	typename: Options.text("typename").pipe(Options.optional, Options.withDescription("The typename to query."))
+}, handler$11).pipe(Command.withDescription("Query objects."), Command.provide(({ spaceId }) => spaceLayer(spaceId, true)));
+//#endregion
+//#region src/commands/database/remove.ts
+var remove = Command.make("remove", {
+	spaceId: Common.spaceId.pipe(Options.optional),
+	typename: Options.text("typename").pipe(Options.withDescription("The typename to query."), Options.optional),
+	id: Options.text("id").pipe(Options.withDescription("The object ID."), Options.optional)
+}, ({ typename, id }) => Effect.gen(function* () {
+	const { json } = yield* CommandConfig;
+	if (Option.isSome(id) && Option.isSome(typename)) throw new Error("Cannot specify both typename and id");
+	let query;
+	if (Option.isSome(id)) query = Query.select(Filter.id(id.value));
+	else if (Option.isSome(typename)) query = Query.select(Filter.type(DXN$1.make(typename.value)));
+	else throw new Error("Must specify typename or id");
+	const objects = yield* Database.query(query).run;
+	for (const object of objects) yield* Database.remove(object);
+	if (json) yield* Console.log(JSON.stringify({ removed: objects.length }, null, 2));
+	else yield* Console.log(print(printObjectRemoved(objects.length)));
+})).pipe(Command.withDescription("Remove an object from a space."), Command.provide(({ spaceId }) => spaceLayer(spaceId, true)));
+//#endregion
+//#region src/commands/database/stats.ts
+var stats = Command.make("stats", { spaceId: Common.spaceId.pipe(Options.optional) }, () => Effect.gen(function* () {
+	const { json } = yield* CommandConfig;
+	const objects = yield* Database.query(Query.select(Filter.everything())).run;
+	const stats = Function.pipe(objects, Array.groupBy((obj) => Obj.getTypename(obj) ?? "<empty>"), Record.map((objs) => objs.length));
+	if (json) yield* Console.log(JSON.stringify(stats, null, 2));
+	else {
+		const formatted = Record.toEntries(stats).map(([typename, count]) => printStats(typename, count));
+		yield* Console.log(printList(formatted));
+	}
+})).pipe(Command.withDescription("Query objects."), Command.provide(({ spaceId }) => spaceLayer(spaceId, true)));
+//#endregion
+//#region src/commands/database/index.ts
+var database = Command.make("database").pipe(Command.withDescription("Database access."), Command.withSubcommands([
+	add,
+	query$1,
+	remove,
+	stats
+]));
+//#endregion
+//#region src/commands/queue/util.ts
+/**
+* Pretty prints a queue object with ANSI colors.
+*/
+var printQueueObject = (obj) => {
+	const typename = Entity.getTypename(obj) ?? "<unknown>";
+	return FormBuilder.make({ title: typename }).pipe(FormBuilder.set("id", obj.id), FormBuilder.set("typename", typename), FormBuilder.build);
+};
+//#endregion
+//#region src/commands/queue/query.ts
+var query = Command.make("query", { dxn: Options.text("dxn").pipe(Options.withDescription("DXN of the queue.")) }, Effect.fnUntraced(function* ({ dxn }) {
+	const { json } = yield* CommandConfig;
+	const client = yield* ClientService;
+	const echoUri = EID.tryParse(dxn);
+	if (!echoUri) {
+		yield* Console.error(`Not a valid feed identifier: ${dxn}`);
+		return;
+	}
+	const spaceId = EID.getSpaceId(echoUri);
+	if (!spaceId) {
+		yield* Console.error(`Could not determine space from: ${dxn}`);
+		return;
+	}
+	const space = client.spaces.get(spaceId);
+	if (!space) {
+		yield* Console.error(`Space not found: ${spaceId}`);
+		return;
+	}
+	const objects = yield* Effect.promise(() => space.db.query(Query.select(Filter.everything()).from(Scope.feed(echoUri))).run());
+	if (json) yield* Console.log(JSON.stringify(objects, null, 2));
+	else {
+		const formatted = objects.map(printQueueObject);
+		yield* Console.log(printList(formatted));
+	}
+})).pipe(Command.withDescription("Query objects in a queue."));
+//#endregion
+//#region src/commands/queue/index.ts
+var queue = Command.make("queue").pipe(Command.withDescription("Manage queues."), Command.withSubcommands([query]));
+//#endregion
+//#region src/commands/space/close/close.ts
+var handler$10 = ({ spaceId }) => Effect.gen(function* () {
+	const { json } = yield* CommandConfig;
+	yield* ClientService;
+	const space = yield* getSpace$1(spaceId);
+	yield* Effect.tryPromise(() => space.db.flush());
+	yield* waitForSync(space);
+	yield* Effect.tryPromise(() => space.close());
+	if (json) yield* Console.log(JSON.stringify({
+		success: true,
+		spaceId
+	}, null, 2));
+	else yield* Console.log(`Space ${spaceId} closed successfully.`);
+});
+var close = Command.make("close", { spaceId: Common.spaceId.pipe(Options.withDescription("Space ID to close.")) }, handler$10).pipe(Command.withDescription("Close a space."));
+//#endregion
+//#region src/commands/space/create/create.ts
+var handler$9 = Effect.fn(function* ({ name }) {
+	const { json } = yield* CommandConfig;
+	const client = yield* ClientService;
+	const space = yield* Effect.tryPromise(() => client.spaces.create());
+	yield* Effect.tryPromise(() => space.waitUntilReady());
+	if (Option.isSome(name)) Obj.update(space.properties, (obj) => {
+		obj.name = Option.getOrUndefined(name);
+	});
+	if (json) yield* Console.log(JSON.stringify({
+		key: space.key.toHex(),
+		...space.properties.name ? { name: space.properties.name } : {}
+	}, null, 2));
+	else {
+		const builder = FormBuilder.make({ title: "Created Space" }).pipe(FormBuilder.set("key", space.key.truncate()), FormBuilder.set("name", space.properties.name ?? "<none>"));
+		yield* Console.log(print(FormBuilder.build(builder)));
+	}
+	yield* Effect.tryPromise(() => space.db.flush());
+	yield* waitForSync(space);
+});
+var create = Command.make("create", { name: Options.text("name").pipe(Options.withDescription("The name of the space."), Options.optional) }, handler$9).pipe(Command.withDescription("Create a new space."));
+//#endregion
+//#region src/commands/space/export/export.ts
+var SPACE_READY_TIMEOUT = Duration.seconds(30);
+var Formats = ["binary", "json"];
+/** Exports a space in the given archive format and writes it to disk. */
+var handler$8 = Effect.fn(function* ({ spaceId, output, format }) {
+	const { json } = yield* CommandConfig;
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const resolvedSpaceId = yield* spaceIdWithDefault(spaceId);
+	const space = yield* getSpace$1(resolvedSpaceId);
+	yield* Effect.tryPromise(() => space.waitUntilReady()).pipe(Effect.timeoutFail({
+		duration: SPACE_READY_TIMEOUT,
+		onTimeout: () => new SpaceNotReadyError({ context: { spaceId: resolvedSpaceId } })
+	}));
+	const archive = yield* Effect.tryPromise(() => space.internal.export({ format: Match.value(format).pipe(Match.when("binary", () => SpaceArchive.Format.BINARY), Match.when("json", () => SpaceArchive.Format.JSON), Match.exhaustive) }));
+	const outputPath = yield* resolveOutputPath(output, archive.filename);
+	yield* fs.makeDirectory(path.dirname(outputPath), { recursive: true });
+	yield* fs.writeFile(outputPath, archive.contents);
+	if (json) yield* Console.log(JSON.stringify({
+		spaceId: resolvedSpaceId,
+		format,
+		path: outputPath,
+		size: archive.contents.length
+	}, null, 2));
+	else {
+		const builder = FormBuilder.make({ title: "Exported Space" }).pipe(FormBuilder.set("spaceId", resolvedSpaceId), FormBuilder.set("format", format), FormBuilder.set("path", outputPath), FormBuilder.set("size", formatBytes(archive.contents.length)));
+		yield* Console.log(print(FormBuilder.build(builder)));
+	}
+});
+var exportSpace = Command.make("export", {
+	spaceId: Common.spaceId.pipe(Options.optional),
+	format: Options.choice("format", Formats).pipe(Options.withDescription("Archive format: binary is a direct dump of the underlying storage and includes document history; json contains current object state only."), Options.withDefault("binary")),
+	output: Options.text("output").pipe(Options.withAlias("o"), Options.withDescription("Output file, or a directory to write the generated filename into."), Options.optional)
+}, (args) => handler$8(args).pipe(withTimeout)).pipe(Command.withDescription("Export a space archive to disk."));
+var resolveOutputPath = Effect.fn(function* (output, filename) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	if (Option.isNone(output)) return path.resolve(filename);
+	const info = yield* fs.stat(output.value).pipe(Effect.option);
+	const isDirectory = Option.isSome(info) && info.value.type === "Directory";
+	return path.resolve(isDirectory ? path.join(output.value, filename) : output.value);
+});
+//#endregion
+//#region src/commands/space/import/import.ts
+/** Reads an archive of either format from disk and creates a new space from it. */
+var handler$7 = Effect.fn(function* ({ file, tags }) {
+	const { json } = yield* CommandConfig;
+	const client = yield* ClientService;
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const contents = yield* fs.readFile(file);
+	const archive = {
+		filename: path.basename(file),
+		contents
+	};
+	const space = yield* Effect.tryPromise(() => client.spaces.import(archive, tags.length > 0 ? { tags: [...tags] } : void 0));
+	if (json) yield* Console.log(JSON.stringify({
+		spaceId: space.id,
+		name: space.properties.name,
+		tags: space.tags,
+		size: contents.length
+	}, null, 2));
+	else {
+		const builder = FormBuilder.make({ title: "Imported Space" }).pipe(FormBuilder.set("spaceId", space.id), FormBuilder.set("name", space.properties.name ?? "<none>"), FormBuilder.set("tags", space.tags.length > 0 ? space.tags.join(", ") : "<none>"), FormBuilder.set("size", formatBytes(contents.length)));
+		yield* Console.log(print(FormBuilder.build(builder)));
+	}
+});
+var importSpace = Command.make("import", {
+	file: Args.file({ name: "file" }).pipe(Args.withDescription("Archive to import, in either binary or json format.")),
+	tags: Options.text("tag").pipe(Options.withDescription("Immutable tag to set on the new space. Repeat to set several."), Options.repeated)
+}, (args) => handler$7(args).pipe(withTimeout)).pipe(Command.withDescription("Import a space archive as a new space."));
+//#endregion
+//#region src/commands/space/info/info.ts
+var handler$6 = Effect.fn(function* ({ spaceId, wait }) {
+	const { json } = yield* CommandConfig;
+	yield* ClientService;
+	const formatted = yield* formatSpace(yield* getSpace$1(yield* spaceIdWithDefault(spaceId)), { waitSeconds: Option.getOrElse(wait, () => 0) });
+	if (json) yield* Console.log(JSON.stringify(formatted, null, 2));
+	else yield* Console.log(print(printSpace(formatted)));
+});
+var info = Command.make("info", {
+	spaceId: Common.spaceId.pipe(Options.optional),
+	wait: Options.integer("wait").pipe(Options.withDescription("Wait up to this many seconds for the space to reach SPACE_READY. Default 0 — read whatever state is available immediately."), Options.optional)
+}, handler$6).pipe(Command.withDescription("Show space info."));
+//#endregion
+//#region src/commands/space/join/util.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-space/src/commands/space/join/util.ts";
+/**
+* Accept an invitation and handle authentication flow.
+* Ported from cli-base to Effect-based approach.
+*/
+var acceptInvitation = ({ observable, callbacks }) => Effect.gen(function* () {
+	const doneQueue = yield* Queue.unbounded();
+	const runCallback = (effect) => {
+		if (effect) EffectEx.runAndForwardErrors(effect).catch(() => {});
+	};
+	const subscription = observable.subscribe((invitation) => {
+		switch (invitation.state) {
+			case Invitation.State.CONNECTING:
+				runCallback(callbacks?.onConnecting?.(invitation));
+				break;
+			case Invitation.State.READY_FOR_AUTHENTICATION:
+				if (invitation.authMethod === Invitation.AuthMethod.SHARED_SECRET) {
+					const callbackEffect = callbacks?.onReadyForAuth?.(invitation) ?? Effect.succeed(void 0);
+					Effect.gen(function* () {
+						const callbackResult = yield* callbackEffect;
+						const code = invitation.authCode ?? callbackResult;
+						invariant(code, "No code provided", {
+							"~LogMeta": "~LogMeta",
+							F: __dxlog_file,
+							L: 52,
+							S: this,
+							A: ["code", "'No code provided'"]
+						});
+						yield* Effect.tryPromise(() => observable.authenticate(code));
+					}).pipe(EffectEx.runAndForwardErrors).catch(() => {});
+				}
+				break;
+			case Invitation.State.SUCCESS:
+				runCallback(callbacks?.onSuccess?.(invitation));
+				EffectEx.runAndForwardErrors(Queue.offer(doneQueue, invitation)).catch(() => {});
+				break;
+		}
+	}, (err) => {
+		if (err instanceof AlreadyJoinedError) {
+			EffectEx.runAndForwardErrors(Queue.offer(doneQueue, observable.get())).catch(() => {});
+			return;
+		}
+		throw err;
+	});
+	const invitation = yield* Queue.take(doneQueue);
+	subscription.unsubscribe();
+	return invitation;
+});
+//#endregion
+//#region src/commands/space/join/join.ts
+var handler$5 = Effect.fn(function* ({ invitationCode, authCode }) {
+	const { json } = yield* CommandConfig;
+	const client = yield* ClientService;
+	let encoded = invitationCode;
+	if (encoded.startsWith("http") || encoded.startsWith("socket")) encoded = new URL(encoded).searchParams.get("spaceInvitationCode") ?? encoded;
+	const spaceKey = (yield* acceptInvitation({
+		observable: client.spaces.join(encoded),
+		callbacks: { onReadyForAuth: (invitation) => {
+			if (Option.isSome(authCode)) return Effect.succeed(Option.getOrUndefined(authCode) ?? void 0);
+			return Prompt.text({ message: "Enter the authentication code" }).pipe(Prompt.run).pipe(Effect.mapError(() => void 0)).pipe(Effect.catchAll(() => Effect.succeed(void 0)));
+		} }
+	})).spaceKey;
+	if (!spaceKey) {
+		if (json) yield* Console.log(JSON.stringify({ error: "No space key in invitation" }, null, 2));
+		else yield* Console.log("No space key in invitation.");
+		return;
+	}
+	let space = client.spaces.get(spaceKey);
+	if (!space) {
+		const maxRetries = 5;
+		const retryDelays = [
+			.5,
+			1,
+			1.5,
+			2,
+			2.5
+		].map((s) => Duration.seconds(s));
+		for (let i = 0; i < maxRetries; i++) {
+			yield* Effect.sleep(retryDelays[i]);
+			space = client.spaces.get(spaceKey);
+			if (space) break;
+		}
+	}
+	if (!space) {
+		if (json) yield* Console.log(JSON.stringify({ error: "Space not found after joining" }, null, 2));
+		else yield* Console.log("Space not found after joining.");
+		return;
+	}
+	yield* Effect.tryPromise(() => space.db.flush());
+	yield* waitForSync(space);
+	if (json) yield* Console.log(JSON.stringify({
+		spaceId: space.id,
+		state: space.state.get()
+	}, null, 2));
+	else {
+		const builder = FormBuilder.make({ title: "Joined Space" }).pipe(FormBuilder.set("spaceId", space.id), FormBuilder.set("key", space.key.truncate()), FormBuilder.set("name", space.properties.name ?? "<none>"));
+		yield* Console.log(print(FormBuilder.build(builder)));
+	}
+});
+var join = Command.make("join", {
+	invitationCode: Args.text({ name: "invitationCode" }).pipe(Args.withDescription("The invitation code.")),
+	authCode: Options.text("authCode").pipe(Options.withDescription("The authentication code."), Options.optional)
+}, handler$5).pipe(Command.withDescription("Join a space via invitation."));
+//#endregion
+//#region src/commands/space/list/list.ts
+var handler$4 = Effect.fn(function* ({ wait }) {
+	const { json } = yield* CommandConfig;
+	const spaces = (yield* ClientService).spaces.get();
+	const waitSeconds = Option.getOrElse(wait, () => 0);
+	const formattedSpaces = yield* Effect.all(spaces.map((space) => formatSpace(space, { waitSeconds })));
+	if (json) yield* Console.log(JSON.stringify(formattedSpaces, null, 2));
+	else {
+		const formatted = formattedSpaces.map(printSpace);
+		yield* Console.log(printList(formatted));
+	}
+});
+var list$1 = Command.make("list", { wait: Options.integer("wait").pipe(Options.withDescription("Wait up to this many seconds for each space to reach SPACE_READY before reading. Default 0 — print whatever state is available immediately so a stuck space cannot hang the command."), Options.optional) }, handler$4).pipe(Command.withDescription("List all spaces available on this device."));
+//#endregion
+//#region src/commands/space/members/util.ts
+var maybeTruncateKey = (key, truncate = false) => truncate ? key.truncate() : key.toHex();
+var mapMembers = (members, truncateKeys = false) => {
+	return members.map((member) => ({
+		key: maybeTruncateKey(member.identity.identityKey, truncateKeys),
+		name: member.identity.profile?.displayName,
+		presence: member.presence === SpaceMember.PresenceState.ONLINE ? "Online" : "Offline"
+	}));
+};
+var printMember = (member) => FormBuilder.make({ title: member.identity.profile?.displayName ?? member.identity.identityKey.truncate() }).pipe(FormBuilder.set("identityKey", member.identity.identityKey.truncate()), FormBuilder.set("displayName", member.identity.profile?.displayName ?? "<none>"), FormBuilder.set("presence", member.presence === SpaceMember.PresenceState.ONLINE ? "Online" : "Offline"), FormBuilder.build);
+var printMembers = (members) => {
+	return members.map(printMember);
+};
+//#endregion
+//#region src/commands/space/members/members.ts
+var handler$3 = Effect.fn(function* ({ spaceId }) {
+	const { json } = yield* CommandConfig;
+	yield* ClientService;
+	const members = (yield* getSpace$1(yield* spaceIdWithDefault(spaceId))).members.get();
+	if (json) yield* Console.log(JSON.stringify(mapMembers(members), null, 2));
+	else {
+		const formatted = printMembers(members);
+		yield* Console.log(printList(formatted));
+	}
+});
+var members = Command.make("members", { spaceId: Common.spaceId.pipe(Options.optional) }, handler$3).pipe(Command.withDescription("List space members."));
+//#endregion
+//#region src/commands/space/open/open.ts
+var handler$2 = ({ spaceId }) => Effect.gen(function* () {
+	const { json } = yield* CommandConfig;
+	yield* ClientService;
+	const space = yield* getSpace$1(spaceId);
+	yield* Effect.tryPromise(() => space.open());
+	yield* Effect.tryPromise(() => space.db.flush());
+	yield* waitForSync(space);
+	if (json) yield* Console.log(JSON.stringify({
+		success: true,
+		spaceId
+	}, null, 2));
+	else yield* Console.log(`Space ${spaceId} opened successfully.`);
+});
+var open = Command.make("open", { spaceId: Common.spaceId.pipe(Options.withDescription("Space ID to open.")) }, handler$2).pipe(Command.withDescription("Open a space."));
+//#endregion
+//#region src/commands/space/schema/list/util.ts
+var mapSchemas = (schemas) => {
+	return schemas.map((schema) => ({
+		id: schema.id,
+		typename: schema.typename,
+		version: schema.version
+	}));
+};
+var printSchema = (schema) => FormBuilder.make({ title: schema.typename }).pipe(FormBuilder.set("id", schema.id ?? "<none>"), FormBuilder.set("typename", schema.typename), FormBuilder.set("version", schema.version), FormBuilder.build);
+var printSchemas = (schemas) => {
+	return schemas.map(printSchema);
+};
+var createTypenameFilter = (typenameFilter) => {
+	if (!typenameFilter) return () => true;
+	return (schema) => schema.typename.toLowerCase().includes(typenameFilter.toLowerCase());
+};
+//#endregion
+//#region src/commands/space/schema/list/list.ts
+var handler$1 = Effect.fn(function* ({ spaceId, typename }) {
+	const { json } = yield* CommandConfig;
+	const schemas = (yield* getSpace$1(yield* spaceIdWithDefault(spaceId))).db.graph.registry.list().filter(Type.isType).map((schema) => {
+		const schemaAnnotation = getTypeAnnotation(Type.getSchema(schema));
+		return {
+			id: Type.getURI(schema).toString(),
+			typename: schemaAnnotation?.typename ?? Type.getTypename(schema) ?? "",
+			version: schemaAnnotation?.version ?? Type.getVersion(schema) ?? ""
+		};
+	}).filter(createTypenameFilter(Option.getOrUndefined(typename)));
+	if (json) yield* Console.log(JSON.stringify(mapSchemas(schemas), null, 2));
+	else {
+		const formatted = printSchemas(schemas);
+		yield* Console.log(printList(formatted));
+	}
+});
+var list = Command.make("list", {
+	spaceId: Common.spaceId.pipe(Options.optional),
+	typename: Options.text("typename").pipe(Options.withDescription("Filter schemas by typename."), Options.optional)
+}, handler$1).pipe(Command.withDescription("List space schemas."));
+//#endregion
+//#region src/commands/space/schema/index.ts
+var schema = Command.make("schema").pipe(Command.withDescription("Manage space schemas."), Command.withSubcommands([list]));
+//#endregion
+//#region src/commands/space/share/share.ts
+var handler = Effect.fn(function* ({ spaceId, multiple, open, host }) {
+	const { json } = yield* CommandConfig;
+	yield* ClientService;
+	const invitation = yield* hostInvitation({
+		observable: (yield* getSpace$1(yield* spaceIdWithDefault(spaceId))).share({
+			authMethod: Invitation.AuthMethod.SHARED_SECRET,
+			persistent: true,
+			multiUse: multiple
+		}),
+		callbacks: { onConnecting: (invitation) => Effect.gen(function* () {
+			const invitationCode = InvitationEncoder.encode(invitation);
+			const authCode = invitation.authCode;
+			yield* copyToClipboard(authCode).pipe(Effect.catchAll(() => Effect.void));
+			if (!json) yield* Console.log(`\nSecret: ${authCode} (copied to clipboard)\n`);
+			if (open) {
+				const url = new URL(host);
+				url.searchParams.append("spaceInvitationCode", invitationCode);
+				yield* openBrowser(url.toString()).pipe(Effect.catchAll(() => Effect.void));
+			} else if (!json) yield* Console.log(`\nInvitation: ${invitationCode}\n`);
+		}) },
+		waitForSuccess: true
+	});
+	if (json) yield* Console.log(JSON.stringify({
+		invitationCode: InvitationEncoder.encode(invitation),
+		authCode: invitation.authCode,
+		state: Invitation.State[invitation.state]
+	}, null, 2));
+	else {
+		const builder = FormBuilder.make({ title: "Space Invitation" }).pipe(FormBuilder.set("invitationCode", InvitationEncoder.encode(invitation)), FormBuilder.set("authCode", invitation.authCode ?? "<none>"), FormBuilder.set("state", Invitation.State[invitation.state]));
+		yield* Console.log(print(FormBuilder.build(builder)));
+	}
+});
+var share = Command.make("share", {
+	spaceId: Common.spaceId.pipe(Options.optional),
+	multiple: Options.boolean("multiple", { ifPresent: true }).pipe(Options.withDescription("Create a multi-use invitation.")),
+	open: Options.boolean("open", { ifPresent: true }).pipe(Options.withDescription("Open browser with invitation.")),
+	host: Options.text("host").pipe(Options.withDescription("Application Host URL."), Options.withDefault("https://composer.space"))
+}, handler).pipe(Command.withDescription("Create space invitation."));
+//#endregion
+//#region src/commands/space/sync/sync.ts
+var sync = Command.make("sync", {
+	spaceId: Common.spaceId.pipe(Options.optional),
+	spaceTimeout: Options.integer("spaceTimeout").pipe(Options.withDescription("The timeout to wait for the space to be available in milliseconds."), Options.withDefault(5e3))
+}, ({ spaceId, spaceTimeout }) => Effect.gen(function* () {
+	yield* waitForSync(yield* getSpace$1(yield* spaceIdWithDefault(spaceId)).pipe(Effect.retry(Schedule.fixed("100 millis")), Effect.timeout(Duration.millis(spaceTimeout))));
+}).pipe(withTimeout)).pipe(Command.withDescription("Wait for a space to be fully synchronized with EDGE."));
+//#endregion
+//#region src/commands/space/index.ts
+var space = Command.make("space").pipe(Command.withDescription("Manage ECHO spaces."), Command.withSubcommands([
+	close,
+	create,
+	exportSpace,
+	importSpace,
+	info,
+	join,
+	list$1,
+	members,
+	open,
+	schema,
+	share,
+	sync
+]));
+//#endregion
+//#region src/SpacePlugin.node.ts
+var SpacePlugin = Plugin.define(meta).pipe(AppPlugin.addCommandModule({ commands: [
+	database,
+	queue,
+	space
+] }), AppPlugin.addCreateObjectModule({ activate: CreateObject }), AppPlugin.addOperationHandlerModule({ activate: OperationHandler }), 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
+] }), Plugin.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(UndoMappings),
+		activatesOn: ActivationEvents.SetupProcessManager,
+		activate: () => UndoMappings({
+			createInvitationUrl,
+			observability: false
+		})
+	};
+}), Plugin.addModule({
+	activatesOn: ClientEvents.IdentityCreated,
+	firesAfterActivation: [SpaceEvents.PersonalSpaceReady],
+	activate: IdentityCreated
+}), Plugin.make);
+//#endregion
+export { SpacePlugin, SpacePlugin as default };
+
+//# sourceMappingURL=SpacePlugin.node.mjs.map