@dxos/cli-util 0.8.4-main.9be5663bfe → 0.8.4-main.abd8ff62ef

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/cli-util",
-  "version": "0.8.4-main.9be5663bfe",
+  "version": "0.8.4-main.abd8ff62ef",
   "description": "Shared CLI utilities for DXOS CLI commands and plugins",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -33,21 +33,22 @@
     "@effect/cli": "0.73.2",
     "@effect/printer": "0.47.0",
     "@effect/printer-ansi": "0.47.0",
-    "@dxos/app-toolkit": "0.8.4-main.9be5663bfe",
-    "@dxos/debug": "0.8.4-main.9be5663bfe",
-    "@dxos/client": "0.8.4-main.9be5663bfe",
-    "@dxos/echo": "0.8.4-main.9be5663bfe",
-    "@dxos/errors": "0.8.4-main.9be5663bfe",
-    "@dxos/functions": "0.8.4-main.9be5663bfe",
-    "@dxos/effect": "0.8.4-main.9be5663bfe",
-    "@dxos/log": "0.8.4-main.9be5663bfe",
-    "@dxos/util": "0.8.4-main.9be5663bfe",
-    "@dxos/protocols": "0.8.4-main.9be5663bfe"
+    "@dxos/app-toolkit": "0.8.4-main.abd8ff62ef",
+    "@dxos/client": "0.8.4-main.abd8ff62ef",
+    "@dxos/debug": "0.8.4-main.abd8ff62ef",
+    "@dxos/echo": "0.8.4-main.abd8ff62ef",
+    "@dxos/errors": "0.8.4-main.abd8ff62ef",
+    "@dxos/effect": "0.8.4-main.abd8ff62ef",
+    "@dxos/compute": "0.8.4-main.abd8ff62ef",
+    "@dxos/functions": "0.8.4-main.abd8ff62ef",
+    "@dxos/log": "0.8.4-main.abd8ff62ef",
+    "@dxos/protocols": "0.8.4-main.abd8ff62ef",
+    "@dxos/util": "0.8.4-main.abd8ff62ef"
   },
   "devDependencies": {
     "effect": "3.20.0",
-    "typescript": "^6.0.2",
-    "vitest": "3.2.4"
+    "typescript": "^6.0.3",
+    "vitest": "4.1.5"
   },
   "peerDependencies": {
     "effect": "3.20.0"

package/src/util/space-format.ts

@@ -2,40 +2,114 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Duration from 'effect/Duration';
 import * as Effect from 'effect/Effect';
 
 import { type Space, SpaceState, type SpaceSyncState } from '@dxos/client/echo';
 
 import * as FormBuilder from './form-builder';
 
+export type FormatSpaceOptions = {
+  verbose?: boolean;
+  truncateKeys?: boolean;
+  /**
+   * If set, wait up to this many seconds for the space to reach
+   * `SPACE_READY` before reading its fields. If unset, read whatever state
+   * is available right now — much safer for `space list` etc., where a
+   * single stuck space would otherwise hang the entire command.
+   */
+  waitSeconds?: number;
+};
+
+const DEFAULT_OPTIONS: Required<FormatSpaceOptions> = {
+  verbose: false,
+  truncateKeys: false,
+  waitSeconds: 0,
+};
+
+/**
+ * Per-async-read internal timeout. Some `space.internal.*` getters do
+ * filesystem / network IO and can themselves hang on a partially-loaded
+ * space; cap each one so the command can never be held hostage by SDK
+ * internals.
+ */
+const READ_TIMEOUT_SECONDS = 2;
+
+const tryWithFallback = <T>(label: string, run: () => Promise<T>, fallback: T) =>
+  Effect.tryPromise(run).pipe(
+    Effect.timeoutFail({
+      duration: Duration.seconds(READ_TIMEOUT_SECONDS),
+      onTimeout: () => new Error(`${label} timed out`),
+    }),
+    Effect.catchAll(() => Effect.succeed(fallback)),
+  );
+
+const tryWithFallbackSync = <T>(read: () => T, fallback: T): T => {
+  try {
+    return read();
+  } catch {
+    return fallback;
+  }
+};
+
 // TODO(wittjosiah): Use @effect/printer.
-export const formatSpace = Effect.fn(function* (space: Space, options = { verbose: false, truncateKeys: false }) {
-  yield* Effect.tryPromise(() => space.waitUntilReady());
+export const formatSpace = Effect.fn(function* (space: Space, options: FormatSpaceOptions = {}) {
+  const { waitSeconds } = { ...DEFAULT_OPTIONS, ...options };
+
+  // Opt-in wait. Defaults to NO wait so a single stuck space can't hang
+  // an enumeration command (e.g. `dx space list`).
+  if (waitSeconds > 0) {
+    yield* Effect.tryPromise(() => space.waitUntilReady()).pipe(
+      Effect.timeoutFail({
+        duration: Duration.seconds(waitSeconds),
+        onTimeout: () => new Error('waitUntilReady timed out'),
+      }),
+      Effect.catchAll(() => Effect.void),
+    );
+  }
+
+  const state = tryWithFallbackSync(() => space.state.get(), SpaceState.SPACE_INITIALIZING);
+  const ready = state === SpaceState.SPACE_READY;
 
   // TODO(burdon): Factor out.
   // TODO(burdon): Agent needs to restart before `ready` is available.
-  const { open, ready } = space.internal.data.metrics ?? {};
-  const startup = open && ready && ready.getTime() - open.getTime();
+  const metrics = tryWithFallbackSync(
+    () => space.internal.data.metrics,
+    undefined as { open?: Date; ready?: Date } | undefined,
+  );
+  const startup = metrics?.open && metrics?.ready ? metrics.ready.getTime() - metrics.open.getTime() : undefined;
 
   // TODO(burdon): Get feeds from client-services if verbose (factor out from devtools/diagnostics).
   // const host = client.services.services.DevtoolsHost!;
-  const pipeline = space.internal.data.pipeline;
+  const pipeline = tryWithFallbackSync(() => space.internal.data.pipeline, undefined);
   const epoch = pipeline?.currentEpoch?.subject.assertion.number;
 
-  const syncState = aggregateSyncState(yield* Effect.tryPromise(() => space.internal.db.coreDatabase.getSyncState()));
+  // The sync-state read does IO; cap it so a stuck space can't hang the
+  // command. Falls back to a "no peers" placeholder.
+  const syncStateRaw = yield* tryWithFallback('getSyncState', () => space.internal.db.coreDatabase.getSyncState(), {
+    peers: {},
+  } as SpaceSyncState);
+  const syncState = aggregateSyncState(syncStateRaw);
+
+  const name = ready ? tryWithFallbackSync(() => space.properties.name, undefined) : 'loading...';
+  const members = tryWithFallbackSync(() => space.members.get().length, 0);
+  const objects = tryWithFallbackSync(() => space.internal.db.coreDatabase.getAllObjectIds().length, 0);
+  const key = options.truncateKeys
+    ? tryWithFallbackSync(() => space.key.truncate(), '')
+    : tryWithFallbackSync(() => space.key.toHex(), '');
 
   return {
     id: space.id,
-    state: SpaceState[space.state.get()],
-    name: space.state.get() === SpaceState.SPACE_READY ? space.properties.name : 'loading...',
+    state: SpaceState[state],
+    name,
 
-    members: space.members.get().length,
-    objects: space.internal.db.coreDatabase.getAllObjectIds().length,
+    members,
+    objects,
 
-    key: options.truncateKeys ? space.key.truncate() : space.key.toHex(),
+    key,
     epoch,
     startup,
-    automergeRoot: space.internal.data.pipeline?.spaceRootUrl,
+    automergeRoot: pipeline?.spaceRootUrl,
     // appliedEpoch,
     syncState: `${syncState.count} ${getSyncIndicator(syncState.up, syncState.down)} (${syncState.peers} peers)`,
   };

package/src/util/space.ts

@@ -5,7 +5,6 @@
 import * as Console from 'effect/Console';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
-import * as Match from 'effect/Match';
 import * as Option from 'effect/Option';
 
 import { getPersonalSpace } from '@dxos/app-toolkit';
@@ -44,16 +43,25 @@ export const spaceLayer = (
   const getSpace = Effect.fn(function* () {
     const client = yield* ClientService;
 
-    const spaceId = Match.value(fallbackToPersonalSpace).pipe(
-      Match.when(true, () => spaceId$.pipe(Option.orElse(() => Option.fromNullable(getPersonalSpace(client)?.id)))),
-      Match.when(false, () => spaceId$),
-      Match.exhaustive,
-    );
+    // Resolution order when fallbackToPersonalSpace is true:
+    //   1. the explicit spaceId arg (if provided);
+    //   2. the space tagged `org.dxos.space.personal`;
+    //   3. the first available space.
+    // This keeps profiles created outside composer-app (which is what creates
+    // the personal-space tag on identity creation) usable — the alternative
+    // is a "Space not found" throw deep inside CredentialsService.
+    const resolveSpace = () => {
+      if (!fallbackToPersonalSpace) {
+        return spaceId$.pipe(Option.flatMap((id) => Option.fromNullable(client.spaces.get(id))));
+      }
+      return spaceId$.pipe(
+        Option.flatMap((id) => Option.fromNullable(client.spaces.get(id))),
+        Option.orElse(() => Option.fromNullable(getPersonalSpace(client))),
+        Option.orElse(() => Option.fromNullable(client.spaces.get()[0])),
+      );
+    };
 
-    const space = spaceId.pipe(
-      Option.flatMap((id) => Option.fromNullable(client.spaces.get(id))),
-      Option.getOrUndefined,
-    );
+    const space = resolveSpace().pipe(Option.getOrUndefined);
 
     if (space) {
       yield* Effect.promise(() => space.waitUntilReady());
@@ -61,21 +69,27 @@ export const spaceLayer = (
     return space;
   });
 
+  // When no space can be resolved we install a stub whose `db` getter throws
+  // on access — preserves the existing semantics for commands that *do* need
+  // a db — but the release callback must NOT touch `db` or it will throw
+  // during teardown (e.g. after a command emits a friendly error and
+  // returns early). A shared sentinel object short-circuits the release.
+  const NO_DB_STUB = {
+    get db(): Database.Database {
+      throw new Error('Space not found');
+    },
+  };
   const db = Layer.scoped(
     Database.Service,
     Effect.acquireRelease(
       Effect.gen(function* () {
         const space = yield* getSpace();
         if (!space) {
-          return {
-            get db(): Database.Database {
-              throw new Error('Space not found');
-            },
-          };
+          return NO_DB_STUB;
         }
         return { db: space.db };
       }),
-      ({ db }) => Effect.promise(() => db.flush()),
+      (holder) => (holder === NO_DB_STUB ? Effect.void : Effect.promise(() => holder.db.flush())),
     ),
   );