@dxos/plugin-space 0.8.4-main.70d3990 → 0.8.4-main.74a063c4e0

package/src/capabilities/undo-mappings.ts

@@ -0,0 +1,59 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability, UndoMapping } from '@dxos/app-framework';
+import { Obj } from '@dxos/echo';
+
+import { meta } from '#meta';
+import { SpaceOperation } from '#operations';
+
+import { SpaceOperationConfig } from '../operations/helpers';
+
+type UndoMappingsOptions = {
+  createInvitationUrl: (invitationCode: string) => string;
+  observability?: boolean;
+};
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* ({ createInvitationUrl, observability }: UndoMappingsOptions) {
+    return [
+      Capability.contributes(Capabilities.UndoMapping, [
+        UndoMapping.make({
+          operation: SpaceOperation.DeleteField,
+          inverse: SpaceOperation.RestoreField,
+          deriveContext: (input, output) => ({
+            view: input.view,
+            field: output.field,
+            props: output.props,
+            index: output.index,
+          }),
+          message: ['field-deleted.label', { ns: meta.id }],
+        }),
+        UndoMapping.make({
+          operation: SpaceOperation.RemoveObjects,
+          inverse: SpaceOperation.RestoreObjects,
+          deriveContext: (_input, output) => ({
+            objects: output.objects,
+            parentCollection: output.parentCollection,
+            indices: output.indices,
+            nestedObjectsList: output.nestedObjectsList,
+            wasActive: output.wasActive,
+          }),
+          message: (input, _output) => {
+            const ns = Obj.getTypename(input.objects[0]);
+            return ns && input.objects.length === 1
+              ? ['object-deleted.label', { ns }]
+              : ['objects-deleted.label', { ns: meta.id }];
+          },
+        }),
+      ]),
+      Capability.contributes(SpaceOperationConfig, {
+        createInvitationUrl,
+        observability: observability ?? false,
+      }),
+    ];
+  }),
+);

package/src/cli/commands/database/add.ts

@@ -0,0 +1,110 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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 type * as Schema from 'effect/Schema';
+
+// eslint-disable-next-line unused-imports/no-unused-imports
+import { type Capability, 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, Type } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
+import { EntityKind, getTypeAnnotation } from '@dxos/echo/internal';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Operation } from '@dxos/operation';
+
+import { type CreateObject } from '#types';
+
+import { printObject } from './util';
+
+export type Metadata = {
+  createObject: CreateObject;
+  inputSchema?: Schema.Schema.AnyNoContext;
+};
+
+export const 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 = (typename: string) => {
+        const metadata = manager.capabilities
+          .getAll(AppCapabilities.Metadata)
+          .find(({ id }) => id === typename)?.metadata;
+        return metadata?.createObject ? (metadata as Metadata) : undefined;
+      };
+
+      const [properties] = yield* Database.runQuery(Filter.type(SpaceProperties));
+      const collection = yield* Database.load<Collection.Collection>(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 result = yield* metadata.createObject({}, { db, target: collection });
+      const object = result.object;
+      if (!Obj.isObject(object)) {
+        return yield* Effect.fail(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.
+ */
+const selectTypename = Effect.fn(function* (resolve: (typename: string) => Metadata | undefined) {
+  const schemas = yield* Database.runSchemaQuery({
+    location: ['database', 'runtime'],
+    includeSystem: false,
+  }).pipe(
+    Effect.map((schemas) => schemas.filter((schema) => getTypeAnnotation(schema)?.kind !== EntityKind.Relation)),
+    Effect.map((schemas) => schemas.filter((schema) => !!resolve(Type.getTypename(schema)))),
+  );
+
+  const choices = schemas.map((schema) => ({
+    // TODO(wittjosiah): Translations.
+    title: Type.getTypename(schema),
+    value: Type.getTypename(schema),
+    description: Type.getTypename(schema),
+  }));
+
+  const selected = yield* Prompt.select({
+    message: 'Select a type:',
+    choices,
+  });
+
+  return selected;
+});

package/src/cli/commands/database/index.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+
+import { add } from './add';
+import { query } from './query';
+import { remove } from './remove';
+import { stats } from './stats';
+
+// TODO(wittjosiah): Alias to `db`.
+export const database: Command.Command<any, any, any, any> = Command.make('database').pipe(
+  Command.withDescription('Database access.'),
+  Command.withSubcommands([add, query, remove, stats]),
+);

package/src/cli/commands/database/query/query.test.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { spaceLayer } from '@dxos/cli-util';
+import { TestConsole, TestLayer } from '@dxos/cli-util/testing';
+import { ClientService } from '@dxos/client';
+import { Obj } from '@dxos/echo';
+import { runAndForwardErrors } from '@dxos/effect';
+import { Task } from '@dxos/types';
+
+import { handler } from './query';
+
+describe('spaces query', () => {
+  it('should query empty space', () =>
+    Effect.gen(function* () {
+      // TODO(wittjosiah): Create test runtime so that client service can be shared with `beforeEach`.
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      const space = yield* Effect.tryPromise(() => client.spaces.create());
+      yield* Effect.tryPromise(() => space.waitUntilReady());
+      yield* handler({ typename: Option.some(Task.Task.typename) }).pipe(
+        Effect.provide(spaceLayer(Option.some(space.id))),
+      );
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      expect(TestConsole.extractJsonString(logs[0])).toEqual('[]');
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+
+  it('should query space for objects', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.addTypes([Task.Task]));
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      const space = yield* Effect.tryPromise(() => client.spaces.create());
+      yield* Effect.tryPromise(() => space.waitUntilReady());
+      space.db.add(Obj.make(Task.Task, { title: 'Task 1' }));
+      space.db.add(Obj.make(Task.Task, { title: 'Task 2' }));
+      yield* handler({ typename: Option.some(Task.Task.typename) }).pipe(
+        Effect.provide(spaceLayer(Option.some(space.id))),
+      );
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      const formattedObjects = TestConsole.parseJson(logs[0]);
+      expect(formattedObjects).toHaveLength(2);
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+});

package/src/cli/commands/database/query/query.ts

@@ -0,0 +1,44 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { CommandConfig, Common, printList, spaceLayer } from '@dxos/cli-util';
+import { Database, Filter } from '@dxos/echo';
+
+import { printObject } from '../util';
+
+export const handler = ({ typename }: { typename: Option.Option<string> }) =>
+  Effect.gen(function* () {
+    const { json } = yield* CommandConfig;
+    const filter = Option.match(typename, {
+      onNone: () => Filter.everything(),
+      onSome: (typename) => Filter.typename(typename),
+    });
+    const objects = yield* Database.runQuery(filter);
+
+    if (json) {
+      yield* Console.log(JSON.stringify(objects, null, 2));
+    } else {
+      // TODO(wittjosiah): Interactive table of results.
+      const formatted = objects.map(printObject);
+      yield* Console.log(printList(formatted));
+    }
+  });
+
+export const query = Command.make(
+  'query',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    typename: Options.text('typename').pipe(Options.optional, Options.withDescription('The typename to query.')),
+  },
+  handler,
+).pipe(
+  Command.withDescription('Query objects.'),
+  Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
+);

package/src/cli/commands/database/remove.ts

@@ -0,0 +1,51 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { CommandConfig, Common, print, spaceLayer } from '@dxos/cli-util';
+import { Database, Filter, Query } from '@dxos/echo';
+
+import { printObjectRemoved } from './util';
+
+export const 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: Query.Any;
+      if (Option.isSome(id)) {
+        query = Query.select(Filter.id(id.value));
+      } else if (Option.isSome(typename)) {
+        query = Query.select(Filter.typename(typename.value));
+      } else {
+        throw new Error('Must specify typename or id');
+      }
+      const objects = yield* Database.runQuery(query);
+      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)),
+);

package/src/cli/commands/database/stats.ts

@@ -0,0 +1,44 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Array from 'effect/Array';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Record from 'effect/Record';
+
+import { CommandConfig, Common, printList, spaceLayer } from '@dxos/cli-util';
+import { Obj } from '@dxos/echo';
+import { Database, Filter, Query } from '@dxos/echo';
+
+import { printStats } from './util';
+
+export const stats = Command.make(
+  'stats',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+  },
+  () =>
+    Effect.gen(function* () {
+      const { json } = yield* CommandConfig;
+      const objects = yield* Database.runQuery(Query.select(Filter.everything()));
+      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)),
+);

package/src/cli/commands/database/util.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { FormBuilder } from '@dxos/cli-util';
+import { Entity } from '@dxos/echo';
+
+/**
+ * Pretty prints an object with ANSI colors.
+ */
+export const printObject = (obj: Entity.Unknown) => {
+  const typename = Entity.getTypename(obj) ?? '<unknown>';
+
+  // TODO(wittjosiah): Obj.getSchema and thus Obj.getLabel are coming back undefined for some reason.
+  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.
+ */
+export const printStats = (typename: string, count: number) =>
+  FormBuilder.make({ title: typename }).pipe(FormBuilder.set('count', count), FormBuilder.build);
+
+/**
+ * Pretty prints object removal result with ANSI colors.
+ */
+export const printObjectRemoved = (count: number) =>
+  FormBuilder.make({ title: 'Objects removed' }).pipe(FormBuilder.set('count', count), FormBuilder.build);

package/src/cli/commands/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './database';
+export * from './queue';
+export * from './space';

package/src/cli/commands/queue/index.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+
+import { query } from './query';
+
+export const queue = Command.make('queue').pipe(
+  Command.withDescription('Manage queues.'),
+  Command.withSubcommands([query]),
+);

package/src/cli/commands/queue/query.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { CommandConfig, printList } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+import { type Queue } from '@dxos/client/echo';
+import { DXN } from '@dxos/keys';
+
+import { printQueueObject } from './util';
+
+// TODO(dmaretskyi): Extract
+const DXNSchema = Schema.String.pipe(
+  Schema.transform(Schema.instanceOf(DXN), {
+    decode: (value: string) => DXN.parse(value),
+    encode: (value: DXN) => value.toString(),
+  }),
+);
+
+export const query = Command.make(
+  'query',
+  {
+    dxn: Options.text('dxn').pipe(Options.withDescription('DXN of the queue.'), Options.withSchema(DXNSchema)),
+  },
+  Effect.fnUntraced(function* ({ dxn }) {
+    const { json } = yield* CommandConfig;
+    const client = yield* ClientService;
+    const queue = (yield* Effect.promise(() => client.graph.createRefResolver({}).resolve(dxn))) as Queue<any>;
+    const objects = yield* Effect.promise(() => queue.queryObjects());
+
+    if (json) {
+      yield* Console.log(JSON.stringify(objects, null, 2));
+    } else {
+      // TODO(wittjosiah): Interactive table of results.
+      const formatted = objects.map(printQueueObject);
+      yield* Console.log(printList(formatted));
+    }
+  }),
+).pipe(Command.withDescription('Query objects in a queue.'));

package/src/cli/commands/queue/util.ts

@@ -0,0 +1,19 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { FormBuilder } from '@dxos/cli-util';
+import { Entity } from '@dxos/echo';
+
+/**
+ * Pretty prints a queue object with ANSI colors.
+ */
+export const printQueueObject = (obj: Entity.Any) => {
+  const typename = Entity.getTypename(obj) ?? '<unknown>';
+
+  return FormBuilder.make({ title: typename }).pipe(
+    FormBuilder.set('id', obj.id),
+    FormBuilder.set('typename', typename),
+    FormBuilder.build,
+  );
+};

package/src/cli/commands/space/close/close.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+
+import { CommandConfig, Common, getSpace, waitForSync } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+import { type Key } from '@dxos/echo';
+
+export const handler = ({ spaceId }: { spaceId: Key.SpaceId }) =>
+  Effect.gen(function* () {
+    const { json } = yield* CommandConfig;
+    const client = yield* ClientService;
+
+    const space = yield* getSpace(spaceId);
+
+    // Flush and sync before closing
+    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.`);
+    }
+  });
+
+export const close = Command.make(
+  'close',
+  {
+    spaceId: Common.spaceId.pipe(Options.withDescription('Space ID to close.')),
+  },
+  handler,
+).pipe(Command.withDescription('Close a space.'));

package/src/{components/JoinDialog → cli/commands/space/close}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './JoinDialog';
+export * from './close';

package/src/cli/commands/space/create/create.test.ts

@@ -0,0 +1,67 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { TestConsole, TestLayer } from '@dxos/cli-util/testing';
+import { ClientService } from '@dxos/client';
+import { runAndForwardErrors } from '@dxos/effect';
+
+import { handler } from './create';
+
+describe('space create', () => {
+  it('should create a space without a name', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      const logger = yield* TestConsole.TestConsole;
+      // Catch timeout errors from sync, but still check output
+      yield* handler({ name: Option.none() }).pipe(Effect.catchAll(() => Effect.void));
+      const logs = logger.logs;
+      // Find the JSON output (should be logged before sync)
+      // log.args is an array, so we need to check the first element
+      const jsonLog = logs.find((log) => {
+        if (log.level === 'log' && Array.isArray(log.args) && log.args.length > 0) {
+          const firstArg = String(log.args[0]);
+          return firstArg.trim().startsWith('{');
+        }
+        return false;
+      });
+      expect(jsonLog).toBeDefined();
+      if (jsonLog && Array.isArray(jsonLog.args) && jsonLog.args.length > 0) {
+        const parsed = JSON.parse(String(jsonLog.args[0]));
+        expect(parsed).toHaveProperty('key');
+        expect(typeof parsed.key).toBe('string');
+        // name might be undefined and omitted from JSON, which is fine
+      }
+      expect(client.spaces.get().length).toBeGreaterThan(0);
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+
+  it('should create a space with a name', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      const logger = yield* TestConsole.TestConsole;
+      // Catch timeout errors from sync, but still check output
+      yield* handler({ name: Option.some('Test Space') }).pipe(Effect.catchAll(() => Effect.void));
+      const logs = logger.logs;
+      // Find the JSON output (should be logged before sync)
+      // log.args is an array, so we need to check the first element
+      const jsonLog = logs.find((log) => {
+        if (log.level === 'log' && Array.isArray(log.args) && log.args.length > 0) {
+          const firstArg = String(log.args[0]);
+          return firstArg.trim().startsWith('{');
+        }
+        return false;
+      });
+      expect(jsonLog).toBeDefined();
+      if (jsonLog && Array.isArray(jsonLog.args) && jsonLog.args.length > 0) {
+        const parsed = JSON.parse(String(jsonLog.args[0]));
+        expect(parsed).toHaveProperty('key');
+        expect(parsed).toHaveProperty('name', 'Test Space');
+      }
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+});

package/src/cli/commands/space/create/create.ts

@@ -0,0 +1,61 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { CommandConfig } from '@dxos/cli-util';
+import { print, waitForSync } from '@dxos/cli-util';
+import { FormBuilder } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+import { Obj } from '@dxos/echo';
+
+export const handler = Effect.fn(function* ({ name }: { name: Option.Option<string> }) {
+  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.change(space.properties, (obj) => {
+      obj.name = Option.getOrUndefined(name);
+    });
+  }
+
+  // Output first, then flush and sync
+  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)));
+  }
+
+  // Flush and sync before completion
+  yield* Effect.tryPromise(() => space.db.flush());
+  yield* waitForSync(space);
+});
+
+export const create = Command.make(
+  'create',
+  {
+    name: Options.text('name').pipe(Options.withDescription('The name of the space.'), Options.optional),
+  },
+  handler,
+).pipe(Command.withDescription('Create a new space.'));