@dxos/plugin-space 0.10.0 → 0.11.1

package/src/collection-path.test.ts

@@ -0,0 +1,161 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import { afterEach, beforeEach, describe, test } from 'vitest';
+
+import { AppAnnotation } from '@dxos/app-toolkit';
+import { SpaceProperties } from '@dxos/client/echo';
+import { Annotation, Collection, Database, Obj, Ref } from '@dxos/echo';
+import { EchoTestBuilder } from '@dxos/echo-client/testing';
+import { EffectEx } from '@dxos/effect';
+
+import { resolveCollectionObjectPath, walkCollectionChainToRoot } from './collection-path';
+
+describe('walkCollectionChainToRoot', () => {
+  let builder: EchoTestBuilder;
+
+  beforeEach(async () => {
+    builder = await new EchoTestBuilder().open();
+  });
+
+  afterEach(async () => {
+    await builder.close();
+  });
+
+  const setup = async () => {
+    const { db } = await builder.createDatabase({ types: [Collection.Collection] });
+    const walk = (objectId: string, rootId: string) =>
+      EffectEx.runPromise(walkCollectionChainToRoot({ objectId, rootId }).pipe(Effect.provide(Database.layer(db))));
+    return { db, walk };
+  };
+
+  /** A collection holding the given objects, added to the database. */
+  const addCollection = (db: Database.Database, objects: Obj.Unknown[]) =>
+    db.add(Collection.make({ objects: objects.map((object) => Ref.make(object)) }));
+
+  test('an object directly in the root collection has an empty chain', async ({ expect }) => {
+    const { db, walk } = await setup();
+    const leaf = db.add(Collection.make());
+    const root = addCollection(db, [leaf]);
+    await db.flush({ indexes: true });
+
+    // Empty rather than null: the object sits directly under `content/collections`, no intermediate ids.
+    expect(await walk(leaf.id, root.id)).toEqual([]);
+  });
+
+  test('a nested object yields its ancestors root-to-leaf', async ({ expect }) => {
+    const { db, walk } = await setup();
+    const leaf = db.add(Collection.make());
+    const inner = addCollection(db, [leaf]);
+    const outer = addCollection(db, [inner]);
+    const root = addCollection(db, [outer]);
+    await db.flush({ indexes: true });
+
+    expect(await walk(leaf.id, root.id)).toEqual([outer.id, inner.id]);
+  });
+
+  test('an object outside the root collection tree has no chain', async ({ expect }) => {
+    const { db, walk } = await setup();
+    const orphan = db.add(Collection.make());
+    const root = addCollection(db, []);
+    await db.flush({ indexes: true });
+
+    expect(await walk(orphan.id, root.id)).toBeNull();
+  });
+
+  test('an object in a collection detached from the root has no chain', async ({ expect }) => {
+    const { db, walk } = await setup();
+    const leaf = db.add(Collection.make());
+    addCollection(db, [leaf]);
+    const root = addCollection(db, []);
+    await db.flush({ indexes: true });
+
+    // The leaf has a parent, but walking up never reaches the root collection.
+    expect(await walk(leaf.id, root.id)).toBeNull();
+  });
+
+  test('a cycle terminates instead of looping', async ({ expect }) => {
+    const { db, walk } = await setup();
+    const first = db.add(Collection.make());
+    const second = addCollection(db, [first]);
+    Obj.update(first, (first) => {
+      first.objects = [Ref.make(second)];
+    });
+    const root = addCollection(db, []);
+    await db.flush({ indexes: true });
+
+    expect(await walk(first.id, root.id)).toBeNull();
+  });
+});
+
+describe('resolveCollectionObjectPath', () => {
+  let builder: EchoTestBuilder;
+
+  beforeEach(async () => {
+    builder = await new EchoTestBuilder().open();
+  });
+
+  afterEach(async () => {
+    await builder.close();
+  });
+
+  const setup = async () => {
+    const { db } = await builder.createDatabase({ types: [Collection.Collection, SpaceProperties] });
+    const resolve = (objectId: string) =>
+      EffectEx.runPromise(resolveCollectionObjectPath({ objectId }).pipe(Effect.provide(Database.layer(db))));
+    return { db, resolve };
+  };
+
+  /** A collection holding the given objects, added to the database. */
+  const addCollection = (db: Database.Database, objects: Obj.Unknown[]) =>
+    db.add(Collection.make({ objects: objects.map((object) => Ref.make(object)) }));
+
+  /** Declare `root` the space's root collection, the way space provisioning does. */
+  const setRootCollection = (db: Database.Database, root: Collection.Collection) => {
+    const properties = db.add(Obj.make(SpaceProperties, {}));
+    Obj.update(properties, (properties) => {
+      Annotation.set(properties, AppAnnotation.RootCollectionAnnotation, Ref.make(root));
+    });
+  };
+
+  test('assembles the nested chain into a collections path, root to leaf', async ({ expect }) => {
+    const { db, resolve } = await setup();
+    const leaf = db.add(Collection.make());
+    const inner = addCollection(db, [leaf]);
+    const outer = addCollection(db, [inner]);
+    setRootCollection(db, addCollection(db, [outer]));
+    await db.flush({ indexes: true });
+
+    expect(await resolve(leaf.id)).toBe(`root/${db.spaceId}/content/collections/${outer.id}/${inner.id}/${leaf.id}`);
+  });
+
+  test('an object directly in the root collection sits directly under the section', async ({ expect }) => {
+    const { db, resolve } = await setup();
+    const leaf = db.add(Collection.make());
+    setRootCollection(db, addCollection(db, [leaf]));
+    await db.flush({ indexes: true });
+
+    expect(await resolve(leaf.id)).toBe(`root/${db.spaceId}/content/collections/${leaf.id}`);
+  });
+
+  test('resolves nothing without a root-collection annotation', async ({ expect }) => {
+    const { db, resolve } = await setup();
+    const leaf = db.add(Collection.make());
+    // Space properties exist but declare no root collection — a space before provisioning.
+    db.add(Obj.make(SpaceProperties, {}));
+    await db.flush({ indexes: true });
+
+    expect(await resolve(leaf.id)).toBeUndefined();
+  });
+
+  test('resolves nothing for an object outside the collection tree', async ({ expect }) => {
+    const { db, resolve } = await setup();
+    const orphan = db.add(Collection.make());
+    setRootCollection(db, addCollection(db, []));
+    await db.flush({ indexes: true });
+
+    expect(await resolve(orphan.id)).toBeUndefined();
+  });
+});

package/src/collection-path.ts

@@ -0,0 +1,97 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { AppAnnotation, GraphPath } from '@dxos/app-toolkit';
+import { SpaceProperties } from '@dxos/client/echo';
+import { Annotation, Collection, Database, Filter } from '@dxos/echo';
+import { EID } from '@dxos/keys';
+
+/** Depth cap for the collection-ancestry walk; the composer nav tree is shallow, this only guards bad data. */
+const COLLECTION_WALK_MAX_DEPTH = 32;
+
+/**
+ * The path under which the nav tree shows an object, when it lives in the space's collection tree:
+ * `content/collections/<ancestors…>/<objectId>`. This is an object's canonical home — the database
+ * path (`system/database/<type>/<objectId>`) exists for every object but names a hidden node — so both
+ * URL resolution and navigation-target resolution answer with this when it exists.
+ *
+ * Returns undefined for an object outside the collection tree (one reachable only via its type
+ * section or the database subtree).
+ */
+export const resolveCollectionObjectPath = ({
+  objectId,
+}: {
+  objectId: string;
+}): Effect.Effect<string | undefined, never, Database.Service> =>
+  Effect.gen(function* () {
+    const { db } = yield* Database.Service;
+    const [properties] = yield* Database.query(Filter.type(SpaceProperties)).run;
+    const rootRef = properties
+      ? Annotation.get(properties, AppAnnotation.RootCollectionAnnotation).pipe(Option.getOrUndefined)
+      : undefined;
+    if (!rootRef) {
+      return undefined;
+    }
+
+    const rootCollection = yield* Database.load(rootRef).pipe(Effect.orElseSucceed(() => undefined));
+    if (!rootCollection) {
+      return undefined;
+    }
+
+    const chain = yield* walkCollectionChainToRoot({ objectId, rootId: rootCollection.id });
+    return chain ? GraphPath.getCollectionsPath(db.spaceId, ...chain, objectId) : undefined;
+  });
+
+/**
+ * Walk up a space's collection tree from `objectId` to the root collection. A single query loads the
+ * space's collections — each already carries its child refs — so the ancestry is a pure in-memory walk
+ * of a child→parent index rather than a query per step. The composer ontology guarantees a tree (an
+ * object lives in one collection, no cycles); on bad data the first indexed parent wins, and a
+ * visited-set plus depth cap stop a cycle from looping. Returns the intermediate collection ids in
+ * root→leaf order (excluding the root collection, whose objects sit directly under
+ * `content/collections`), or null if no path to the root exists.
+ */
+export const walkCollectionChainToRoot = ({
+  objectId,
+  rootId,
+}: {
+  objectId: string;
+  rootId: string;
+}): Effect.Effect<string[] | null, never, Database.Service> =>
+  Effect.gen(function* () {
+    const collections = yield* Database.query(Filter.type(Collection.Collection)).run;
+    const parentOf = new Map<string, string>();
+    for (const collection of collections) {
+      for (const ref of collection.objects ?? []) {
+        const childId = EID.isEID(ref.uri) ? EID.getEntityId(ref.uri) : undefined;
+        if (childId && !parentOf.has(childId)) {
+          parentOf.set(childId, collection.id);
+        }
+      }
+    }
+
+    const visited = new Set<string>([objectId]);
+    // Built leaf→root on the way up; the node id wants root→leaf.
+    const chain: string[] = [];
+    let current = objectId;
+    for (let depth = 0; depth < COLLECTION_WALK_MAX_DEPTH; depth++) {
+      const parent = parentOf.get(current);
+      if (!parent) {
+        return null;
+      }
+      if (parent === rootId) {
+        return chain.reverse();
+      }
+      if (visited.has(parent)) {
+        return null;
+      }
+      visited.add(parent);
+      chain.push(parent);
+      current = parent;
+    }
+    return null;
+  });

package/src/commands/space/export/export.test.ts

@@ -0,0 +1,68 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as NodeContext from '@effect/platform-node/NodeContext';
+import * as FileSystem from '@effect/platform/FileSystem';
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+
+import { TestConsole, TestLayer } from '@dxos/cli-util/testing';
+import { ClientService } from '@dxos/client';
+import { EffectEx } from '@dxos/effect';
+
+import { handler } from './export';
+
+const ExportTestLayer = Layer.mergeAll(TestLayer, NodeContext.layer);
+
+type ExportOutput = { spaceId: string; format: string; path: string; size: number };
+
+describe('space export', () => {
+  it('should write a json export into an output directory', () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const space = yield* createSpace();
+
+      const outputDir = yield* fs.makeTempDirectoryScoped();
+      yield* handler({ spaceId: Option.some(space.id), output: Option.some(outputDir), format: 'json' });
+
+      const { spaceId, format, path, size } = yield* lastOutput();
+      expect(spaceId).toEqual(space.id);
+      expect(format).toEqual('json');
+      expect(path.startsWith(outputDir)).toBe(true);
+      expect(path.endsWith('.dx.json')).toBe(true);
+      expect(size).toBeGreaterThan(0);
+
+      const contents = JSON.parse(yield* fs.readFileString(path));
+      expect(contents.originalSpaceId).toEqual(space.id);
+    }).pipe(Effect.provide(ExportTestLayer), Effect.scoped, EffectEx.runAndForwardErrors));
+
+  it('should write a binary export to an explicit file path', () =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const space = yield* createSpace();
+
+      const outputPath = `${yield* fs.makeTempDirectoryScoped()}/nested/space.tar`;
+      yield* handler({ spaceId: Option.some(space.id), output: Option.some(outputPath), format: 'binary' });
+
+      const { format, path } = yield* lastOutput();
+      expect(format).toEqual('binary');
+      expect(path).toEqual(outputPath);
+      expect((yield* fs.stat(outputPath)).type).toEqual('File');
+    }).pipe(Effect.provide(ExportTestLayer), Effect.scoped, EffectEx.runAndForwardErrors));
+});
+
+const createSpace = Effect.fn(function* () {
+  const client = yield* ClientService;
+  yield* Effect.tryPromise(() => client.halo.createIdentity());
+  const space = yield* Effect.tryPromise(() => client.spaces.create());
+  yield* Effect.tryPromise(() => space.waitUntilReady());
+  return space;
+});
+
+const lastOutput = Effect.fn(function* () {
+  const logger = yield* TestConsole.TestConsole;
+  return TestConsole.parseJson<ExportOutput>(logger.logs[logger.logs.length - 1]);
+});

package/src/commands/space/export/export.ts

@@ -0,0 +1,118 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as Path from '@effect/platform/Path';
+import * as Console from 'effect/Console';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Match from 'effect/Match';
+import * as Option from 'effect/Option';
+
+import {
+  CommandConfig,
+  Common,
+  FormBuilder,
+  formatBytes,
+  getSpace,
+  print,
+  spaceIdWithDefault,
+  withTimeout,
+} from '@dxos/cli-util';
+import { type Key } from '@dxos/echo';
+import { SpaceArchive } from '@dxos/protocols/proto/dxos/client/services';
+
+import { SpaceNotReadyError } from '../../../errors';
+
+const SPACE_READY_TIMEOUT = Duration.seconds(30);
+
+// TODO(wittjosiah): Upstream as SpaceArchive.Formats/SpaceArchive.Format, replacing the proto enum.
+export const Formats = ['binary', 'json'] as const;
+
+export type Format = (typeof Formats)[number];
+
+export type ExportArgs = {
+  spaceId: Option.Option<Key.SpaceId>;
+  output: Option.Option<string>;
+  format: Format;
+};
+
+/** Exports a space in the given archive format and writes it to disk. */
+export const handler = Effect.fn(function* ({ spaceId, output, format }: ExportArgs) {
+  const { json } = yield* CommandConfig;
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+
+  const resolvedSpaceId = yield* spaceIdWithDefault(spaceId);
+  const space = yield* getSpace(resolvedSpaceId);
+
+  // Export reads the epoch root, and a closed space never becomes ready — so cap the wait.
+  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)));
+  }
+});
+
+export const 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' as const),
+    ),
+    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(args).pipe(withTimeout),
+).pipe(Command.withDescription('Export a space archive to disk.'));
+
+const resolveOutputPath = Effect.fn(function* (output: Option.Option<string>, filename: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  if (Option.isNone(output)) {
+    return path.resolve(filename);
+  }
+
+  // An existing directory target keeps the generated space-scoped, timestamped 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);
+});

package/src/commands/space/export/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './export';

package/src/commands/space/import/import.test.ts

@@ -0,0 +1,80 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as NodeContext from '@effect/platform-node/NodeContext';
+import * as FileSystem from '@effect/platform/FileSystem';
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+
+import { TestConsole, TestLayer } from '@dxos/cli-util/testing';
+import { ClientService } from '@dxos/client';
+import { Obj } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
+
+import { type Format, handler as exportSpace } from '../export';
+import { handler as importSpace } from './import';
+
+const ImportTestLayer = Layer.mergeAll(TestLayer, NodeContext.layer);
+
+describe('space import', () => {
+  it('should import a json archive as a new space', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      const { space, path } = yield* exportFixture('json');
+
+      yield* importSpace({ file: path, tags: [] });
+
+      const imported = yield* lastOutput();
+      expect(imported.spaceId).not.toEqual(space.id);
+      expect(client.spaces.get().some(({ id }) => id === imported.spaceId)).toBe(true);
+      expect(imported.name).toEqual('original');
+    }).pipe(Effect.provide(ImportTestLayer), Effect.scoped, EffectEx.runAndForwardErrors));
+
+  it('should import a binary archive as a new space', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      const { space, path } = yield* exportFixture('binary');
+
+      yield* importSpace({ file: path, tags: [] });
+
+      const imported = yield* lastOutput();
+      expect(imported.spaceId).not.toEqual(space.id);
+      expect(client.spaces.get().some(({ id }) => id === imported.spaceId)).toBe(true);
+    }).pipe(Effect.provide(ImportTestLayer), Effect.scoped, EffectEx.runAndForwardErrors));
+
+  it('should apply tags to the imported space', () =>
+    Effect.gen(function* () {
+      const { path } = yield* exportFixture('json');
+
+      yield* importSpace({ file: path, tags: ['imported'] });
+
+      expect((yield* lastOutput()).tags).toContain('imported');
+    }).pipe(Effect.provide(ImportTestLayer), Effect.scoped, EffectEx.runAndForwardErrors));
+});
+
+const lastOutput = Effect.fn(function* () {
+  const logger = yield* TestConsole.TestConsole;
+  return TestConsole.parseJson<{ spaceId: string; name?: string; tags: string[]; path: string }>(
+    logger.logs[logger.logs.length - 1],
+  );
+});
+
+/** Exports a named space and returns the archive path, so import has a real archive to read. */
+const exportFixture = Effect.fn(function* (format: Format) {
+  const fs = yield* FileSystem.FileSystem;
+  const client = yield* ClientService;
+  yield* Effect.tryPromise(() => client.halo.createIdentity());
+  const space = yield* Effect.tryPromise(() => client.spaces.create());
+  yield* Effect.tryPromise(() => space.waitUntilReady());
+  Obj.update(space.properties, (obj) => {
+    obj.name = 'original';
+  });
+  yield* Effect.tryPromise(() => space.db.flush());
+
+  const outputDir = yield* fs.makeTempDirectoryScoped();
+  yield* exportSpace({ spaceId: Option.some(space.id), output: Option.some(outputDir), format });
+  return { space, path: (yield* lastOutput()).path };
+});

package/src/commands/space/import/import.ts

@@ -0,0 +1,65 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Args from '@effect/cli/Args';
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as Path from '@effect/platform/Path';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+
+import { CommandConfig, FormBuilder, formatBytes, print, withTimeout } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+import { type SpaceArchive } from '@dxos/protocols/proto/dxos/client/services';
+
+export type ImportArgs = {
+  file: string;
+  tags: ReadonlyArray<string>;
+};
+
+/** Reads an archive of either format from disk and creates a new space from it. */
+export const handler = Effect.fn(function* ({ file, tags }: ImportArgs) {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+
+  const contents = yield* fs.readFile(file);
+  // Format is left unset so the host detects it from the extension, falling back to sniffing contents.
+  const archive: SpaceArchive = { filename: path.basename(file), contents };
+  const space = yield* Effect.tryPromise(() =>
+    client.spaces.import(archive, tags.length > 0 ? { tags: [...tags] } : undefined),
+  );
+
+  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)));
+  }
+});
+
+export const 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(args).pipe(withTimeout),
+).pipe(Command.withDescription('Import a space archive as a new space.'));

package/src/commands/space/import/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './import';

package/src/commands/space/index.ts

@@ -6,6 +6,8 @@ import * as Command from '@effect/cli/Command';
 
 import { close } from './close';
 import { create } from './create';
+import { exportSpace } from './export';
+import { importSpace } from './import';
 import { info } from './info';
 import { join } from './join';
 import { list } from './list';
@@ -17,5 +19,18 @@ import { sync } from './sync';
 
 export const space = Command.make('space').pipe(
   Command.withDescription('Manage ECHO spaces.'),
-  Command.withSubcommands([close, create, info, join, list, members, open, schema, share, sync]),
+  Command.withSubcommands([
+    close,
+    create,
+    exportSpace,
+    importSpace,
+    info,
+    join,
+    list,
+    members,
+    open,
+    schema,
+    share,
+    sync,
+  ]),
 );

package/src/components/AwaitingObject/AwaitingObject.tsx

@@ -2,14 +2,15 @@
 // Copyright 2023 DXOS.org
 //
 
-import React, { useCallback, useEffect, useState } from 'react';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
 
 import { useOperationInvoker } from '@dxos/app-framework/ui';
 import { LayoutOperation } from '@dxos/app-toolkit';
 import { useLayout } from '@dxos/app-toolkit/ui';
-import { Filter, Obj } from '@dxos/echo';
+import { Filter, Obj, Query } from '@dxos/echo';
+import { useQuery } from '@dxos/echo-react';
 import { useClient } from '@dxos/react-client';
-import { useQuery } from '@dxos/react-client/echo';
+import { useSpaces } from '@dxos/react-client/echo';
 import { Button, Icon, Toast, useTranslation } from '@dxos/react-ui';
 import { osTranslations } from '@dxos/ui-theme';
 
@@ -28,7 +29,12 @@ export const AwaitingObject = ({ id }: { id: string }) => {
   const layout = useLayout();
 
   const client = useClient();
-  const objects = useQuery(client.spaces, Filter.everything());
+  // The awaited object may land in any space, so this queries the whole graph — which, unlike
+  // `db.query`, does not scope itself: an unscoped query reaches the planner and throws
+  // ("Query must be scoped with a from() clause"), killing whatever rendered this toast.
+  const spaces = useSpaces();
+  const query = useMemo(() => Query.select(Filter.everything()).from(spaces.map((space) => space.db)), [spaces]);
+  const objects = useQuery(client.spaces, query);
 
   useEffect(() => {
     if (!id) {