@dxos/plugin-space 0.8.4-main.4a85c3132b → 0.8.4-main.4f23b4e393

package/src/capabilities/spaces-ready/spaces-ready.ts

@@ -1,290 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import * as Option from 'effect/Option';
-
-import { Capabilities, Capability } from '@dxos/app-framework';
-import { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
-import { SubscriptionList } from '@dxos/async';
-import { Filter, Obj } from '@dxos/echo';
-import { log } from '@dxos/log';
-import { AttentionCapabilities } from '@dxos/plugin-attention';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { Graph } from '@dxos/plugin-graph';
-import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
-import { PublicKey } from '@dxos/react-client';
-import { SPACE_ID_LENGTH, SpaceState, parseId } from '@dxos/react-client/echo';
-import { Expando } from '@dxos/schema';
-import { ComplexMap, reduceGroupBy } from '@dxos/util';
-
-import { SpaceCapabilities, SpaceOperation } from '../../types';
-import { COMPOSER_SPACE_LOCK, SHARED } from '../../util';
-
-const ACTIVE_NODE_BROADCAST_INTERVAL = 30_000;
-const WAIT_FOR_OBJECT_TIMEOUT = 5_000;
-
-// E.g., dxn:echo:BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE:01J00J9B45YHYSGZQTQMSKMGJ6
-const ECHO_DXN_LENGTH = 3 + 1 + 4 + 1 + 33 + 1 + 26;
-
-export default Capability.makeModule(
-  Effect.fnUntraced(function* () {
-    const subscriptions = new SubscriptionList();
-    const spaceSubscriptions = new SubscriptionList();
-
-    const { invoke, invokePromise } = yield* Capability.get(Capabilities.OperationInvoker);
-    const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
-    const registry = yield* Capability.get(Capabilities.AtomRegistry);
-    const layoutAtom = yield* Capability.get(AppCapabilities.Layout);
-    const attention = yield* Capability.get(AttentionCapabilities.Attention);
-    const stateAtom = yield* Capability.get(SpaceCapabilities.State);
-    const ephemeralAtom = yield* Capability.get(SpaceCapabilities.EphemeralState);
-    const client = yield* Capability.get(ClientCapabilities.Client);
-
-    const defaultSpace = client.spaces.default;
-    yield* Effect.tryPromise(() => defaultSpace.waitUntilReady());
-
-    // Check if deck state indicates we should switch to default space.
-    const layout = registry.get(layoutAtom);
-    if (layout.workspace === 'default') {
-      yield* invoke(LayoutOperation.SwitchWorkspace, { subject: defaultSpace.id });
-    }
-
-    // Initialize space sharing lock in default space.
-    if (typeof defaultSpace.properties[COMPOSER_SPACE_LOCK] !== 'boolean') {
-      Obj.change(defaultSpace.properties, (p) => {
-        p[COMPOSER_SPACE_LOCK] = true;
-      });
-    }
-
-    const queryResults = yield* Effect.tryPromise(() =>
-      defaultSpace.db.query(Filter.type(Expando.Expando, { key: SHARED })).run(),
-    );
-    const spacesOrder = queryResults[0];
-    if (!spacesOrder) {
-      // TODO(wittjosiah): Cannot be a Folder because Spaces are not TypedObjects so can't be saved in the database.
-      //  Instead, we store order as an array of space ids.
-      defaultSpace.db.add(Obj.make(Expando.Expando, { key: SHARED, order: [] }));
-    }
-
-    // Await missing objects - subscribe to layout atom changes.
-    // NOTE: Use immediate: true to check initial state (URL handler may have already set active).
-    let lastActiveCleanup: (() => void) | undefined;
-    subscriptions.add(
-      registry.subscribe(
-        layoutAtom,
-        (layout) => {
-          // Clean up previous effect.
-          lastActiveCleanup?.();
-          lastActiveCleanup = undefined;
-
-          // Determine the ID to check - either from active item or workspace.
-          const id = layout.active.length === 1 ? layout.active[0] : layout.workspace;
-          if (!id) {
-            return;
-          }
-
-          const node = Graph.getNode(graph, id).pipe(Option.getOrNull);
-          if (!node && (id.length === ECHO_DXN_LENGTH || id.length === SPACE_ID_LENGTH)) {
-            void Graph.initialize(graph, id);
-            const timeout = setTimeout(async () => {
-              const node = Graph.getNode(graph, id).pipe(Option.getOrNull);
-              if (!node) {
-                await invokePromise(SpaceOperation.WaitForObject, { id });
-              }
-            }, WAIT_FOR_OBJECT_TIMEOUT);
-
-            lastActiveCleanup = () => clearTimeout(timeout);
-          }
-        },
-        { immediate: true },
-      ),
-    );
-    // Also add cleanup for the last effect.
-    subscriptions.add(() => lastActiveCleanup?.());
-
-    // Cache space names.
-    subscriptions.add(
-      client.spaces.subscribe(async (spaces) => {
-        // TODO(wittjosiah): Remove. This is a hack to be able to migrate the default space properties.
-        if (defaultSpace.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
-          await defaultSpace.internal.migrate();
-        }
-
-        spaces
-          .filter((space) => space.state.get() === SpaceState.SPACE_READY)
-          .forEach((space) => {
-            const updateSpaceName = () => {
-              const name = space.properties.name;
-              if (!name) {
-                registry.update(stateAtom, (current) => {
-                  const { [space.id]: _, ...rest } = current.spaceNames;
-                  return { ...current, spaceNames: rest };
-                });
-              } else {
-                registry.update(stateAtom, (current) => ({
-                  ...current,
-                  spaceNames: { ...current.spaceNames, [space.id]: name },
-                }));
-              }
-            };
-            updateSpaceName();
-            subscriptions.add(Obj.subscribe(space.properties, updateSpaceName));
-          });
-      }).unsubscribe,
-    );
-
-    // Broadcast active node to other peers in the space - subscribe to both layout and attention.
-    let broadcastCleanup: (() => void) | undefined;
-    const setupBroadcast = () => {
-      broadcastCleanup?.();
-
-      const layout = registry.get(layoutAtom);
-      const current = attention.getCurrent();
-      const active = layout.active;
-      const inactive = layout.inactive;
-
-      const send = () => {
-        const spaces = client.spaces.get();
-        const identity = client.halo.identity.get();
-        if (identity) {
-          // Group parts by space for efficient messaging.
-          const idsBySpace = reduceGroupBy(active, (id: string) => {
-            try {
-              const { spaceId } = parseId(id);
-              return spaceId;
-            } catch {
-              return null;
-            }
-          });
-
-          const removedBySpace = reduceGroupBy(inactive, (id: string) => {
-            try {
-              const { spaceId } = parseId(id);
-              return spaceId;
-            } catch {
-              return null;
-            }
-          });
-
-          // NOTE: Ensure all spaces are included so that we send the correct `removed` object arrays.
-          for (const space of spaces) {
-            if (!idsBySpace.has(space.id)) {
-              idsBySpace.set(space.id, []);
-            }
-          }
-
-          for (const [spaceId, added] of idsBySpace) {
-            const removed = removedBySpace.get(spaceId) ?? [];
-            const space = spaces.find((space) => space.id === spaceId);
-            if (!space) {
-              continue;
-            }
-
-            void space
-              .postMessage('viewing', {
-                identityKey: identity.identityKey.toHex(),
-                attended: current,
-                added,
-                removed,
-              })
-              // TODO(burdon): This seems defensive; why would this fail? Backoff interval.
-              .catch((err) => {
-                log.warn('Failed to broadcast active node for presence.', {
-                  err: err.message,
-                });
-              });
-          }
-        }
-      };
-
-      send();
-      // Send at interval to allow peers to expire entries if they become disconnected.
-      const interval = setInterval(() => send(), ACTIVE_NODE_BROADCAST_INTERVAL);
-      broadcastCleanup = () => clearInterval(interval);
-    };
-
-    // Subscribe to layout changes for broadcast.
-    subscriptions.add(registry.subscribe(layoutAtom, setupBroadcast));
-    // Subscribe to attention.current changes.
-    subscriptions.add(attention.subscribeCurrent(() => setupBroadcast()));
-    // Initial setup.
-    setupBroadcast();
-    // Cleanup.
-    subscriptions.add(() => broadcastCleanup?.());
-
-    // Listen for active nodes from other peers in the space.
-    subscriptions.add(
-      client.spaces.subscribe((spaces) => {
-        spaceSubscriptions.clear();
-        spaces.forEach((space) => {
-          spaceSubscriptions.add(
-            space.listen('viewing', (message) => {
-              const { added, removed, attended } = message.payload;
-
-              const identityKey = PublicKey.safeFrom(message.payload.identityKey);
-              const currentIdentity = client.halo.identity.get();
-              if (
-                identityKey &&
-                !currentIdentity?.identityKey.equals(identityKey) &&
-                Array.isArray(added) &&
-                Array.isArray(removed)
-              ) {
-                // TODO(wittjosiah): Stop using (Complex)Map inside reactive object.
-                registry.update(ephemeralAtom, (ephemeral) => {
-                  added.forEach((id) => {
-                    if (typeof id === 'string') {
-                      if (!(id in ephemeral.viewersByObject)) {
-                        ephemeral.viewersByObject[id] = new ComplexMap(PublicKey.hash);
-                      }
-                      ephemeral.viewersByObject[id]!.set(identityKey, {
-                        lastSeen: Date.now(),
-                        currentlyAttended: new Set(attended).has(id),
-                      });
-                      if (!ephemeral.viewersByIdentity.has(identityKey)) {
-                        ephemeral.viewersByIdentity.set(identityKey, new Set());
-                      }
-                      ephemeral.viewersByIdentity.get(identityKey)!.add(id);
-                    }
-                  });
-
-                  removed.forEach((id) => {
-                    if (typeof id === 'string') {
-                      ephemeral.viewersByObject[id]?.delete(identityKey);
-                      ephemeral.viewersByIdentity.get(identityKey)?.delete(id);
-                      // It's okay for these to be empty sets/maps, reduces churn.
-                    }
-                  });
-
-                  return { ...ephemeral };
-                });
-              }
-            }),
-          );
-        });
-      }).unsubscribe,
-    );
-
-    // Enable edge replication for all spaces.
-    try {
-      yield* Effect.tryPromise(() =>
-        Promise.all(
-          client.spaces
-            .get()
-            .map((space) => space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED)),
-        ),
-      );
-      registry.update(stateAtom, (current) => ({ ...current, enabledEdgeReplication: true }));
-    } catch (err) {
-      log.catch(err);
-    }
-
-    return Capability.contributes(Capabilities.Null, null, () =>
-      Effect.sync(() => {
-        spaceSubscriptions.clear();
-        subscriptions.clear();
-      }),
-    );
-  }),
-);

package/src/capabilities/state/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capability } from '@dxos/app-framework';
-
-export const SpaceState = Capability.lazy('SpaceState', () => import('./state'));

package/src/capabilities/state/state.ts

@@ -1,64 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Atom } from '@effect-atom/atom-react';
-import * as Effect from 'effect/Effect';
-
-import { Capabilities, Capability } from '@dxos/app-framework';
-import { createKvsStore } from '@dxos/effect';
-import { PublicKey } from '@dxos/keys';
-import { ComplexMap } from '@dxos/util';
-
-import { meta } from '../../meta';
-import { SpaceCapabilities } from '../../types';
-
-/** Default persisted state. */
-const defaultSpaceState: SpaceCapabilities.SpaceState = {
-  spaceNames: {},
-  enabledEdgeReplication: false,
-};
-
-export default Capability.makeModule(
-  Effect.fnUntraced(function* () {
-    const registry = yield* Capability.get(Capabilities.AtomRegistry);
-
-    // Persisted state using KVS store.
-    const stateAtom = createKvsStore({
-      key: `${meta.id}/state`,
-      schema: SpaceCapabilities.StateSchema,
-      defaultValue: () => ({ ...defaultSpaceState }),
-    });
-
-    // Ephemeral state (not persisted, but kept alive to prevent GC resets).
-    const ephemeralAtom = Atom.make<SpaceCapabilities.SpaceEphemeralState>({
-      awaiting: undefined,
-      sdkMigrationRunning: {},
-      navigableCollections: false,
-      viewersByObject: {},
-      viewersByIdentity: new ComplexMap<PublicKey, Set<string>>(PublicKey.hash),
-    }).pipe(Atom.keepAlive);
-
-    const manager = yield* Capability.get(Capabilities.PluginManager);
-    // Update navigableCollections based on plugin state.
-    const updateNavigableCollections = () => {
-      const enabled = manager.getEnabled().includes('dxos.org/plugin/stack');
-      const current = registry.get(ephemeralAtom);
-      if (enabled !== current.navigableCollections) {
-        registry.update(ephemeralAtom, (c) => ({ ...c, navigableCollections: enabled }));
-      }
-    };
-    // Check initial state and subscribe to changes.
-    updateNavigableCollections();
-    const unsubscribe = registry.subscribe(manager.enabled, updateNavigableCollections);
-
-    return [
-      Capability.contributes(SpaceCapabilities.State, stateAtom),
-      Capability.contributes(SpaceCapabilities.EphemeralState, ephemeralAtom, () =>
-        Effect.sync(() => {
-          unsubscribe();
-        }),
-      ),
-    ];
-  }),
-);

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

@@ -1,115 +0,0 @@
-//
-// 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, Ref, 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;
-  addToCollectionOnCreate?: boolean;
-};
-
-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 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)),
-);
-
-/**
- * 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/query/query.test.ts

@@ -1,55 +0,0 @@
-//
-// 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());
-      yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
-      yield* Effect.tryPromise(() => client.spaces.default.waitUntilReady());
-      const space = client.spaces.default;
-      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());
-      yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
-      const space = client.spaces.default;
-      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/stats.ts

@@ -1,44 +0,0 @@
-//
-// 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/queue/query.ts

@@ -1,45 +0,0 @@
-//
-// 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/space/close/close.ts

@@ -1,40 +0,0 @@
-//
-// 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({ indexes: true }));
-    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.'));