@dxos/plugin-client 0.8.4-main.c85a9c8dae → 0.8.4-main.d9fc60f731

package/src/capabilities/layer-specs.ts

@@ -0,0 +1,92 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { ClientService } from '@dxos/client';
+import { Credential, LayerSpec } from '@dxos/compute';
+import { Database, Feed } from '@dxos/echo';
+import { createFeedServiceLayer } from '@dxos/echo-db';
+import { credentialsLayerFromDatabase } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+
+import { ClientCapabilities } from '#types';
+
+//
+// Capability Module
+//
+// Contributes the core client/space service layer specs:
+//   - {@link ClientService} (application affinity).
+//   - {@link Database.Service}, {@link Feed.FeedService},
+//     {@link Credential.CredentialsService} (space affinity).
+//
+// Specs are declared at module level and resolve the underlying
+// {@link ClientCapabilities.Client} through the Effect layer graph (via
+// {@link Capability.Service}) rather than capturing it from an outer scope.
+//
+
+/**
+ * Provides the Effect-level {@link ClientService} backed by the
+ * {@link ClientCapabilities.Client} capability contributed by the plugin
+ * runtime.
+ */
+const ClientLayerSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [Capability.Service],
+    provides: [ClientService],
+  },
+  () =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        const client = yield* Capability.get(ClientCapabilities.Client);
+        return ClientService.fromClient(client);
+      }).pipe(Effect.orDie),
+    ),
+);
+
+/**
+ * Space-scoped database/feed services resolved from the `Client`'s space
+ * registry. One spec for both so the `client.spaces.get` / `waitUntilReady`
+ * round-trip only happens once per space slice. Fails hard if the context is
+ * missing a `space` id or the client cannot resolve it — both indicate a
+ * configuration bug in the layer graph.
+ */
+const DatabaseLayerSpec = LayerSpec.make(
+  {
+    affinity: 'space',
+    requires: [ClientService],
+    provides: [Database.Service, Feed.FeedService],
+  },
+  (context) =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        invariant(context.space, 'space context required for Database layer');
+        const client = yield* ClientService;
+        const space = client.spaces.get(context.space);
+        invariant(space, `space not found on client: ${context.space}`);
+        yield* Effect.promise(() => space.waitUntilReady());
+        return Layer.mergeAll(Database.layer(space.db), createFeedServiceLayer(space.queues));
+      }),
+    ),
+);
+
+const CredentialsLayerSpec = LayerSpec.make(
+  {
+    affinity: 'space',
+    requires: [Database.Service],
+    provides: [Credential.CredentialsService],
+  },
+  () => credentialsLayerFromDatabase(),
+);
+
+export default Capability.makeModule(() =>
+  Effect.succeed([
+    Capability.contributes(Capabilities.LayerSpec, ClientLayerSpec),
+    Capability.contributes(Capabilities.LayerSpec, DatabaseLayerSpec),
+    Capability.contributes(Capabilities.LayerSpec, CredentialsLayerSpec),
+  ]),
+);

package/src/capabilities/{migrations/migrations.ts → migrations.ts}

@@ -6,7 +6,7 @@ import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 
-import { ClientCapabilities } from '../../types';
+import { ClientCapabilities } from '#types';
 
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {

package/src/capabilities/navigation-handler/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export type { NavigationHandlerOptions } from './navigation-handler';
+
+export const NavigationHandler = Capability.lazy('NavigationHandler', () => import('./navigation-handler'));

package/src/capabilities/navigation-handler/navigation-handler.ts

@@ -0,0 +1,64 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+import { log } from '@dxos/log';
+
+import { ClientOperation } from '../../operations';
+
+export type NavigationHandlerOptions = {
+  invitationProp?: string;
+  tokenProp?: string;
+  tokenTypeProp?: string;
+};
+
+/**
+ * NavigationHandler for auth-related URL params.
+ * Handles login tokens and device invitation codes.
+ */
+export default Capability.makeModule(
+  Effect.fnUntraced(function* ({
+    invitationProp = 'deviceInvitationCode',
+    tokenProp = 'token',
+    tokenTypeProp = 'type',
+  }: NavigationHandlerOptions = {}) {
+    const capabilities = yield* Capability.Service;
+    const operationService = yield* Capability.get(Capabilities.OperationInvoker);
+
+    const handler: AppCapabilities.NavigationHandler = (url: URL) =>
+      Effect.gen(function* () {
+        const token = url.searchParams.get(tokenProp);
+        const tokenType = url.searchParams.get(tokenTypeProp);
+        const invitationCode = url.searchParams.get(invitationProp);
+
+        if (token && tokenType === 'login') {
+          log('login token received via navigation');
+          removeQueryParam(tokenProp);
+          removeQueryParam(tokenTypeProp);
+          yield* Operation.invoke(ClientOperation.RedeemToken, { token });
+        } else if (invitationCode) {
+          log('device invitation received via navigation');
+          removeQueryParam(invitationProp);
+          yield* Operation.invoke(ClientOperation.JoinIdentity, { invitationCode });
+        }
+      }).pipe(
+        Effect.provideService(Capability.Service, capabilities),
+        Effect.provideService(Operation.Service, operationService),
+        Effect.orDie,
+      );
+
+    return Capability.contributes(AppCapabilities.NavigationHandler, handler);
+  }),
+);
+
+/** Remove a query param from the current browser URL. */
+const removeQueryParam = (key: string) => {
+  const current = new URL(window.location.href);
+  current.searchParams.delete(key);
+  history.replaceState(null, '', current.pathname + current.search);
+};

package/src/capabilities/node.ts

@@ -0,0 +1,21 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const Client = Capability.lazy('Client', () => import('./client'));
+export const LayerSpecs = Capability.lazy<void, Capability.Any[]>('LayerSpecs', () => import('./layer-specs'));
+export const Migrations = Capability.lazy('Migrations', () => import('./migrations'));
+export const NavigationHandler = Capability.lazy(
+  'NavigationHandler',
+  () => import('./navigation-handler/navigation-handler'),
+);
+export type { NavigationHandlerOptions } from './navigation-handler';
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const SchemaDefs = Capability.lazy('SchemaDefs', () => import('./schema-defs'));

package/src/capabilities/operation-handler.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/compute';
+
+import { ClientOperationHandlerSet } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationHandler, ClientOperationHandlerSet);
+  }),
+);

package/src/capabilities/{react-context/react-context.tsx → react-context.tsx}

@@ -3,20 +3,20 @@
 //
 
 import * as Effect from 'effect/Effect';
-import React from 'react';
+import React, { ReactNode } from 'react';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { useCapability } from '@dxos/app-framework/ui';
 import { ClientProvider } from '@dxos/react-client';
 
-import { meta } from '../../meta';
-import { ClientCapabilities } from '../../types';
+import { meta } from '#meta';
+import { ClientCapabilities } from '#types';
 
 export default Capability.makeModule(() =>
   Effect.succeed(
     Capability.contributes(Capabilities.ReactContext, {
       id: meta.id,
-      context: ({ children }: { children?: React.ReactNode }) => {
+      context: ({ children }: { children?: ReactNode }) => {
         const client = useCapability(ClientCapabilities.Client);
         return <ClientProvider client={client}>{children}</ClientProvider>;
       },

package/src/capabilities/{react-surface/react-surface.tsx → react-surface.tsx}

@@ -3,24 +3,25 @@
 //
 
 import * as Effect from 'effect/Effect';
-import React from 'react';
+import React, { type ComponentProps } from 'react';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { Surface } from '@dxos/app-framework/ui';
-import { type JoinPanelProps } from '@dxos/shell/react';
+import { AppSurface } from '@dxos/app-toolkit/ui';
 
-import { JOIN_DIALOG, RECOVERY_CODE_DIALOG, RESET_DIALOG } from '../../constants';
 import {
+  AccountContainer,
   DevicesContainer,
+  InvitationsContainer,
   JoinDialog,
   ProfileContainer,
   RecoveryCodeDialog,
-  type RecoveryCodeDialogProps,
   RecoveryCredentialsContainer,
   ResetDialog,
-  type ResetDialogProps,
-} from '../../containers';
-import { Account, type ClientPluginOptions } from '../../types';
+} from '#containers';
+import { Account, type ClientPluginOptions } from '#types';
+
+import { JOIN_DIALOG, RECOVERY_CODE_DIALOG, RESET_DIALOG } from '../constants';
 
 type ReactSurfaceOptions = Pick<ClientPluginOptions, 'onReset'> & {
   createInvitationUrl: (invitationCode: string) => string;
@@ -33,39 +34,46 @@ export default Capability.makeModule(
     return Capability.contributes(Capabilities.ReactSurface, [
       Surface.create({
         id: Account.Profile,
-        role: 'article',
-        filter: (data): data is any => data.subject === Account.Profile,
+        filter: AppSurface.literal(AppSurface.Article, Account.Profile),
         component: () => <ProfileContainer />,
       }),
       Surface.create({
         id: Account.Devices,
-        role: 'article',
-        filter: (data): data is any => data.subject === Account.Devices,
+        filter: AppSurface.literal(AppSurface.Article, Account.Devices),
         component: () => <DevicesContainer createInvitationUrl={createInvitationUrl} />,
       }),
       Surface.create({
         id: Account.Security,
-        role: 'article',
-        filter: (data): data is any => data.subject === Account.Security,
+        filter: AppSurface.literal(AppSurface.Article, Account.Security),
         component: () => <RecoveryCredentialsContainer />,
       }),
+      Surface.create({
+        id: Account.Account,
+        filter: AppSurface.literal(AppSurface.Article, Account.Account),
+        component: () => <AccountContainer />,
+      }),
+      Surface.create({
+        id: Account.Invitations,
+        filter: AppSurface.literal(AppSurface.Article, Account.Invitations),
+        component: () => <InvitationsContainer />,
+      }),
       Surface.create({
         id: JOIN_DIALOG,
-        role: 'dialog',
-        filter: (data): data is { props: JoinPanelProps } => data.component === JOIN_DIALOG,
-        component: ({ data }: { data: any }) => <JoinDialog {...data.props} />,
+        filter: AppSurface.component<ComponentProps<typeof JoinDialog>>(AppSurface.Dialog, JOIN_DIALOG),
+        component: ({ data }) => <JoinDialog {...data.props} />,
       }),
       Surface.create({
         id: RECOVERY_CODE_DIALOG,
-        role: 'dialog',
-        filter: (data): data is { props: RecoveryCodeDialogProps } => data.component === RECOVERY_CODE_DIALOG,
-        component: ({ data }: { data: any }) => <RecoveryCodeDialog {...data.props} />,
+        filter: AppSurface.component<ComponentProps<typeof RecoveryCodeDialog>>(
+          AppSurface.Dialog,
+          RECOVERY_CODE_DIALOG,
+        ),
+        component: ({ data }) => <RecoveryCodeDialog {...data.props} />,
       }),
       Surface.create({
         id: RESET_DIALOG,
-        role: 'dialog',
-        filter: (data): data is { props: ResetDialogProps } => data.component === RESET_DIALOG,
-        component: ({ data }: { data: any }) => (
+        filter: AppSurface.component<Pick<ComponentProps<typeof ResetDialog>, 'mode'>>(AppSurface.Dialog, RESET_DIALOG),
+        component: ({ data }) => (
           <ResetDialog {...data.props} onReset={onReset} capabilityManager={capabilityManager} />
         ),
       }),

package/src/capabilities/schema-defs.ts

@@ -0,0 +1,56 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { Type } from '@dxos/echo';
+import { log } from '@dxos/log';
+
+import { ClientCapabilities } from '#types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const registry = yield* Capability.get(Capabilities.AtomRegistry);
+    const client = yield* Capability.get(ClientCapabilities.Client);
+    const schemasAtom = yield* Capability.atom(AppCapabilities.Schema);
+
+    // TODO(wittjosiah): Unregister schemas when they are disabled.
+    let previousDxns = new Set<string>();
+    const cancel = registry.subscribe(
+      schemasAtom,
+      async (schemas) => {
+        const seenSchemaDxns = new Set<string>();
+        const batch: { schema: Type.AnyEntity; dxnKey: string }[] = [];
+        for (const schema of schemas.flat()) {
+          const uri = Type.getURI(schema);
+          if (!uri) {
+            log.warn('skipping schema without uri');
+            continue;
+          }
+
+          const key = uri.toString();
+          if (seenSchemaDxns.has(key)) {
+            log('skipping duplicate schema for echo registration', { uri: key });
+            continue;
+          }
+
+          seenSchemaDxns.add(key);
+          batch.push({ schema, dxnKey: key });
+        }
+
+        const toRegister = batch.filter(({ dxnKey }) => !previousDxns.has(dxnKey));
+
+        await client.addTypes(toRegister.map(({ schema }) => schema));
+        for (const { dxnKey } of toRegister) {
+          previousDxns.add(dxnKey);
+        }
+      },
+      { immediate: true },
+    );
+
+    return Capability.contributes(Capabilities.Null, null, () => Effect.sync(() => cancel()));
+  }),
+);

package/src/{cli/commands → commands}/config/view.ts

@@ -9,17 +9,20 @@ import * as Yaml from 'yaml';
 
 import { CommandConfig } from '@dxos/cli-util';
 import { ConfigService } from '@dxos/client';
+import { DX_CONFIG, getProfileConfigPath } from '@dxos/client-protocol';
 
 export const view = Command.make(
   'view',
   {},
   Effect.fnUntraced(function* () {
     const config = yield* ConfigService;
-    const { json } = yield* CommandConfig;
+    const { json, profile } = yield* CommandConfig;
+    const configPath = getProfileConfigPath(DX_CONFIG, profile);
 
     if (json) {
       yield* Console.log(JSON.stringify(config.values, null, 2));
     } else {
+      yield* Console.log(`Path: ${configPath}`);
       yield* Console.log(Yaml.stringify(config.values));
     }
   }),

package/src/{cli/commands → commands}/device/info/info.test.ts

@@ -16,7 +16,6 @@ describe('device info', () => {
     Effect.gen(function* () {
       const client = yield* ClientService;
       yield* Effect.tryPromise(() => client.halo.createIdentity());
-      yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
       yield* handler();
       const logger = yield* TestConsole.TestConsole;
       const logs = logger.logs;

package/src/{cli/commands → commands}/device/info/info.ts

@@ -16,8 +16,6 @@ import { printDevice } from '../util';
 export const handler = Effect.fn(function* () {
   const { json } = yield* CommandConfig;
   const client = yield* ClientService;
-  yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
-
   const device = client.halo.device;
   if (!device) {
     if (json) {

package/src/{cli/commands → commands}/device/list/list.test.ts

@@ -16,7 +16,6 @@ describe('device list', () => {
     Effect.gen(function* () {
       const client = yield* ClientService;
       yield* Effect.tryPromise(() => client.halo.createIdentity());
-      yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
       yield* handler();
       const logger = yield* TestConsole.TestConsole;
       const logs = logger.logs;

package/src/{cli/commands → commands}/device/list/list.ts

@@ -15,8 +15,6 @@ import { mapDevices, printDevices } from '../util';
 export const handler = Effect.fn(function* () {
   const { json } = yield* CommandConfig;
   const client = yield* ClientService;
-  yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
-
   const devices = client.halo.devices.get();
 
   if (json) {

package/src/{cli/commands → commands}/device/update/update.ts

@@ -16,8 +16,6 @@ import { printDevice } from '../util';
 export const handler = Effect.fn(function* ({ label }: { label: string }) {
   const { json } = yield* CommandConfig;
   const client = yield* ClientService;
-  yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
-
   const device = client.halo.device;
   if (!device) {
     if (json) {

package/src/{cli/commands → commands}/edge/status.ts

@@ -10,13 +10,14 @@ import * as Option from 'effect/Option';
 import { CommandConfig } from '@dxos/cli-util';
 import { ClientService } from '@dxos/client';
 import { createEdgeIdentity } from '@dxos/client/edge';
+import { Context } from '@dxos/context';
 
 export const getStatus = () =>
   Effect.gen(function* () {
     const client = yield* ClientService;
     const identity = createEdgeIdentity(client);
     client.edge.http.setIdentity(identity);
-    const status = yield* Effect.tryPromise(() => client.edge.http.getStatus());
+    const status = yield* Effect.tryPromise(() => client.edge.http.getStatus(Context.default()));
 
     if (yield* CommandConfig.isJson) {
       yield* Console.log(JSON.stringify(status, null, 2));

package/src/{cli/commands → commands}/halo/create/create.test.ts

@@ -2,27 +2,28 @@
 // Copyright 2025 DXOS.org
 //
 
-import { describe, expect, it } from '@effect/vitest';
+import { describe, test } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import * as Option from 'effect/Option';
 
-import { OperationPlugin } from '@dxos/app-framework';
+import {} from '@dxos/app-framework';
 import { fromPlugins } from '@dxos/app-framework/testing';
 import { TestConsole, TestLayer } from '@dxos/cli-util/testing';
 import { ClientService } from '@dxos/client';
 import { runAndForwardErrors } from '@dxos/effect';
-import { ObservabilityPlugin } from '@dxos/plugin-observability/cli';
+import { ObservabilityPlugin } from '@dxos/plugin-observability/plugin';
 
-import { ClientPlugin } from '../../../plugin';
+import { ClientPlugin } from '#plugin';
 
 import { handler } from './create';
 
-const layer = Layer.merge(TestLayer, fromPlugins([ClientPlugin({}), OperationPlugin(), ObservabilityPlugin()]));
+// TODO(wittjosiah): Align browser and node variant option types for ObservabilityPlugin.
+const layer = Layer.merge(TestLayer, fromPlugins([ClientPlugin({}), ObservabilityPlugin({} as any)]));
 
 // TODO(wittjosiah): Fix these tests.
 describe.skip('halo create', () => {
-  it('should create an identity without a display name', () =>
+  test('should create an identity without a display name', ({ expect }) =>
     Effect.gen(function* () {
       const client = yield* ClientService;
       yield* handler({ agent: false, displayName: Option.none() });
@@ -31,12 +32,12 @@ describe.skip('halo create', () => {
       expect(logs).toHaveLength(1);
       const parsedIdentity = TestConsole.parseJson(logs[0]);
       expect(parsedIdentity).toEqual({
-        identityKey: client.halo.identity.get()?.identityKey.toHex(),
+        identityDid: client.halo.identity.get()?.did,
         displayName: client.halo.identity.get()?.profile?.displayName,
       });
     }).pipe(Effect.provide(layer), Effect.scoped, runAndForwardErrors));
 
-  it('should create an identity with a display name', () =>
+  test('should create an identity with a display name', ({ expect }) =>
     Effect.gen(function* () {
       const client = yield* ClientService;
       yield* handler({ agent: false, displayName: Option.some('Example') });
@@ -45,7 +46,7 @@ describe.skip('halo create', () => {
       expect(logs).toHaveLength(1);
       const parsedIdentity = TestConsole.parseJson(logs[0]);
       expect(parsedIdentity).toEqual({
-        identityKey: client.halo.identity.get()?.identityKey.toHex(),
+        identityDid: client.halo.identity.get()?.did,
         displayName: client.halo.identity.get()?.profile?.displayName,
       });
     }).pipe(Effect.provide(layer), Effect.scoped, runAndForwardErrors));

package/src/{cli/commands → commands}/halo/create/create.ts

@@ -9,12 +9,16 @@ import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 
 import { Capabilities, Plugin } from '@dxos/app-framework';
+import { PERSONAL_SPACE_TAG } from '@dxos/app-toolkit';
 import { CommandConfig, flushAndSync, spaceLayer } from '@dxos/cli-util';
 import { print } from '@dxos/cli-util';
 import { ClientService } from '@dxos/client';
 import { invariant } from '@dxos/invariant';
+import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
+import { MembershipPolicy } from '@dxos/protocols/proto/dxos/halo/credentials';
+
+import { ClientOperation } from '#operations';
 
-import { ClientOperation } from '../../../../types';
 import { printIdentity } from '../util';
 
 export const handler = Effect.fn(function* ({
@@ -39,16 +43,19 @@ export const handler = Effect.fn(function* ({
     yield* invoke(ClientOperation.CreateAgent);
   }
 
-  yield* Effect.promise(() => client.spaces.waitUntilReady());
-  yield* Effect.promise(() => client.spaces.default.waitUntilReady());
-  const space = client.spaces.default;
+  // Create personal space for the CLI identity.
+  const space = yield* Effect.promise(() =>
+    client.spaces.create({}, { tags: [PERSONAL_SPACE_TAG], membershipPolicy: MembershipPolicy.LOCKED }),
+  );
+  yield* Effect.promise(() => space.waitUntilReady());
+  yield* Effect.promise(() => space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED));
   yield* flushAndSync({ indexes: true }).pipe(Effect.provide(spaceLayer(Option.some(space.id))));
 
   if (json) {
     yield* Console.log(
       JSON.stringify(
         {
-          identityKey: identity.identityKey.toHex(),
+          identityDid: identity.identityDid,
           displayName: identity.profile?.displayName,
         },
         null,

package/src/{cli/commands → commands}/halo/credential/list/list.test.ts

@@ -17,7 +17,6 @@ describe('halo credential list', () => {
     Effect.gen(function* () {
       const client = yield* ClientService;
       yield* Effect.tryPromise(() => client.halo.createIdentity());
-      yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
       yield* handler({ type: Option.none(), spaceId: Option.none(), timeout: 500, delay: 250 });
       const logger = yield* TestConsole.TestConsole;
       const logs = logger.logs;

package/src/{cli/commands → commands}/halo/credential/list/list.ts

@@ -9,7 +9,7 @@ import * as Duration from 'effect/Duration';
 import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 
-import { CommandConfig, Common, FormBuilder, getSpace, printList, spaceIdWithDefault } from '@dxos/cli-util';
+import { CommandConfig, Common, FormBuilder, getSpace, printList } from '@dxos/cli-util';
 import { ClientService } from '@dxos/client';
 import type { Credential } from '@dxos/client/halo';
 import { type Key } from '@dxos/echo';
@@ -41,20 +41,17 @@ export const handler = Effect.fn(function* ({
   delay,
 }: {
   type: Option.Option<string>;
-  spaceId: Option.Option<string>;
+  spaceId: Option.Option<Key.SpaceId>;
   timeout: number;
   delay: number;
 }) {
   const { json } = yield* CommandConfig;
   const client = yield* ClientService;
-  yield* Effect.tryPromise(() => client.spaces.waitUntilReady());
-
   let credentials: Credential[];
 
-  const resolvedSpaceId = yield* spaceIdWithDefault(spaceId as Option.Option<Key.SpaceId>);
   if (Option.isSome(spaceId)) {
-    // If space ID was provided, get credentials from that space
-    const space = yield* getSpace(resolvedSpaceId);
+    // If space ID was provided, get credentials from that space.
+    const space = yield* getSpace(spaceId.value);
     credentials = yield* Effect.tryPromise(() => space.internal.getCredentials());
   } else {
     // Get credentials from HALO