@dxos/plugin-client 0.8.4-main.72ec0f3 → 0.8.4-main.7996785055

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

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

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

@@ -0,0 +1,97 @@
+//
+// 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, copyToClipboard, openBrowser, print } from '@dxos/cli-util';
+import { FormBuilder } from '@dxos/cli-util';
+import { ClientService } from '@dxos/client';
+import { Invitation, InvitationEncoder, hostInvitation } from '@dxos/client/invitations';
+
+export const handler = Effect.fn(function* ({
+  lifetime,
+  open,
+  host,
+}: {
+  lifetime: number;
+  open: boolean;
+  host: string;
+}) {
+  const { json } = yield* CommandConfig;
+  const client = yield* ClientService;
+
+  // Always use persistent and delegated (auth required) due to P2P limitations
+  const observable = client.halo.share({
+    authMethod: Invitation.AuthMethod.SHARED_SECRET,
+    persistent: true,
+    lifetime,
+  });
+
+  const invitation = yield* hostInvitation({
+    observable,
+    callbacks: {
+      onConnecting: (invitation) =>
+        Effect.gen(function* () {
+          const invitationCode = InvitationEncoder.encode(invitation);
+          const authCode = invitation.authCode!;
+
+          // Copy auth code to clipboard
+          yield* copyToClipboard(authCode).pipe(Effect.catchAll(() => Effect.void));
+
+          if (!json) {
+            yield* Console.log(`\nSecret: ${authCode} (copied to clipboard)\n`);
+          }
+
+          if (open) {
+            const url = new URL(host);
+            url.searchParams.append('deviceInvitationCode', invitationCode);
+            yield* openBrowser(url.toString()).pipe(Effect.catchAll(() => Effect.void));
+          } else if (!json) {
+            yield* Console.log(`\nInvitation: ${invitationCode}\n`);
+          }
+        }),
+    },
+    waitForSuccess: true,
+  });
+
+  if (json) {
+    yield* Console.log(
+      JSON.stringify(
+        {
+          invitationCode: InvitationEncoder.encode(invitation),
+          authCode: invitation.authCode,
+          state: Invitation.State[invitation.state],
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    const builder = FormBuilder.make({ title: 'HALO Invitation' }).pipe(
+      FormBuilder.set('invitationCode', InvitationEncoder.encode(invitation)),
+      FormBuilder.set('authCode', invitation.authCode ?? '<none>'),
+      FormBuilder.set('state', Invitation.State[invitation.state]),
+    );
+    yield* Console.log(print(FormBuilder.build(builder)));
+  }
+});
+
+export const share = Command.make(
+  'share',
+  {
+    lifetime: Options.integer('lifetime').pipe(
+      Options.withDescription('Lifetime of the invitation in seconds.'),
+      Options.withDefault(12 * 60 * 60), // 12 hours - HALO invitations are typically shorter-lived
+    ),
+    open: Options.boolean('open', { ifPresent: true }).pipe(Options.withDescription('Open browser with invitation.')),
+    host: Options.text('host').pipe(
+      Options.withDescription('Application Host URL.'),
+      Options.withDefault('https://composer.space'),
+    ),
+  },
+  handler,
+).pipe(Command.withDescription('Create HALO (device) invitation.'));

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

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

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

@@ -0,0 +1,28 @@
+//
+// 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 './update';
+
+describe('halo update', () => {
+  it('should update identity display name', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      yield* handler({ displayName: 'Updated Name' });
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      const parsed = TestConsole.parseJson<{ identityKey: string; displayName: string }>(logs[0]);
+      expect(parsed).toHaveProperty('identityKey');
+      expect(parsed).toHaveProperty('displayName', 'Updated Name');
+      expect(parsed.identityKey).toBe(client.halo.identity.get()?.identityKey.toHex());
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+});

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

@@ -0,0 +1,67 @@
+//
+// 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 { printIdentity } from '../util';
+
+export const handler = Effect.fn(function* ({ displayName }: { displayName: string }) {
+  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.');
+    }
+    return;
+  }
+
+  const identityService = client.services.services.IdentityService;
+  if (!identityService) {
+    if (json) {
+      yield* Console.log(JSON.stringify({ error: 'IdentityService not found' }, null, 2));
+    } else {
+      yield* Console.log('IdentityService not found.');
+    }
+    return;
+  }
+
+  const updatedIdentity = yield* Effect.tryPromise(() =>
+    identityService.updateProfile({
+      displayName,
+    }),
+  );
+
+  if (json) {
+    yield* Console.log(
+      JSON.stringify(
+        {
+          identityKey: updatedIdentity.identityKey.toHex(),
+          displayName: updatedIdentity.profile?.displayName,
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    yield* Console.log(print(printIdentity(updatedIdentity)));
+  }
+});
+
+export const update = Command.make(
+  'update',
+  {
+    displayName: Options.text('displayName').pipe(Options.withDescription('The display name of the identity.')),
+  },
+  handler,
+).pipe(Command.withDescription('Update identity profile.'));

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

@@ -0,0 +1,18 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { FormBuilder } from '@dxos/cli-util';
+
+/**
+ * Pretty prints an identity with ANSI colors.
+ */
+export const printIdentity = (identity: {
+  identityKey: { toHex(): string; truncate(): string };
+  profile?: { displayName?: string };
+}) =>
+  FormBuilder.make({ title: 'Identity' }).pipe(
+    FormBuilder.set('identityKey', identity.identityKey.truncate()),
+    FormBuilder.set('displayName', identity.profile?.displayName ?? '<none>'),
+    FormBuilder.build,
+  );

package/src/cli/commands/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './config';
+export * from './device';
+export * from './edge';
+export * from './halo';
+export * from './profile';

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

@@ -0,0 +1,90 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as Path from '@effect/platform/Path';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import * as Record from 'effect/Record';
+
+import { CommandConfig, print } from '@dxos/cli-util';
+import { DX_CONFIG, getProfileConfigPath } from '@dxos/client-protocol';
+import { trim } from '@dxos/util';
+
+import { printProfileCreated } from './util';
+
+const TEMPLATES = {
+  default: trim`
+    version: 1
+    runtime:
+      client:
+        storage:
+          persistent: true
+      services:
+        edge:
+          url: https://edge-production.dxos.workers.dev
+  `,
+  main: trim`
+    version: 1
+    runtime:
+      client:
+        storage:
+          persistent: true
+      services:
+        edge:
+          url: https://edge-main.dxos.workers.dev
+  `,
+  dev: trim`
+    version: 1
+    runtime:
+      client:
+        storage:
+          persistent: true
+      services:
+        edge:
+          url: https://edge.dxos.workers.dev
+  `,
+  local: trim`
+    version: 1
+    runtime:
+      client:
+        storage:
+          persistent: true
+      services:
+        edge:
+          url: http://localhost:8787
+  `,
+} as const;
+
+export const create = Command.make(
+  'create',
+  {
+    template: Options.choice('template', Record.keys(TEMPLATES)).pipe(
+      Options.withDescription('Template to use'),
+      Options.withDefault('default'),
+    ),
+    name: Options.text('name').pipe(Options.withDescription('Profile name'), Options.optional),
+  },
+  Effect.fnUntraced(function* ({ template, name }) {
+    const { json } = yield* CommandConfig;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const profileName = name.pipe(Option.getOrElse(() => template));
+    const configPath = getProfileConfigPath(DX_CONFIG, profileName);
+    if (yield* fs.exists(configPath)) {
+      throw new Error(`Profile ${profileName} already exists`);
+    }
+
+    yield* fs.makeDirectory(path.dirname(configPath), { recursive: true });
+    yield* fs.writeFileString(configPath, TEMPLATES[template]);
+    if (json) {
+      yield* Console.log(JSON.stringify({ name: profileName, path: configPath }, null, 2));
+    } else {
+      yield* Console.log(print(printProfileCreated(profileName, configPath)));
+    }
+  }),
+);

package/src/cli/commands/profile/delete.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { CommandConfig, print } from '@dxos/cli-util';
+import { DX_CONFIG, getProfileConfigPath } from '@dxos/client-protocol';
+
+import { printProfileDeleted } from './util';
+
+export const del = Command.make(
+  'delete',
+  {
+    name: Options.text('name').pipe(Options.withDescription('Profile name'), Options.optional),
+  },
+  Effect.fnUntraced(function* ({ name }) {
+    const { json } = yield* CommandConfig;
+    const fs = yield* FileSystem.FileSystem;
+    const profileName = name.pipe(Option.getOrElse(() => 'default'));
+    const configPath = getProfileConfigPath(DX_CONFIG, profileName);
+    const pluginsPath = `${DX_CONFIG}/plugins/${profileName}.yml`;
+    yield* fs.remove(configPath).pipe(Effect.ignore);
+    yield* fs.remove(pluginsPath).pipe(Effect.ignore);
+    if (json) {
+      yield* Console.log(JSON.stringify({ name: profileName, deleted: true }, null, 2));
+    } else {
+      yield* Console.log(print(printProfileDeleted(profileName)));
+    }
+  }),
+);

package/src/cli/commands/profile/import.ts

@@ -0,0 +1,101 @@
+//
+// 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 FileSystem from '@effect/platform/FileSystem';
+import * as Path from '@effect/platform/Path';
+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 { ConfigService } from '@dxos/config';
+import { log } from '@dxos/log';
+import type { Runtime } from '@dxos/protocols/proto/dxos/config';
+
+export const handler = Effect.fn(function* ({
+  file,
+  dataDir,
+  force,
+}: {
+  file: string;
+  dataDir: Option.Option<string>;
+  force: boolean;
+}) {
+  const dataDirValue = Option.getOrUndefined(dataDir);
+  const { json, profile } = yield* CommandConfig;
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const config = yield* ConfigService;
+
+  const { createLevel, createStorageObjects, importProfileData, decodeProfileArchive } = yield* Effect.promise(
+    () => import('@dxos/client-services'),
+  );
+
+  let storageConfig: Runtime.Client.Storage;
+  if (!dataDirValue) {
+    if (!force) {
+      yield* Console.log(`Will overwrite profile: ${profile}`);
+      const confirmed = yield* Prompt.confirm({
+        message: `Delete all data? (Profile: ${profile})`,
+        initial: false,
+      }).pipe(Prompt.run);
+      if (!confirmed) {
+        return;
+      }
+    }
+    storageConfig = config.values.runtime!.client!.storage!;
+  } else {
+    const fullPath = path.resolve(dataDirValue);
+    yield* Console.log(`Importing into: ${fullPath}`);
+    storageConfig = {
+      persistent: true,
+      dataRoot: fullPath,
+    };
+  }
+
+  if (yield* fs.exists(storageConfig.dataRoot!)) {
+    log.error('data directory already exists', { path: storageConfig.dataRoot! });
+    if (json) {
+      yield* Console.log(JSON.stringify({ error: 'Data directory already exists' }, null, 2));
+    } else {
+      yield* Console.log('Data directory already exists.');
+    }
+    return;
+  }
+
+  const data = yield* fs.readFile(file);
+
+  const archive = decodeProfileArchive(data);
+  yield* Console.log(`Importing archive with ${archive.storage.length} entries`);
+
+  const { storage } = createStorageObjects(storageConfig);
+  const level = yield* Effect.tryPromise({
+    try: () => createLevel(storageConfig),
+    catch: (error) => new Error(`Failed to create level: ${error}`),
+  });
+
+  yield* Console.log('Beginning profile import...');
+  yield* Effect.tryPromise({
+    try: () => importProfileData({ storage, level }, archive),
+    catch: (error) => new Error(`Failed to import profile data: ${error}`),
+  });
+  yield* Console.log('Profile import complete');
+
+  if (json) {
+    yield* Console.log(JSON.stringify({ success: true, profile, entries: archive.storage.length }, null, 2));
+  }
+});
+
+export const importCommand = Command.make(
+  'import',
+  {
+    file: Options.text('file').pipe(Options.withDescription('Archive filename.'), Options.withAlias('f')),
+    dataDir: Options.text('data-dir').pipe(Options.withDescription('Storage directory.'), Options.optional),
+    force: Options.boolean('force', { ifPresent: true }).pipe(Options.withDescription('Skip confirmation prompt.')),
+  },
+  handler,
+).pipe(Command.withDescription('Import profile.'));

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

@@ -0,0 +1,17 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+
+import { create } from './create';
+import { del } from './delete';
+import { importCommand } from './import';
+import { inspect } from './inspect';
+import { list } from './list';
+import { reset } from './reset';
+
+export const profile = Command.make('profile').pipe(
+  Command.withDescription('Profile commands.'),
+  Command.withSubcommands([create, del, importCommand, inspect, list, reset]),
+);

package/src/cli/commands/profile/inspect.ts

@@ -0,0 +1,64 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+
+import { CommandConfig, FormBuilder, print } from '@dxos/cli-util';
+import { ProfileArchiveEntryType } from '@dxos/protocols';
+import { arrayToBuffer } from '@dxos/util';
+
+export const handler = Effect.fn(function* ({ file, storage }: { file: string; storage: boolean }) {
+  const { json } = yield* CommandConfig;
+  const fs = yield* FileSystem.FileSystem;
+
+  const { decodeProfileArchive } = yield* Effect.promise(() => import('@dxos/client-services'));
+
+  const data = yield* fs.readFile(file);
+
+  const archive = decodeProfileArchive(data);
+
+  if (json) {
+    yield* Console.log(
+      JSON.stringify(
+        {
+          meta: archive.meta,
+          ...(storage ? { storage: archive.storage } : {}),
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    const builder = FormBuilder.make({ title: 'Profile Archive' }).pipe(
+      FormBuilder.when(
+        archive.meta,
+        FormBuilder.each(Object.entries(archive.meta ?? {}), ([key, value]) => FormBuilder.set(key, String(value))),
+      ),
+      FormBuilder.build,
+    );
+    yield* Console.log(print(builder));
+
+    if (storage) {
+      yield* Console.log('\nStorage entries:\n');
+      for (const entry of archive.storage) {
+        const key =
+          typeof entry.key === 'string' ? entry.key : JSON.stringify(arrayToBuffer(entry.key).toString()).slice(1, -1);
+        yield* Console.log(`  ${ProfileArchiveEntryType[entry.type]} ${key}`);
+      }
+    }
+  }
+});
+
+export const inspect = Command.make(
+  'inspect',
+  {
+    file: Options.text('file').pipe(Options.withDescription('Archive filename.'), Options.withAlias('f')),
+    storage: Options.boolean('storage', { ifPresent: true }).pipe(Options.withDescription('List storage entries.')),
+  },
+  handler,
+).pipe(Command.withDescription('Inspect profile archive.'));

package/src/cli/commands/profile/list.ts

@@ -0,0 +1,55 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as Path from '@effect/platform/Path';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Yaml from 'yaml';
+
+import { CommandConfig, printList } from '@dxos/cli-util';
+import { Config } from '@dxos/client';
+import { DX_CONFIG, DX_DATA, getProfilePath } from '@dxos/client-protocol';
+
+import { printProfile } from './util';
+
+export const list = Command.make(
+  'list',
+  {},
+  Effect.fnUntraced(function* () {
+    const { profile: currentProfile } = yield* CommandConfig;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const profileDir = path.join(DX_CONFIG, 'profile');
+    const entries = yield* fs.readDirectory(profileDir);
+    const profileFiles = entries.filter((entry) => entry.endsWith('.yml'));
+    const profiles = yield* Effect.forEach(profileFiles, (filename) =>
+      Effect.gen(function* () {
+        const name = filename.slice(0, -4);
+        const configPath = path.join(profileDir, filename);
+        const configContent = yield* fs
+          .readFileString(configPath)
+          .pipe(Effect.catchTag('SystemError', () => Effect.succeed('{}')));
+        const configValues = Yaml.parse(configContent) ?? {};
+        const config = new Config(configValues);
+        return {
+          name,
+          isCurrent: name === currentProfile,
+          fullPath: configPath,
+          storagePath: getProfilePath(configValues?.runtime?.client?.storage?.dataRoot ?? DX_DATA, name),
+          edge: config.values.runtime?.services?.edge?.url,
+        };
+      }),
+    );
+
+    const { json } = yield* CommandConfig;
+    if (json) {
+      yield* Console.log(JSON.stringify(profiles, null, 2));
+    } else {
+      const formatted = profiles.map(printProfile);
+      yield* Console.log(printList(formatted));
+    }
+  }),
+);

package/src/cli/commands/profile/reset.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 Prompt from '@effect/cli/Prompt';
+import * as FileSystem from '@effect/platform/FileSystem';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+
+import { CommandConfig, print } from '@dxos/cli-util';
+import { DX_DATA, getProfilePath } from '@dxos/client-protocol';
+import { ConfigService } from '@dxos/config';
+
+import { printProfileReset } from './util';
+
+export const reset = Command.make(
+  'reset',
+  {
+    force: Options.boolean('force', { ifPresent: true }).pipe(Options.withDescription('Skip confirmation prompt')),
+  },
+  Effect.fnUntraced(function* ({ force }) {
+    const fs = yield* FileSystem.FileSystem;
+    const config = yield* ConfigService;
+    const { json, profile } = yield* CommandConfig;
+    const path = config.values.runtime?.client?.storage?.dataRoot ?? getProfilePath(DX_DATA, profile);
+    if (!force) {
+      const confirmed = yield* Prompt.confirm({
+        message: `Are you sure you want to reset the profile (${profile})?`,
+        initial: false,
+      });
+      if (!confirmed) {
+        return;
+      }
+    }
+
+    yield* fs.remove(path, { recursive: true });
+    if (json) {
+      yield* Console.log(JSON.stringify({ profile, reset: true }, null, 2));
+    } else {
+      yield* Console.log(print(printProfileReset(profile)));
+    }
+  }),
+);