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

package/dist/lib/node-esm/cli/index.mjs

@@ -0,0 +1,1052 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  Client,
+  OperationResolver,
+  SchemaDefs
+} from "../chunk-H2CCMM4Z.mjs";
+import {
+  ClientEvents,
+  ClientOperation
+} from "../chunk-VEUNEDN5.mjs";
+import {
+  meta
+} from "../chunk-RGULICLJ.mjs";
+
+// src/cli/plugin.ts
+import { ActivationEvents, Capability, Plugin as Plugin2 } from "@dxos/app-framework";
+import { AppActivationEvents, AppPlugin } from "@dxos/app-toolkit";
+
+// src/cli/commands/config/index.ts
+import * as Command2 from "@effect/cli/Command";
+
+// src/cli/commands/config/view.ts
+import * as Command from "@effect/cli/Command";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as Yaml from "yaml";
+import { CommandConfig } from "@dxos/cli-util";
+import { ConfigService } from "@dxos/client";
+var view = Command.make("view", {}, Effect.fnUntraced(function* () {
+  const config2 = yield* ConfigService;
+  const { json } = yield* CommandConfig;
+  if (json) {
+    yield* Console.log(JSON.stringify(config2.values, null, 2));
+  } else {
+    yield* Console.log(Yaml.stringify(config2.values));
+  }
+}));
+
+// src/cli/commands/config/index.ts
+var config = Command2.make("config").pipe(Command2.withDescription("Config commands."), Command2.withSubcommands([
+  view
+]));
+
+// src/cli/commands/device/index.ts
+import * as Command6 from "@effect/cli/Command";
+
+// src/cli/commands/device/info/info.ts
+import * as Command3 from "@effect/cli/Command";
+import * as Console2 from "effect/Console";
+import * as Effect2 from "effect/Effect";
+import { CommandConfig as CommandConfig2 } from "@dxos/cli-util";
+import { print } from "@dxos/cli-util";
+import { ClientService } from "@dxos/client";
+import { DeviceType as DeviceType2 } from "@dxos/protocols/proto/dxos/halo/credentials";
+
+// src/cli/commands/device/util.ts
+import { FormBuilder } from "@dxos/cli-util";
+import { Device, DeviceKind, DeviceType } from "@dxos/client/halo";
+var maybeTruncateKey = (key, truncate = false) => truncate ? key.truncate() : key.toHex();
+var getDeviceTitle = (device2) => {
+  if (device2.profile?.label) {
+    return device2.profile.label;
+  }
+  const platform = device2.profile?.platform ?? "Unknown";
+  const os = device2.profile?.os ?? "Unknown";
+  return `${platform} on ${os}`;
+};
+var mapDevices = (devices, truncateKeys = false) => {
+  return devices.map((device2) => ({
+    label: device2.profile?.label,
+    type: device2.profile?.type ? DeviceType[device2.profile?.type] : "UNKNOWN",
+    key: maybeTruncateKey(device2.deviceKey, truncateKeys),
+    kind: DeviceKind[device2.kind],
+    platform: device2.profile?.platform,
+    platformVersion: device2.profile?.platformVersion,
+    architecture: device2.profile?.architecture,
+    os: device2.profile?.os,
+    osVersion: device2.profile?.osVersion,
+    presence: device2?.kind === DeviceKind.CURRENT ? "THIS DEVICE" : Device.PresenceState[device2.presence]
+  }));
+};
+var printDevice = (device2) => FormBuilder.make({
+  title: getDeviceTitle(device2)
+}).pipe(FormBuilder.set("deviceKey", device2.deviceKey.truncate()), FormBuilder.set("label", device2.profile?.label ?? "<none>"), FormBuilder.set("type", device2.profile?.type ? DeviceType[device2.profile?.type] : "UNKNOWN"), FormBuilder.set("kind", DeviceKind[device2.kind]), FormBuilder.set("presence", device2?.kind === DeviceKind.CURRENT ? "THIS DEVICE" : Device.PresenceState[device2.presence]), FormBuilder.set("platform", device2.profile?.platform ?? "<none>"), FormBuilder.set("platformVersion", device2.profile?.platformVersion ?? "<none>"), FormBuilder.set("architecture", device2.profile?.architecture ?? "<none>"), FormBuilder.set("os", device2.profile?.os ?? "<none>"), FormBuilder.set("osVersion", device2.profile?.osVersion ?? "<none>"), FormBuilder.build);
+var printDevices = (devices) => {
+  return devices.map(printDevice);
+};
+
+// src/cli/commands/device/info/info.ts
+var handler = Effect2.fn(function* () {
+  const { json } = yield* CommandConfig2;
+  const client = yield* ClientService;
+  yield* Effect2.tryPromise(() => client.spaces.waitUntilReady());
+  const device2 = client.halo.device;
+  if (!device2) {
+    if (json) {
+      yield* Console2.log(JSON.stringify({
+        error: "No device found"
+      }, null, 2));
+    } else {
+      yield* Console2.log("No device found.");
+    }
+    return;
+  }
+  if (json) {
+    yield* Console2.log(JSON.stringify({
+      deviceKey: device2.deviceKey.toHex(),
+      profile: {
+        ...device2.profile,
+        type: device2.profile?.type ? DeviceType2[device2.profile?.type] : "UNKNOWN"
+      }
+    }, null, 2));
+  } else {
+    yield* Console2.log(print(printDevice(device2)));
+  }
+});
+var info = Command3.make("info", {}, handler).pipe(Command3.withDescription("Show device info."));
+
+// src/cli/commands/device/list/list.ts
+import * as Command4 from "@effect/cli/Command";
+import * as Console3 from "effect/Console";
+import * as Effect3 from "effect/Effect";
+import { CommandConfig as CommandConfig3 } from "@dxos/cli-util";
+import { printList } from "@dxos/cli-util";
+import { ClientService as ClientService2 } from "@dxos/client";
+var handler2 = Effect3.fn(function* () {
+  const { json } = yield* CommandConfig3;
+  const client = yield* ClientService2;
+  yield* Effect3.tryPromise(() => client.spaces.waitUntilReady());
+  const devices = client.halo.devices.get();
+  if (json) {
+    yield* Console3.log(JSON.stringify(mapDevices(devices), null, 2));
+  } else {
+    const formatted = printDevices(devices);
+    yield* Console3.log(printList(formatted));
+  }
+});
+var list = Command4.make("list", {}, handler2).pipe(Command4.withDescription("List devices."));
+
+// src/cli/commands/device/update/update.ts
+import * as Command5 from "@effect/cli/Command";
+import * as Options from "@effect/cli/Options";
+import * as Console4 from "effect/Console";
+import * as Effect4 from "effect/Effect";
+import { CommandConfig as CommandConfig4 } from "@dxos/cli-util";
+import { print as print2 } from "@dxos/cli-util";
+import { ClientService as ClientService3 } from "@dxos/client";
+var handler3 = Effect4.fn(function* ({ label }) {
+  const { json } = yield* CommandConfig4;
+  const client = yield* ClientService3;
+  yield* Effect4.tryPromise(() => client.spaces.waitUntilReady());
+  const device2 = client.halo.device;
+  if (!device2) {
+    if (json) {
+      yield* Console4.log(JSON.stringify({
+        error: "No device found"
+      }, null, 2));
+    } else {
+      yield* Console4.log("No device found.");
+    }
+    return;
+  }
+  const updatedProfile = {
+    ...device2.profile,
+    label
+  };
+  const devicesService = client.services.services.DevicesService;
+  if (!devicesService) {
+    if (json) {
+      yield* Console4.log(JSON.stringify({
+        error: "DevicesService not found"
+      }, null, 2));
+    } else {
+      yield* Console4.log("DevicesService not found.");
+    }
+    return;
+  }
+  const updatedDevice = yield* Effect4.tryPromise(() => devicesService.updateDevice(updatedProfile));
+  if (json) {
+    yield* Console4.log(JSON.stringify({
+      deviceKey: updatedDevice.deviceKey.toHex(),
+      profile: updatedDevice.profile
+    }, null, 2));
+  } else {
+    yield* Console4.log(print2(printDevice(updatedDevice)));
+  }
+});
+var update = Command5.make("update", {
+  label: Options.text("label").pipe(Options.withDescription("The device label."))
+}, handler3).pipe(Command5.withDescription("Update device label."));
+
+// src/cli/commands/device/index.ts
+var device = Command6.make("device").pipe(Command6.withDescription("Manage HALO devices."), Command6.withSubcommands([
+  info,
+  list,
+  update
+]));
+
+// src/cli/commands/edge/index.ts
+import * as Command8 from "@effect/cli/Command";
+
+// src/cli/commands/edge/status.ts
+import * as Command7 from "@effect/cli/Command";
+import * as Console5 from "effect/Console";
+import * as Effect5 from "effect/Effect";
+import * as Option from "effect/Option";
+import { CommandConfig as CommandConfig5 } from "@dxos/cli-util";
+import { ClientService as ClientService4 } from "@dxos/client";
+import { createEdgeIdentity } from "@dxos/client/edge";
+var getStatus = () => Effect5.gen(function* () {
+  const client = yield* ClientService4;
+  const identity2 = createEdgeIdentity(client);
+  client.edge.http.setIdentity(identity2);
+  const status2 = yield* Effect5.tryPromise(() => client.edge.http.getStatus());
+  if (yield* CommandConfig5.isJson) {
+    yield* Console5.log(JSON.stringify(status2, null, 2));
+  } else if (status2.problems.length > 0) {
+    for (const problem of status2.problems) {
+      yield* Console5.error(problem);
+    }
+  } else {
+    yield* Console5.log("No problems found.");
+  }
+}).pipe(
+  // TODO(wittjosiah): Tagged error.
+  Effect5.catchSome((error2) => {
+    if (error2 instanceof Error && error2.message === "Identity not available") {
+      return Option.some(Console5.error(error2.message));
+    } else {
+      return Option.none();
+    }
+  })
+);
+var status = Command7.make("status", {}, getStatus).pipe(Command7.withDescription("Get the EDGE status for the current identity."));
+
+// src/cli/commands/edge/index.ts
+var edge = Command8.make("edge").pipe(Command8.withDescription("EDGE commands."), Command8.withSubcommands([
+  status
+]));
+
+// src/cli/commands/halo/index.ts
+import * as Command18 from "@effect/cli/Command";
+
+// src/cli/commands/halo/create/create.ts
+import * as Command9 from "@effect/cli/Command";
+import * as Options2 from "@effect/cli/Options";
+import * as Console6 from "effect/Console";
+import * as Effect6 from "effect/Effect";
+import * as Option2 from "effect/Option";
+import { Capabilities, Plugin } from "@dxos/app-framework";
+import { CommandConfig as CommandConfig6, flushAndSync, spaceLayer } from "@dxos/cli-util";
+import { print as print3 } from "@dxos/cli-util";
+import { ClientService as ClientService5 } from "@dxos/client";
+import { invariant } from "@dxos/invariant";
+
+// src/cli/commands/halo/util.ts
+import { FormBuilder as FormBuilder2 } from "@dxos/cli-util";
+var printIdentity = (identity2) => FormBuilder2.make({
+  title: "Identity"
+}).pipe(FormBuilder2.set("identityKey", identity2.identityKey.truncate()), FormBuilder2.set("displayName", identity2.profile?.displayName ?? "<none>"), FormBuilder2.build);
+
+// src/cli/commands/halo/create/create.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-client/src/cli/commands/halo/create/create.ts";
+var handler4 = Effect6.fn(function* ({ agent, displayName }) {
+  const { json } = yield* CommandConfig6;
+  const client = yield* ClientService5;
+  invariant(!client.halo.identity.get(), "Identity already exists", {
+    F: __dxlog_file,
+    L: 30,
+    S: this,
+    A: [
+      "!client.halo.identity.get()",
+      "'Identity already exists'"
+    ]
+  });
+  const manager = yield* Plugin.Service;
+  const { invoke } = manager.capabilities.get(Capabilities.OperationInvoker);
+  const identity2 = yield* invoke(ClientOperation.CreateIdentity, {
+    displayName: Option2.getOrUndefined(displayName)
+  });
+  if (agent) {
+    yield* invoke(ClientOperation.CreateAgent);
+  }
+  yield* Effect6.promise(() => client.spaces.waitUntilReady());
+  yield* Effect6.promise(() => client.spaces.default.waitUntilReady());
+  const space = client.spaces.default;
+  yield* flushAndSync({
+    indexes: true
+  }).pipe(Effect6.provide(spaceLayer(Option2.some(space.id))));
+  if (json) {
+    yield* Console6.log(JSON.stringify({
+      identityKey: identity2.identityKey.toHex(),
+      displayName: identity2.profile?.displayName
+    }, null, 2));
+  } else {
+    yield* Console6.log(print3(printIdentity(identity2)));
+  }
+});
+var create = Command9.make("create", {
+  agent: Options2.boolean("noAgent", {
+    ifPresent: false
+  }).pipe(Options2.withDescription("Do not create an EDGE agent for the identity.")),
+  displayName: Options2.text("displayName").pipe(Options2.withDescription("The display name of the identity."), Options2.optional)
+}, handler4).pipe(Command9.withDescription("Create a new identity."));
+
+// src/cli/commands/halo/credential/index.ts
+import * as Command12 from "@effect/cli/Command";
+
+// src/cli/commands/halo/credential/add/add.ts
+import * as Args from "@effect/cli/Args";
+import * as Command10 from "@effect/cli/Command";
+import * as Prompt from "@effect/cli/Prompt";
+import * as Console7 from "effect/Console";
+import * as Effect7 from "effect/Effect";
+import * as Option3 from "effect/Option";
+import { CommandConfig as CommandConfig7 } from "@dxos/cli-util";
+import { ClientService as ClientService6 } from "@dxos/client";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { schema } from "@dxos/protocols/proto";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-client/src/cli/commands/halo/credential/add/add.ts";
+var handler5 = Effect7.fn(function* ({ credential: credential2 }) {
+  const { json } = yield* CommandConfig7;
+  const client = yield* ClientService6;
+  let credentialHex = Option3.getOrUndefined(credential2);
+  if (!credentialHex) {
+    credentialHex = yield* Prompt.text({
+      message: "Enter credential (hex string)"
+    }).pipe(Prompt.run);
+  }
+  invariant2(credentialHex, "Invalid credential.", {
+    F: __dxlog_file2,
+    L: 26,
+    S: this,
+    A: [
+      "credentialHex",
+      "'Invalid credential.'"
+    ]
+  });
+  const identity2 = client.halo.identity;
+  if (!identity2) {
+    if (json) {
+      yield* Console7.log(JSON.stringify({
+        error: "Profile not initialized"
+      }, null, 2));
+    } else {
+      yield* Console7.log("Profile not initialized.");
+    }
+    return;
+  }
+  yield* Effect7.gen(function* () {
+    const codec = schema.getCodecForType("dxos.halo.credentials.Credential");
+    const credentialBytes = yield* Effect7.try({
+      try: () => Buffer.from(credentialHex, "hex"),
+      catch: (error2) => new Error(`Failed to parse hex string: ${error2}`)
+    });
+    const verifyError = codec.protoType.verify(credentialBytes);
+    if (verifyError) {
+      yield* Effect7.fail(new Error(verifyError));
+    }
+    const credentialObj = yield* Effect7.try({
+      try: () => codec.decode(credentialBytes),
+      catch: (error2) => new Error(`Failed to decode credential: ${error2}`)
+    });
+    yield* Effect7.tryPromise({
+      try: () => client.halo.writeCredentials([
+        credentialObj
+      ]),
+      catch: (error2) => new Error(`Failed to write credential: ${error2}`)
+    });
+    if (json) {
+      yield* Console7.log(JSON.stringify({
+        success: true
+      }, null, 2));
+    } else {
+      yield* Console7.log("Credential added successfully.");
+    }
+  }).pipe(Effect7.catchAll((error2) => Effect7.gen(function* () {
+    if (json) {
+      yield* Console7.log(JSON.stringify({
+        error: "Invalid credential",
+        message: error2 instanceof Error ? error2.message : String(error2)
+      }, null, 2));
+    } else {
+      yield* Console7.log("Invalid credential.");
+    }
+    yield* Effect7.fail(error2);
+  })));
+});
+var add = Command10.make("add", {
+  credential: Args.text({
+    name: "credential"
+  }).pipe(Args.withDescription("Credential as hex string."), Args.optional)
+}, handler5).pipe(Command10.withDescription("Import credential into HALO."));
+
+// src/cli/commands/halo/credential/list/list.ts
+import * as Command11 from "@effect/cli/Command";
+import * as Options3 from "@effect/cli/Options";
+import * as Console8 from "effect/Console";
+import * as Duration from "effect/Duration";
+import * as Effect8 from "effect/Effect";
+import * as Option4 from "effect/Option";
+import { CommandConfig as CommandConfig8, Common, FormBuilder as FormBuilder3, getSpace, printList as printList2, spaceIdWithDefault } from "@dxos/cli-util";
+import { ClientService as ClientService7 } from "@dxos/client";
+var mapCredentials = (credentials) => {
+  return credentials.map((credential2) => ({
+    id: credential2.id?.toHex() ?? "<unknown>",
+    issuer: credential2.issuer?.toHex() ?? "<unknown>",
+    subject: credential2.subject?.id?.toHex() ?? "<unknown>",
+    type: credential2.subject.assertion["@type"],
+    assertion: credential2.subject.assertion
+  }));
+};
+var printCredential = (credential2) => {
+  const type = credential2.subject.assertion["@type"] ?? "<unknown>";
+  return FormBuilder3.make({
+    title: type
+  }).pipe(FormBuilder3.option("id", Option4.fromNullable(credential2.id?.truncate())), FormBuilder3.option("issuer", Option4.fromNullable(credential2.issuer?.truncate())), FormBuilder3.option("subject", Option4.fromNullable(credential2.subject?.id?.truncate())), FormBuilder3.build);
+};
+var handler6 = Effect8.fn(function* ({ type, spaceId, timeout: timeout2, delay }) {
+  const { json } = yield* CommandConfig8;
+  const client = yield* ClientService7;
+  yield* Effect8.tryPromise(() => client.spaces.waitUntilReady());
+  let credentials;
+  const resolvedSpaceId = yield* spaceIdWithDefault(spaceId);
+  if (Option4.isSome(spaceId)) {
+    const space = yield* getSpace(resolvedSpaceId);
+    credentials = yield* Effect8.tryPromise(() => space.internal.getCredentials());
+  } else {
+    const identity2 = client.halo.identity;
+    if (!identity2) {
+      if (json) {
+        yield* Console8.log(JSON.stringify({
+          error: "Profile not initialized"
+        }, null, 2));
+      } else {
+        yield* Console8.log("Profile not initialized.");
+      }
+      return;
+    }
+    const latch = yield* Effect8.makeLatch();
+    const subscription = client.halo.credentials.subscribe((creds) => {
+      if (creds.length > 0) {
+        Effect8.runSync(latch.open);
+      }
+    });
+    yield* latch.await.pipe(Effect8.timeout(Duration.millis(timeout2)), Effect8.catchAll(() => Effect8.void), Effect8.ensuring(Effect8.sync(() => {
+      subscription.unsubscribe();
+    })));
+    yield* Effect8.sleep(Duration.millis(delay));
+    credentials = client.halo.queryCredentials({
+      type: Option4.getOrUndefined(type)
+    });
+  }
+  if (json) {
+    yield* Console8.log(JSON.stringify(mapCredentials(credentials), null, 2));
+  } else {
+    const formatted = credentials.map(printCredential);
+    yield* Console8.log(printList2(formatted));
+  }
+});
+var list2 = Command11.make("list", {
+  type: Options3.text("type").pipe(Options3.withDescription("Filter by credential type."), Options3.optional),
+  spaceId: Common.spaceId.pipe(Options3.withDescription("Space ID to show credentials from."), Options3.optional),
+  timeout: Options3.integer("timeout").pipe(Options3.withDescription("Time in milliseconds to wait for at least one credential before listing."), Options3.withDefault(500)),
+  delay: Options3.integer("delay").pipe(Options3.withDescription("Delay in milliseconds before listing."), Options3.withDefault(250))
+}, handler6).pipe(Command11.withDescription("List HALO credentials."));
+
+// src/cli/commands/halo/credential/index.ts
+var credential = Command12.make("credential").pipe(Command12.withDescription("Manage HALO credentials."), Command12.withSubcommands([
+  add,
+  list2
+]));
+
+// src/cli/commands/halo/identity/identity.ts
+import * as Command13 from "@effect/cli/Command";
+import * as Console9 from "effect/Console";
+import * as Effect9 from "effect/Effect";
+import { CommandConfig as CommandConfig9 } from "@dxos/cli-util";
+import { print as print4 } from "@dxos/cli-util";
+import { ClientService as ClientService8 } from "@dxos/client";
+var handler7 = Effect9.fn(function* () {
+  const { json } = yield* CommandConfig9;
+  const client = yield* ClientService8;
+  const identity2 = client.halo.identity.get();
+  if (!identity2) {
+    if (json) {
+      yield* Console9.log(JSON.stringify({
+        error: "Identity not initialized"
+      }, null, 2));
+    } else {
+      yield* Console9.log("Identity not initialized.");
+    }
+  } else {
+    yield* Effect9.tryPromise(() => client.spaces.waitUntilReady());
+    if (json) {
+      yield* Console9.log(JSON.stringify({
+        identityKey: identity2.identityKey.toHex(),
+        displayName: identity2.profile?.displayName
+      }, null, 2));
+    } else {
+      yield* Console9.log(print4(printIdentity(identity2)));
+    }
+  }
+});
+var identity = Command13.make("identity", {}, handler7).pipe(Command13.withDescription("Get the current identity."));
+
+// src/cli/commands/halo/keys/keys.ts
+import * as Command14 from "@effect/cli/Command";
+import * as Console10 from "effect/Console";
+import * as Effect10 from "effect/Effect";
+import * as Option5 from "effect/Option";
+import { CommandConfig as CommandConfig10 } from "@dxos/cli-util";
+import { FormBuilder as FormBuilder4, print as print5 } from "@dxos/cli-util";
+import { ClientService as ClientService9 } from "@dxos/client";
+var handler8 = Effect10.fn(function* () {
+  const { json } = yield* CommandConfig10;
+  const client = yield* ClientService9;
+  yield* Effect10.tryPromise(() => client.spaces.waitUntilReady());
+  const identity2 = client.halo.identity.get();
+  const device2 = client.halo.device;
+  if (json) {
+    yield* Console10.log(JSON.stringify({
+      identityKey: identity2?.identityKey.toHex(),
+      deviceKey: device2?.deviceKey.toHex()
+    }, null, 2));
+  } else {
+    const builder = FormBuilder4.make({
+      title: "HALO Keys"
+    }).pipe(FormBuilder4.option("identityKey", Option5.fromNullable(identity2?.identityKey.truncate())), FormBuilder4.option("deviceKey", Option5.fromNullable(device2?.deviceKey.truncate())));
+    yield* Console10.log(print5(FormBuilder4.build(builder)));
+  }
+});
+var keys = Command14.make("keys", {}, handler8).pipe(Command14.withDescription("Show HALO keys."));
+
+// src/cli/commands/halo/recover/recover.ts
+import * as Args2 from "@effect/cli/Args";
+import * as Command15 from "@effect/cli/Command";
+import * as Console11 from "effect/Console";
+import * as Effect11 from "effect/Effect";
+import { CommandConfig as CommandConfig11, print as print6 } from "@dxos/cli-util";
+import { ClientService as ClientService10 } from "@dxos/client";
+import { invariant as invariant3 } from "@dxos/invariant";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-client/src/cli/commands/halo/recover/recover.ts";
+var recover = Command15.make("recover", {
+  recoveryCode: Args2.text({
+    name: "recoveryCode"
+  }).pipe(Args2.withDescription("The recovery code seed phrase."))
+}, Effect11.fn(function* ({ recoveryCode }) {
+  const { json } = yield* CommandConfig11;
+  const client = yield* ClientService10;
+  invariant3(!client.halo.identity.get(), "Identity already exists", {
+    F: __dxlog_file3,
+    L: 25,
+    S: this,
+    A: [
+      "!client.halo.identity.get()",
+      "'Identity already exists'"
+    ]
+  });
+  const identity2 = yield* Effect11.tryPromise(() => client.halo.recoverIdentity({
+    recoveryCode
+  }));
+  if (json) {
+    yield* Console11.log(JSON.stringify({
+      identityKey: identity2.identityKey.toHex(),
+      displayName: identity2.profile?.displayName
+    }, null, 2));
+  } else {
+    yield* Console11.log("Identity recovered successfully");
+    yield* Console11.log(print6(printIdentity(identity2)));
+  }
+})).pipe(Command15.withDescription("Recover an existing identity using a recovery code."));
+
+// src/cli/commands/halo/seed/seed.ts
+import * as Command16 from "@effect/cli/Command";
+import * as Console12 from "effect/Console";
+import * as Effect12 from "effect/Effect";
+import { CommandConfig as CommandConfig12 } from "@dxos/cli-util";
+import { ClientService as ClientService11 } from "@dxos/client";
+var handler9 = Effect12.fn(function* () {
+  const { json } = yield* CommandConfig12;
+  const client = yield* ClientService11;
+  yield* Effect12.tryPromise(() => client.spaces.waitUntilReady());
+  const identityService = client.services.services.IdentityService;
+  if (!identityService) {
+    if (json) {
+      yield* Console12.log(JSON.stringify({
+        error: "IdentityService not found"
+      }, null, 2));
+    } else {
+      yield* Console12.log("IdentityService not found.");
+    }
+    return;
+  }
+  const result = yield* Effect12.tryPromise(() => identityService.createRecoveryCredential({}));
+  if (json) {
+    yield* Console12.log(JSON.stringify({
+      recoveryCode: result.recoveryCode
+    }, null, 2));
+  } else {
+    yield* Console12.log(result.recoveryCode);
+  }
+});
+var seed = Command16.make("seed", {}, handler9).pipe(Command16.withDescription("Generate a seedphrase that can be used for identity recovery."));
+
+// src/cli/commands/halo/update/update.ts
+import * as Command17 from "@effect/cli/Command";
+import * as Options4 from "@effect/cli/Options";
+import * as Console13 from "effect/Console";
+import * as Effect13 from "effect/Effect";
+import { CommandConfig as CommandConfig13 } from "@dxos/cli-util";
+import { print as print7 } from "@dxos/cli-util";
+import { ClientService as ClientService12 } from "@dxos/client";
+var handler10 = Effect13.fn(function* ({ displayName }) {
+  const { json } = yield* CommandConfig13;
+  const client = yield* ClientService12;
+  yield* Effect13.tryPromise(() => client.spaces.waitUntilReady());
+  const identity2 = client.halo.identity.get();
+  if (!identity2) {
+    if (json) {
+      yield* Console13.log(JSON.stringify({
+        error: "Identity not initialized"
+      }, null, 2));
+    } else {
+      yield* Console13.log("Identity not initialized.");
+    }
+    return;
+  }
+  const identityService = client.services.services.IdentityService;
+  if (!identityService) {
+    if (json) {
+      yield* Console13.log(JSON.stringify({
+        error: "IdentityService not found"
+      }, null, 2));
+    } else {
+      yield* Console13.log("IdentityService not found.");
+    }
+    return;
+  }
+  const updatedIdentity = yield* Effect13.tryPromise(() => identityService.updateProfile({
+    displayName
+  }));
+  if (json) {
+    yield* Console13.log(JSON.stringify({
+      identityKey: updatedIdentity.identityKey.toHex(),
+      displayName: updatedIdentity.profile?.displayName
+    }, null, 2));
+  } else {
+    yield* Console13.log(print7(printIdentity(updatedIdentity)));
+  }
+});
+var update2 = Command17.make("update", {
+  displayName: Options4.text("displayName").pipe(Options4.withDescription("The display name of the identity."))
+}, handler10).pipe(Command17.withDescription("Update identity profile."));
+
+// src/cli/commands/halo/index.ts
+var halo = Command18.make("halo").pipe(Command18.withDescription("Manage HALO identity."), Command18.withSubcommands([
+  create,
+  credential,
+  identity,
+  keys,
+  recover,
+  seed,
+  update2
+]));
+
+// src/cli/commands/profile/index.ts
+import * as Command25 from "@effect/cli/Command";
+
+// src/cli/commands/profile/create.ts
+import * as Command19 from "@effect/cli/Command";
+import * as Options5 from "@effect/cli/Options";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Console14 from "effect/Console";
+import * as Effect14 from "effect/Effect";
+import * as Option6 from "effect/Option";
+import * as Record from "effect/Record";
+import { CommandConfig as CommandConfig14, print as print8 } from "@dxos/cli-util";
+import { DX_CONFIG, getProfilePath } from "@dxos/client-protocol";
+import { trim } from "@dxos/util";
+
+// src/cli/commands/profile/util.ts
+import { FormBuilder as FormBuilder5 } from "@dxos/cli-util";
+var printProfileCreated = (name, path) => FormBuilder5.make({
+  title: "Profile created"
+}).pipe(FormBuilder5.set("name", name), FormBuilder5.set("path", path), FormBuilder5.build);
+var printProfileDeleted = (name) => FormBuilder5.make({
+  title: "Profile deleted"
+}).pipe(FormBuilder5.set("name", name), FormBuilder5.build);
+var printProfileReset = (profile2) => FormBuilder5.make({
+  title: "Profile reset"
+}).pipe(FormBuilder5.set("profile", profile2), FormBuilder5.build);
+var printProfile = (profile2) => {
+  const title = profile2.isCurrent ? `${profile2.name} (current)` : profile2.name;
+  return FormBuilder5.make({
+    title
+  }).pipe(FormBuilder5.set("fullPath", profile2.fullPath), FormBuilder5.set("storagePath", profile2.storagePath), FormBuilder5.set("edge", profile2.edge ?? "<none>"), FormBuilder5.build);
+};
+
+// src/cli/commands/profile/create.ts
+var 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
+  `
+};
+var create2 = Command19.make("create", {
+  template: Options5.choice("template", Record.keys(TEMPLATES)).pipe(Options5.withDescription("Template to use"), Options5.withDefault("default")),
+  name: Options5.text("name").pipe(Options5.withDescription("Profile name"), Options5.optional)
+}, Effect14.fnUntraced(function* ({ template, name }) {
+  const { json } = yield* CommandConfig14;
+  const fs = yield* FileSystem.FileSystem;
+  const profileName = name.pipe(Option6.getOrElse(() => template));
+  const profilePath = `${getProfilePath(DX_CONFIG, profileName)}.yml`;
+  if (yield* fs.exists(profilePath)) {
+    throw new Error(`Profile ${profileName} already exists`);
+  }
+  yield* fs.writeFileString(profilePath, TEMPLATES[template]);
+  if (json) {
+    yield* Console14.log(JSON.stringify({
+      name: profileName,
+      path: profilePath
+    }, null, 2));
+  } else {
+    yield* Console14.log(print8(printProfileCreated(profileName, profilePath)));
+  }
+}));
+
+// src/cli/commands/profile/delete.ts
+import * as Command20 from "@effect/cli/Command";
+import * as Options6 from "@effect/cli/Options";
+import * as FileSystem3 from "@effect/platform/FileSystem";
+import * as Console15 from "effect/Console";
+import * as Effect15 from "effect/Effect";
+import * as Option7 from "effect/Option";
+import { CommandConfig as CommandConfig15, print as print9 } from "@dxos/cli-util";
+import { DX_CONFIG as DX_CONFIG2, getProfilePath as getProfilePath2 } from "@dxos/client-protocol";
+var del = Command20.make("delete", {
+  name: Options6.text("name").pipe(Options6.withDescription("Profile name"), Options6.optional)
+}, Effect15.fnUntraced(function* ({ name }) {
+  const { json } = yield* CommandConfig15;
+  const fs = yield* FileSystem3.FileSystem;
+  const profileName = name.pipe(Option7.getOrElse(() => "default"));
+  yield* fs.remove(`${getProfilePath2(DX_CONFIG2, profileName)}.yml`);
+  if (json) {
+    yield* Console15.log(JSON.stringify({
+      name: profileName,
+      deleted: true
+    }, null, 2));
+  } else {
+    yield* Console15.log(print9(printProfileDeleted(profileName)));
+  }
+}));
+
+// src/cli/commands/profile/import.ts
+import * as Command21 from "@effect/cli/Command";
+import * as Options7 from "@effect/cli/Options";
+import * as Prompt2 from "@effect/cli/Prompt";
+import * as FileSystem5 from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import * as Console16 from "effect/Console";
+import * as Effect16 from "effect/Effect";
+import * as Option8 from "effect/Option";
+import { CommandConfig as CommandConfig16 } from "@dxos/cli-util";
+import { ConfigService as ConfigService2 } from "@dxos/config";
+import { log as log17 } from "@dxos/log";
+var __dxlog_file4 = "/__w/dxos/dxos/packages/plugins/plugin-client/src/cli/commands/profile/import.ts";
+var handler11 = Effect16.fn(function* ({ file, dataDir, force }) {
+  const dataDirValue = Option8.getOrUndefined(dataDir);
+  const { json, profile: profile2 } = yield* CommandConfig16;
+  const fs = yield* FileSystem5.FileSystem;
+  const path = yield* Path.Path;
+  const config2 = yield* ConfigService2;
+  const { createLevel, createStorageObjects, importProfileData, decodeProfileArchive } = yield* Effect16.promise(() => import("@dxos/client-services"));
+  let storageConfig;
+  if (!dataDirValue) {
+    if (!force) {
+      yield* Console16.log(`Will overwrite profile: ${profile2}`);
+      const confirmed = yield* Prompt2.confirm({
+        message: `Delete all data? (Profile: ${profile2})`,
+        initial: false
+      }).pipe(Prompt2.run);
+      if (!confirmed) {
+        return;
+      }
+    }
+    storageConfig = config2.values.runtime.client.storage;
+  } else {
+    const fullPath = path.resolve(dataDirValue);
+    yield* Console16.log(`Importing into: ${fullPath}`);
+    storageConfig = {
+      persistent: true,
+      dataRoot: fullPath
+    };
+  }
+  if (yield* fs.exists(storageConfig.dataRoot)) {
+    log17.error("data directory already exists", {
+      path: storageConfig.dataRoot
+    }, {
+      F: __dxlog_file4,
+      L: 61,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (json) {
+      yield* Console16.log(JSON.stringify({
+        error: "Data directory already exists"
+      }, null, 2));
+    } else {
+      yield* Console16.log("Data directory already exists.");
+    }
+    return;
+  }
+  const data = yield* fs.readFile(file);
+  const archive = decodeProfileArchive(data);
+  yield* Console16.log(`Importing archive with ${archive.storage.length} entries`);
+  const { storage } = createStorageObjects(storageConfig);
+  const level = yield* Effect16.tryPromise({
+    try: () => createLevel(storageConfig),
+    catch: (error2) => new Error(`Failed to create level: ${error2}`)
+  });
+  yield* Console16.log("Beginning profile import...");
+  yield* Effect16.tryPromise({
+    try: () => importProfileData({
+      storage,
+      level
+    }, archive),
+    catch: (error2) => new Error(`Failed to import profile data: ${error2}`)
+  });
+  yield* Console16.log("Profile import complete");
+  if (json) {
+    yield* Console16.log(JSON.stringify({
+      success: true,
+      profile: profile2,
+      entries: archive.storage.length
+    }, null, 2));
+  }
+});
+var importCommand = Command21.make("import", {
+  file: Options7.text("file").pipe(Options7.withDescription("Archive filename."), Options7.withAlias("f")),
+  dataDir: Options7.text("data-dir").pipe(Options7.withDescription("Storage directory."), Options7.optional),
+  force: Options7.boolean("force", {
+    ifPresent: true
+  }).pipe(Options7.withDescription("Skip confirmation prompt."))
+}, handler11).pipe(Command21.withDescription("Import profile."));
+
+// src/cli/commands/profile/inspect.ts
+import * as Command22 from "@effect/cli/Command";
+import * as Options8 from "@effect/cli/Options";
+import * as FileSystem7 from "@effect/platform/FileSystem";
+import * as Console17 from "effect/Console";
+import * as Effect17 from "effect/Effect";
+import { CommandConfig as CommandConfig17, FormBuilder as FormBuilder6, print as print10 } from "@dxos/cli-util";
+import { ProfileArchiveEntryType } from "@dxos/protocols";
+import { arrayToBuffer } from "@dxos/util";
+var handler12 = Effect17.fn(function* ({ file, storage }) {
+  const { json } = yield* CommandConfig17;
+  const fs = yield* FileSystem7.FileSystem;
+  const { decodeProfileArchive } = yield* Effect17.promise(() => import("@dxos/client-services"));
+  const data = yield* fs.readFile(file);
+  const archive = decodeProfileArchive(data);
+  if (json) {
+    yield* Console17.log(JSON.stringify({
+      meta: archive.meta,
+      ...storage ? {
+        storage: archive.storage
+      } : {}
+    }, null, 2));
+  } else {
+    const builder = FormBuilder6.make({
+      title: "Profile Archive"
+    }).pipe(FormBuilder6.when(archive.meta, FormBuilder6.each(Object.entries(archive.meta ?? {}), ([key, value]) => FormBuilder6.set(key, String(value)))), FormBuilder6.build);
+    yield* Console17.log(print10(builder));
+    if (storage) {
+      yield* Console17.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* Console17.log(`  ${ProfileArchiveEntryType[entry.type]} ${key}`);
+      }
+    }
+  }
+});
+var inspect = Command22.make("inspect", {
+  file: Options8.text("file").pipe(Options8.withDescription("Archive filename."), Options8.withAlias("f")),
+  storage: Options8.boolean("storage", {
+    ifPresent: true
+  }).pipe(Options8.withDescription("List storage entries."))
+}, handler12).pipe(Command22.withDescription("Inspect profile archive."));
+
+// src/cli/commands/profile/list.ts
+import * as Command23 from "@effect/cli/Command";
+import * as FileSystem9 from "@effect/platform/FileSystem";
+import * as Path3 from "@effect/platform/Path";
+import * as Console18 from "effect/Console";
+import * as Effect18 from "effect/Effect";
+import * as Yaml2 from "yaml";
+import { CommandConfig as CommandConfig18, printList as printList3 } from "@dxos/cli-util";
+import { Config } from "@dxos/client";
+import { DX_CONFIG as DX_CONFIG3, DX_DATA, getProfilePath as getProfilePath3 } from "@dxos/client-protocol";
+var list3 = Command23.make("list", {}, Effect18.fnUntraced(function* () {
+  const { profile: currentProfile } = yield* CommandConfig18;
+  const fs = yield* FileSystem9.FileSystem;
+  const path = yield* Path3.Path;
+  const profileDir = path.join(DX_CONFIG3, "profile");
+  const files = yield* fs.readDirectory(profileDir);
+  const profiles = yield* Effect18.forEach(files, Effect18.fnUntraced(function* (filename) {
+    const ext = path.extname(filename);
+    const name = filename.slice(0, -ext.length);
+    const fullPath = path.join(DX_CONFIG3, "profile", filename);
+    const configContent = yield* fs.readFileString(fullPath);
+    const configValues = Yaml2.parse(configContent);
+    const config2 = new Config(configValues);
+    return {
+      name,
+      isCurrent: name === currentProfile,
+      fullPath,
+      storagePath: getProfilePath3(configValues?.runtime?.client?.storage.dataRoot ?? DX_DATA, name),
+      edge: config2.values.runtime?.services?.edge?.url
+    };
+  }));
+  const { json } = yield* CommandConfig18;
+  if (json) {
+    yield* Console18.log(JSON.stringify(profiles, null, 2));
+  } else {
+    const formatted = profiles.map(printProfile);
+    yield* Console18.log(printList3(formatted));
+  }
+}));
+
+// src/cli/commands/profile/reset.ts
+import * as Command24 from "@effect/cli/Command";
+import * as Options9 from "@effect/cli/Options";
+import * as Prompt3 from "@effect/cli/Prompt";
+import * as FileSystem11 from "@effect/platform/FileSystem";
+import * as Console19 from "effect/Console";
+import * as Effect19 from "effect/Effect";
+import { CommandConfig as CommandConfig19, print as print11 } from "@dxos/cli-util";
+import { DX_DATA as DX_DATA2, getProfilePath as getProfilePath4 } from "@dxos/client-protocol";
+import { ConfigService as ConfigService3 } from "@dxos/config";
+var reset = Command24.make("reset", {
+  force: Options9.boolean("force", {
+    ifPresent: true
+  }).pipe(Options9.withDescription("Skip confirmation prompt"))
+}, Effect19.fnUntraced(function* ({ force }) {
+  const fs = yield* FileSystem11.FileSystem;
+  const config2 = yield* ConfigService3;
+  const { json, profile: profile2 } = yield* CommandConfig19;
+  const path = config2.values.runtime?.client?.storage?.dataRoot ?? getProfilePath4(DX_DATA2, profile2);
+  if (!force) {
+    const confirmed = yield* Prompt3.confirm({
+      message: `Are you sure you want to reset the profile (${profile2})?`,
+      initial: false
+    });
+    if (!confirmed) {
+      return;
+    }
+  }
+  yield* fs.remove(path, {
+    recursive: true
+  });
+  if (json) {
+    yield* Console19.log(JSON.stringify({
+      profile: profile2,
+      reset: true
+    }, null, 2));
+  } else {
+    yield* Console19.log(print11(printProfileReset(profile2)));
+  }
+}));
+
+// src/cli/commands/profile/index.ts
+var profile = Command25.make("profile").pipe(Command25.withDescription("Profile commands."), Command25.withSubcommands([
+  create2,
+  del,
+  importCommand,
+  inspect,
+  list3,
+  reset
+]));
+
+// src/cli/plugin.ts
+var ClientPlugin = Plugin2.define(meta).pipe(
+  // TODO(wittjosiah): Could some of these commands make use of operations?
+  AppPlugin.addCommandModule({
+    commands: [
+      config,
+      device,
+      edge,
+      halo,
+      profile
+    ]
+  }),
+  AppPlugin.addOperationResolverModule({
+    activate: OperationResolver
+  }),
+  Plugin2.addModule((options) => ({
+    id: Capability.getModuleTag(Client),
+    activatesOn: ActivationEvents.Startup,
+    activatesAfter: [
+      ClientEvents.ClientReady
+    ],
+    activate: () => Client(options)
+  })),
+  Plugin2.addModule({
+    activatesOn: ClientEvents.ClientReady,
+    activatesBefore: [
+      AppActivationEvents.SetupSchema
+    ],
+    activate: SchemaDefs
+  }),
+  Plugin2.make
+);
+export {
+  ClientPlugin
+};
+//# sourceMappingURL=index.mjs.map