@dxos/plugin-client 0.8.4-main.f9ba587 → 0.8.4-main.fcc0d83b33

package/src/cli/commands/device/update/update.ts

@@ -0,0 +1,68 @@
+//
+// 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 } from '@dxos/cli-util';
+import { print } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+
+import { printDevice } from '../util';
+
+export const handler = Effect.fn(function* ({ label }: { label: string }) {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+  const device = client.halo.device;
+  if (!device) {
+    if (json) {
+      yield* Console.log(JSON.stringify({ error: 'No device found' }, null, 2));
+    } else {
+      yield* Console.log('No device found.');
+    }
+    return;
+  }
+
+  const updatedProfile = {
+    ...device.profile,
+    label,
+  };
+
+  const devicesService = client.services.services.DevicesService;
+  if (!devicesService) {
+    if (json) {
+      yield* Console.log(JSON.stringify({ error: 'DevicesService not found' }, null, 2));
+    } else {
+      yield* Console.log('DevicesService not found.');
+    }
+    return;
+  }
+
+  const updatedDevice = yield* Effect.tryPromise(() => devicesService.updateDevice(updatedProfile));
+
+  if (json) {
+    yield* Console.log(
+      JSON.stringify(
+        {
+          deviceKey: updatedDevice.deviceKey.toHex(),
+          profile: updatedDevice.profile,
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    yield* Console.log(print(printDevice(updatedDevice)));
+  }
+});
+
+export const update = Command.make(
+  'update',
+  {
+    label: Options.text('label').pipe(Options.withDescription('The device label.')),
+  },
+  handler,
+).pipe(Command.withDescription('Update device label.'));

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

@@ -0,0 +1,55 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { FormBuilder } from '@dxos/cli-util';
+import { Device, DeviceKind, DeviceType } from '@dxos/client/halo';
+
+const maybeTruncateKey = (key: { toHex(): string; truncate(): string }, truncate = false) =>
+  truncate ? key.truncate() : key.toHex();
+
+const getDeviceTitle = (device: Device): string => {
+  if (device.profile?.label) {
+    return device.profile.label;
+  }
+  const platform = device.profile?.platform ?? 'Unknown';
+  const os = device.profile?.os ?? 'Unknown';
+  return `${platform} on ${os}`;
+};
+
+export const mapDevices = (devices: Device[], truncateKeys = false) => {
+  return devices.map((device) => ({
+    label: device.profile?.label,
+    type: device.profile?.type ? DeviceType[device.profile?.type] : 'UNKNOWN',
+    key: maybeTruncateKey(device.deviceKey, truncateKeys),
+    kind: DeviceKind[device.kind],
+    platform: device.profile?.platform,
+    platformVersion: device.profile?.platformVersion,
+    architecture: device.profile?.architecture,
+    os: device.profile?.os,
+    osVersion: device.profile?.osVersion,
+    presence: device?.kind === DeviceKind.CURRENT ? 'THIS DEVICE' : Device.PresenceState[device.presence],
+  }));
+};
+
+export const printDevice = (device: Device) =>
+  FormBuilder.make({ title: getDeviceTitle(device) }).pipe(
+    FormBuilder.set('deviceKey', device.deviceKey.truncate()),
+    FormBuilder.set('label', device.profile?.label ?? '<none>'),
+    FormBuilder.set('type', device.profile?.type ? DeviceType[device.profile?.type] : 'UNKNOWN'),
+    FormBuilder.set('kind', DeviceKind[device.kind]),
+    FormBuilder.set(
+      'presence',
+      device?.kind === DeviceKind.CURRENT ? 'THIS DEVICE' : Device.PresenceState[device.presence],
+    ),
+    FormBuilder.set('platform', device.profile?.platform ?? '<none>'),
+    FormBuilder.set('platformVersion', device.profile?.platformVersion ?? '<none>'),
+    FormBuilder.set('architecture', device.profile?.architecture ?? '<none>'),
+    FormBuilder.set('os', device.profile?.os ?? '<none>'),
+    FormBuilder.set('osVersion', device.profile?.osVersion ?? '<none>'),
+    FormBuilder.build,
+  );
+
+export const printDevices = (devices: Device[]) => {
+  return devices.map(printDevice);
+};

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

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

package/src/cli/commands/edge/status.ts

@@ -0,0 +1,46 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+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 { 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(Context.default()));
+
+    if (yield* CommandConfig.isJson) {
+      yield* Console.log(JSON.stringify(status, null, 2));
+    } else if (status.problems.length > 0) {
+      for (const problem of status.problems) {
+        yield* Console.error(problem);
+      }
+    } else {
+      yield* Console.log('No problems found.');
+    }
+  }).pipe(
+    // TODO(wittjosiah): Tagged error.
+    Effect.catchSome((error) => {
+      if (error instanceof Error && error.message === 'Identity not available') {
+        // TODO(wittjosiah): Error coloring for logs.
+        return Option.some(Console.error(error.message));
+      } else {
+        return Option.none();
+      }
+    }),
+  );
+
+// TODO(wittjosiah): Admin functionality to provide to specify an identity.
+export const status = Command.make('status', {}, getStatus).pipe(
+  Command.withDescription('Get the EDGE status for the current identity.'),
+);

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

@@ -0,0 +1,51 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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 { OperationPlugin } 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 { ClientPlugin } from '../../../plugin';
+import { handler } from './create';
+
+const layer = Layer.merge(TestLayer, fromPlugins([ClientPlugin({}), OperationPlugin(), ObservabilityPlugin()]));
+
+// TODO(wittjosiah): Fix these tests.
+describe.skip('halo create', () => {
+  it('should create an identity without a display name', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* handler({ agent: false, displayName: Option.none() });
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      const parsedIdentity = TestConsole.parseJson(logs[0]);
+      expect(parsedIdentity).toEqual({
+        identityKey: client.halo.identity.get()?.identityKey.toHex(),
+        displayName: client.halo.identity.get()?.profile?.displayName,
+      });
+    }).pipe(Effect.provide(layer), Effect.scoped, runAndForwardErrors));
+
+  it('should create an identity with a display name', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* handler({ agent: false, displayName: Option.some('Example') });
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      const parsedIdentity = TestConsole.parseJson(logs[0]);
+      expect(parsedIdentity).toEqual({
+        identityKey: client.halo.identity.get()?.identityKey.toHex(),
+        displayName: client.halo.identity.get()?.profile?.displayName,
+      });
+    }).pipe(Effect.provide(layer), Effect.scoped, runAndForwardErrors));
+});

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

@@ -0,0 +1,82 @@
+//
+// 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 { 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 { printIdentity } from '../util';
+
+export const handler = Effect.fn(function* ({
+  agent,
+  displayName,
+}: {
+  agent: boolean;
+  displayName: Option.Option<string>;
+}) {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+  // TODO(wittjosiah): How to surface this error to the user cleanly?
+  invariant(!client.halo.identity.get(), 'Identity already exists');
+
+  const manager = yield* Plugin.Service;
+  const { invoke } = manager.capabilities.get(Capabilities.OperationInvoker);
+  const identity = yield* invoke(ClientOperation.CreateIdentity, {
+    displayName: Option.getOrUndefined(displayName),
+  });
+
+  if (agent) {
+    yield* invoke(ClientOperation.CreateAgent);
+  }
+
+  // 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(),
+          displayName: identity.profile?.displayName,
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    yield* Console.log(print(printIdentity(identity)));
+  }
+});
+
+export const create = Command.make(
+  'create',
+  {
+    agent: Options.boolean('noAgent', { ifPresent: false }).pipe(
+      Options.withDescription('Do not create an EDGE agent for the identity.'),
+    ),
+    displayName: Options.text('displayName').pipe(
+      Options.withDescription('The display name of the identity.'),
+      Options.optional,
+    ),
+  },
+  handler,
+).pipe(Command.withDescription('Create a new identity.'));

package/src/cli/commands/halo/create/index.ts

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

package/src/cli/commands/halo/credential/add/add.ts

@@ -0,0 +1,97 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Args from '@effect/cli/Args';
+import * as Command from '@effect/cli/Command';
+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 { CommandConfig } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+import { invariant } from '@dxos/invariant';
+import { schema } from '@dxos/protocols/proto';
+
+export const handler = Effect.fn(function* ({ credential }: { credential: Option.Option<string> }) {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+
+  let credentialHex = Option.getOrUndefined(credential);
+  if (!credentialHex) {
+    credentialHex = yield* Prompt.text({ message: 'Enter credential (hex string)' }).pipe(Prompt.run);
+  }
+
+  invariant(credentialHex, 'Invalid credential.');
+
+  const identity = client.halo.identity;
+  if (!identity) {
+    if (json) {
+      yield* Console.log(JSON.stringify({ error: 'Profile not initialized' }, null, 2));
+    } else {
+      yield* Console.log('Profile not initialized.');
+    }
+    return;
+  }
+
+  yield* Effect.gen(function* () {
+    const codec = schema.getCodecForType('dxos.halo.credentials.Credential');
+    const credentialBytes = yield* Effect.try({
+      try: () => Buffer.from(credentialHex, 'hex'),
+      catch: (error) => new Error(`Failed to parse hex string: ${error}`),
+    });
+
+    const verifyError = codec.protoType.verify(credentialBytes);
+    if (verifyError) {
+      yield* Effect.fail(new Error(verifyError));
+    }
+
+    const credentialObj = yield* Effect.try({
+      try: () => codec.decode(credentialBytes),
+      catch: (error) => new Error(`Failed to decode credential: ${error}`),
+    });
+
+    yield* Effect.tryPromise({
+      try: () => client.halo.writeCredentials([credentialObj]),
+      catch: (error) => new Error(`Failed to write credential: ${error}`),
+    });
+
+    if (json) {
+      yield* Console.log(JSON.stringify({ success: true }, null, 2));
+    } else {
+      yield* Console.log('Credential added successfully.');
+    }
+  }).pipe(
+    Effect.catchAll((error) =>
+      Effect.gen(function* () {
+        if (json) {
+          yield* Console.log(
+            JSON.stringify(
+              {
+                error: 'Invalid credential',
+                message: error instanceof Error ? error.message : String(error),
+              },
+              null,
+              2,
+            ),
+          );
+        } else {
+          yield* Console.log('Invalid credential.');
+        }
+        yield* Effect.fail(error);
+      }),
+    ),
+  );
+});
+
+export const add = Command.make(
+  'add',
+  {
+    credential: Args.text({ name: 'credential' }).pipe(
+      Args.withDescription('Credential as hex string.'),
+      Args.optional,
+    ),
+  },
+  handler,
+).pipe(Command.withDescription('Import credential into HALO.'));

package/src/cli/commands/halo/credential/add/index.ts

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

package/src/cli/commands/halo/credential/index.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+
+import { add } from './add';
+import { list } from './list';
+
+export const credential = Command.make('credential').pipe(
+  Command.withDescription('Manage HALO credentials.'),
+  Command.withSubcommands([add, list]),
+);

package/src/cli/commands/halo/credential/list/index.ts

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

package/src/cli/commands/halo/credential/list/list.test.ts

@@ -0,0 +1,27 @@
+//
+// 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 './list';
+
+describe('halo credential list', () => {
+  it('should list HALO credentials', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      yield* handler({ type: Option.none(), spaceId: Option.none(), timeout: 500, delay: 250 });
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      const parsed = TestConsole.parseJson(logs[0]);
+      expect(Array.isArray(parsed)).toBe(true);
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+});

package/src/cli/commands/halo/credential/list/list.ts

@@ -0,0 +1,115 @@
+//
+// 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 Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+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';
+
+const mapCredentials = (credentials: Credential[]) => {
+  return credentials.map((credential) => ({
+    id: credential.id?.toHex() ?? '<unknown>',
+    issuer: credential.issuer?.toHex() ?? '<unknown>',
+    subject: credential.subject?.id?.toHex() ?? '<unknown>',
+    type: credential.subject.assertion['@type'],
+    assertion: credential.subject.assertion,
+  }));
+};
+
+const printCredential = (credential: Credential) => {
+  const type = credential.subject.assertion['@type'] ?? '<unknown>';
+  return FormBuilder.make({ title: type }).pipe(
+    FormBuilder.option('id', Option.fromNullable(credential.id?.truncate())),
+    FormBuilder.option('issuer', Option.fromNullable(credential.issuer?.truncate())),
+    FormBuilder.option('subject', Option.fromNullable(credential.subject?.id?.truncate())),
+    FormBuilder.build,
+  );
+};
+
+export const handler = Effect.fn(function* ({
+  type,
+  spaceId,
+  timeout,
+  delay,
+}: {
+  type: Option.Option<string>;
+  spaceId: Option.Option<Key.SpaceId>;
+  timeout: number;
+  delay: number;
+}) {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+  let credentials: Credential[];
+
+  if (Option.isSome(spaceId)) {
+    // 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
+    const identity = client.halo.identity;
+    if (!identity) {
+      if (json) {
+        yield* Console.log(JSON.stringify({ error: 'Profile not initialized' }, null, 2));
+      } else {
+        yield* Console.log('Profile not initialized.');
+      }
+      return;
+    }
+
+    // Wait for at least one credential
+    const latch = yield* Effect.makeLatch();
+    const subscription = client.halo.credentials.subscribe((creds) => {
+      if (creds.length > 0) {
+        Effect.runSync(latch.open);
+      }
+    });
+
+    yield* latch.await.pipe(
+      Effect.timeout(Duration.millis(timeout)),
+      Effect.catchAll(() => Effect.void),
+      Effect.ensuring(
+        Effect.sync(() => {
+          subscription.unsubscribe();
+        }),
+      ),
+    );
+
+    // Wait a bit more to ensure all credentials are loaded
+    yield* Effect.sleep(Duration.millis(delay));
+
+    credentials = client.halo.queryCredentials({ type: Option.getOrUndefined(type) });
+  }
+
+  if (json) {
+    yield* Console.log(JSON.stringify(mapCredentials(credentials), null, 2));
+  } else {
+    const formatted = credentials.map(printCredential);
+    yield* Console.log(printList(formatted));
+  }
+});
+
+export const list = Command.make(
+  'list',
+  {
+    type: Options.text('type').pipe(Options.withDescription('Filter by credential type.'), Options.optional),
+    spaceId: Common.spaceId.pipe(Options.withDescription('Space ID to show credentials from.'), Options.optional),
+    timeout: Options.integer('timeout').pipe(
+      Options.withDescription('Time in milliseconds to wait for at least one credential before listing.'),
+      Options.withDefault(500),
+    ),
+    delay: Options.integer('delay').pipe(
+      Options.withDescription('Delay in milliseconds before listing.'),
+      Options.withDefault(250),
+    ),
+  },
+  handler,
+).pipe(Command.withDescription('List HALO credentials.'));

package/src/cli/commands/halo/identity/identity.test.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { TestConsole, TestLayer } from '@dxos/cli-util/testing';
+import { ClientService } from '@dxos/client';
+import { runAndForwardErrors } from '@dxos/effect';
+
+import { handler } from './identity';
+
+describe('halo identity', () => {
+  it('should log if identity is not initialized', () =>
+    Effect.gen(function* () {
+      yield* handler();
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      expect(TestConsole.extractJsonString(logs[0])).toEqual(
+        JSON.stringify({ error: 'Identity not initialized' }, null, 2),
+      );
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+
+  it('should print identity if initialized', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.halo.createIdentity({ displayName: 'Test' }));
+      yield* handler();
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      const parsedIdentity = TestConsole.parseJson(logs[0]);
+      expect(parsedIdentity).toEqual({
+        identityKey: client.halo.identity.get()?.identityKey.toHex(),
+        displayName: client.halo.identity.get()?.profile?.displayName,
+      });
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+});

package/src/cli/commands/halo/identity/identity.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+
+import { CommandConfig } from '@dxos/cli-util';
+import { print } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+
+import { printIdentity } from '../util';
+
+export const handler = Effect.fn(function* () {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+  const identity = client.halo.identity.get();
+  if (!identity) {
+    if (json) {
+      yield* Console.log(JSON.stringify({ error: 'Identity not initialized' }, null, 2));
+    } else {
+      yield* Console.log('Identity not initialized.');
+    }
+  } else {
+    if (json) {
+      yield* Console.log(
+        JSON.stringify(
+          {
+            identityKey: identity.identityKey.toHex(),
+            displayName: identity.profile?.displayName,
+          },
+          null,
+          2,
+        ),
+      );
+    } else {
+      yield* Console.log(print(printIdentity(identity)));
+    }
+  }
+});
+
+export const identity = Command.make('identity', {}, handler).pipe(
+  Command.withDescription('Get the current identity.'),
+);