@dxos/plugin-client 0.10.0 → 0.11.1

package/dist/lib/ClientPlugin.node.mjs

@@ -0,0 +1,904 @@
+import { ActivationEvents, Capabilities, Capability, Plugin } from "@dxos/app-framework";
+import { arrayToBuffer, trim } from "@dxos/util";
+import { meta } from "#meta";
+import { AppActivationEvents, AppPlugin, AppSpace } from "@dxos/app-toolkit";
+import { Client, LayerSpecs, Migrations, OperationHandler, SchemaDefs } from "#capabilities";
+import { ClientEvents } from "#types";
+import * as Command from "@effect/cli/Command";
+import * as Args from "@effect/cli/Args";
+import * as Options from "@effect/cli/Options";
+import * as Prompt from "@effect/cli/Prompt";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import { CommandConfig, Common, FormBuilder, copyToClipboard, flushAndSync, getSpace, openBrowser, performRecoveryOAuthFlow, print, printList, spaceLayer } from "@dxos/cli-util";
+import { ClientService, Config, ConfigService } from "@dxos/client";
+import { Invitation, InvitationEncoder, hostInvitation } from "@dxos/client/invitations";
+import { Context } from "@dxos/context";
+import { HubHttpClient as HubHttpClient$1 } from "@dxos/edge-client";
+import { invariant } from "@dxos/invariant";
+import { ATPROTO_OAUTH_SCOPES, OAuthProvider, ProfileArchiveEntryType } from "@dxos/protocols";
+import { ClientOperation } from "#operations";
+import * as Duration from "effect/Duration";
+import * as FileSystem from "@effect/platform/FileSystem";
+import { DX_CONFIG, DX_DATA, getProfileConfigPath, getProfilePath } from "@dxos/client-protocol";
+import { ConfigService as ConfigService$1 } from "@dxos/config";
+import * as Yaml from "yaml";
+import { DeviceType, MembershipPolicy } from "@dxos/protocols/proto/dxos/halo/credentials";
+import { Device, DeviceKind, DeviceType as DeviceType$1 } from "@dxos/client/halo";
+import { createEdgeIdentity } from "@dxos/client/edge";
+import { EdgeReplicationSetting } from "@dxos/protocols/proto/dxos/echo/metadata";
+import { schema } from "@dxos/protocols/proto";
+import * as Path from "@effect/platform/Path";
+import * as Record from "effect/Record";
+import { log } from "@dxos/log";
+//#region src/commands/halo/util.ts
+/**
+* Pretty prints an identity with ANSI colors.
+*/
+var printIdentity = (identity) => FormBuilder.make({ title: "Identity" }).pipe(FormBuilder.set("identityDid", identity.identityDid), FormBuilder.set("displayName", identity.profile?.displayName ?? "<none>"), FormBuilder.build);
+var TERMINAL_FAILURE_STATES = /* @__PURE__ */ new Set([
+	Invitation.State.CANCELLED,
+	Invitation.State.TIMEOUT,
+	Invitation.State.ERROR,
+	Invitation.State.EXPIRED
+]);
+/** Await an authenticating invitation reaching the given state. */
+var waitForState = (invitation, state) => Effect.async((resume) => {
+	const subscription = invitation.subscribe((inv) => {
+		if (inv.state === state) resume(Effect.void);
+		else if (TERMINAL_FAILURE_STATES.has(inv.state)) resume(Effect.fail(/* @__PURE__ */ new Error(`Invitation failed with state: ${Invitation.State[inv.state]}`)));
+	});
+	return Effect.sync(() => subscription.unsubscribe());
+}).pipe(Effect.timeout(Duration.minutes(3)));
+//#endregion
+//#region src/commands/account/login/login.ts
+var __dxlog_file$4 = "/__w/dxos/dxos/packages/plugins/plugin-client/src/commands/account/login/login.ts";
+var LOGIN_METHODS = [
+	"email",
+	"atproto",
+	"device-invitation",
+	"recovery-code"
+];
+var METHOD_CHOICES = [
+	{
+		title: "Email",
+		value: "email"
+	},
+	{
+		title: "AT Protocol",
+		value: "atproto"
+	},
+	{
+		title: "Device invitation",
+		value: "device-invitation"
+	},
+	{
+		title: "Recovery code",
+		value: "recovery-code"
+	}
+];
+var INPUT_PROMPT = {
+	"email": "Email address",
+	"atproto": "atproto handle or DID (e.g. alice.bsky.social)",
+	"device-invitation": "Invitation code or URL",
+	"recovery-code": "Recovery code (seed phrase)"
+};
+var login = Command.make("login", {
+	method: Options.choice("method", LOGIN_METHODS).pipe(Options.withDescription("Login method (email | atproto | device-invitation | recovery-code). Prompted if omitted."), Options.optional),
+	input: Args.text({ name: "input" }).pipe(Args.withDescription("Method input: email address / atproto handle / invitation code / recovery code."), Args.optional)
+}, Effect.fn(function* ({ method, input }) {
+	const { json } = yield* CommandConfig;
+	const client = yield* ClientService;
+	const { invoke } = (yield* Plugin.Service).capabilities.get(Capabilities.OperationInvoker);
+	invariant(!client.halo.identity.get(), "Already logged in. Run `dx account logout` first.", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$4,
+		L: 65,
+		S: this,
+		A: ["!client.halo.identity.get()", "'Already logged in. Run `dx account logout` first.'"]
+	});
+	const resolvedMethod = Option.isSome(method) ? method.value : yield* Prompt.select({
+		message: "Choose a login method:",
+		choices: METHOD_CHOICES
+	}).pipe(Prompt.run);
+	const resolvedInput = Option.isSome(input) ? input.value : yield* Prompt.text({ message: `${INPUT_PROMPT[resolvedMethod]}:` }).pipe(Prompt.run);
+	const identity = yield* Match.value(resolvedMethod).pipe(Match.when("atproto", () => loginWithAtproto(client, resolvedInput)), Match.when("email", () => loginWithEmail(client, resolvedInput, invoke)), Match.when("recovery-code", () => loginWithRecoveryCode(client, resolvedInput)), Match.when("device-invitation", () => loginWithDeviceInvitation(client, resolvedInput)), Match.exhaustive);
+	if (json) yield* Console.log(JSON.stringify({
+		identityDid: identity.did,
+		displayName: identity.profile?.displayName
+	}, null, 2));
+	else {
+		yield* Console.log("Logged in successfully");
+		yield* Console.log(print(printIdentity({
+			identityDid: identity.did,
+			profile: identity.profile
+		})));
+	}
+})).pipe(Command.withDescription("Log in to an existing DXOS identity (same methods as Composer)."));
+/**
+* atproto / Bluesky OAuth login: runs the gate recovery flow (local server + browser) and redeems
+* the resulting one-time `recoveryProof` to admit this device into the existing identity's HALO.
+*/
+var loginWithAtproto = (client, handle) => Effect.gen(function* () {
+	const edgeBaseUrl = client.config.values.runtime?.services?.edge?.url;
+	invariant(edgeBaseUrl, "Edge services not configured (runtime.services.edge.url).", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$4,
+		L: 101,
+		S: this,
+		A: ["edgeBaseUrl", "'Edge services not configured (runtime.services.edge.url).'"]
+	});
+	const { recoveryProof } = yield* performRecoveryOAuthFlow({
+		edgeBaseUrl,
+		provider: OAuthProvider.ATPROTO,
+		scopes: ATPROTO_OAUTH_SCOPES,
+		loginHint: handle
+	});
+	return yield* Effect.tryPromise(() => client.halo.recoverIdentity({ recoveryProof }));
+});
+/** Recovery-code (seed phrase) login. */
+var loginWithRecoveryCode = (client, recoveryCode) => Effect.tryPromise(() => client.halo.recoverIdentity({ recoveryCode }));
+/**
+* Email login, mirroring the gate's login tab (`WelcomeScreen.handleLogin`). Hub-service answers in
+* one of three ways:
+*
+* - `needsIdentity`: the address may bind a fresh Account but has no identity yet. Create one
+*   locally and retry with its DID; the hub then admits it directly — there is no token because
+*   there is nothing to recover — and we provision the agent as the gate does.
+* - `token`: an Account exists and the hub returned a one-time recovery token inline.
+* - neither: the link went out by email, so prompt for the token from the message.
+*/
+var loginWithEmail = (client, email, invoke) => Effect.gen(function* () {
+	const hubUrl = client.config.values?.runtime?.app?.env?.DX_HUB_URL;
+	invariant(hubUrl, "Hub URL not configured (runtime.app.env.DX_HUB_URL).", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$4,
+		L: 128,
+		S: this,
+		A: ["hubUrl", "'Hub URL not configured (runtime.app.env.DX_HUB_URL).'"]
+	});
+	const hub = new HubHttpClient$1(hubUrl);
+	const result = yield* Effect.tryPromise(() => hub.login(Context.default(void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$4,
+		L: 130
+	}), { email }));
+	if (result.needsIdentity) {
+		yield* invoke(ClientOperation.CreateIdentity, { displayName: email.split("@")[0] });
+		const identity = client.halo.identity.get();
+		invariant(identity, "identity should exist after create", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$4,
+			L: 136,
+			S: this,
+			A: ["identity", "'identity should exist after create'"]
+		});
+		const notAdmitted = (detail) => /* @__PURE__ */ new Error(`Hub did not admit ${email} (${detail}). A local identity was created and remains bound to this profile; run \`dx account logout\` to clear it before retrying.`);
+		if (!(yield* Effect.tryPromise({
+			try: () => hub.login(Context.default(void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$4,
+				L: 148
+			}), {
+				email,
+				identityDid: identity.did,
+				identityKey: identity.identityKey.toHex()
+			}),
+			catch: (cause) => notAdmitted(cause instanceof Error ? cause.message : String(cause))
+		})).admitted) return yield* Effect.fail(notAdmitted("no admission granted"));
+		yield* invoke(ClientOperation.CreateAgent);
+		return identity;
+	}
+	let token = result.token;
+	if (!token) {
+		yield* Console.log(`A login link was sent to ${email}. Paste the token from the email below.`);
+		token = yield* Prompt.text({ message: "Login token" }).pipe(Prompt.run);
+	}
+	return yield* Effect.tryPromise(() => client.halo.recoverIdentity({ token }));
+});
+/**
+* Device-invitation login: joins an existing identity from another authorized device.
+*
+* NOTE: p2p networking does not work in bun — this method will likely hang waiting for the peer.
+*/
+var loginWithDeviceInvitation = (client, encoded) => Effect.gen(function* () {
+	let code = encoded;
+	if (code.startsWith("http") || code.startsWith("socket")) code = new URL(code).searchParams.get("deviceInvitationCode") ?? code;
+	const invitation = client.halo.join(InvitationEncoder.decode(code));
+	yield* waitForState(invitation, Invitation.State.READY_FOR_AUTHENTICATION);
+	const authCode = yield* Prompt.text({ message: "Enter the authentication code" }).pipe(Prompt.run);
+	yield* Effect.tryPromise(() => invitation.authenticate(authCode));
+	yield* waitForState(invitation, Invitation.State.SUCCESS);
+	const identity = client.halo.identity.get();
+	invariant(identity, "Device invitation completed but no identity is present.", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$4,
+		L: 187,
+		S: this,
+		A: ["identity", "'Device invitation completed but no identity is present.'"]
+	});
+	return identity;
+});
+//#endregion
+//#region src/commands/account/logout/logout.ts
+var logout = Command.make("logout", { 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$1;
+	const { json, profile } = yield* CommandConfig;
+	const path = config.values.runtime?.client?.storage?.dataRoot ?? getProfilePath(DX_DATA, profile);
+	if (!force) {
+		if (!(yield* Prompt.confirm({
+			message: `Log out of profile (${profile})? This removes the local identity and data; spaces re-sync on next login.`,
+			initial: false
+		}).pipe(Prompt.run))) return;
+	}
+	yield* fs.remove(path, { recursive: true }).pipe(Effect.catchIf((e) => e._tag === "SystemError" && e.reason === "NotFound", () => Effect.void));
+	yield* fs.makeDirectory(path, { recursive: true });
+	if (json) yield* Console.log(JSON.stringify({
+		profile,
+		loggedOut: true
+	}, null, 2));
+	else yield* Console.log(`Logged out of profile (${profile}).`);
+})).pipe(Command.withDescription("Log out of the current profile (clears the local identity and data)."));
+//#endregion
+//#region src/commands/account/index.ts
+var account = Command.make("account").pipe(Command.withDescription("Log in and out of a DXOS identity."), Command.withSubcommands([login, logout]));
+//#endregion
+//#region src/commands/config/view.ts
+var view = Command.make("view", {}, Effect.fnUntraced(function* () {
+	const config = yield* ConfigService;
+	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));
+	}
+}));
+//#endregion
+//#region src/commands/config/index.ts
+var config = Command.make("config").pipe(Command.withDescription("Config commands."), Command.withSubcommands([view]));
+//#endregion
+//#region src/commands/device/util.ts
+var maybeTruncateKey = (key, truncate = false) => truncate ? key.truncate() : key.toHex();
+var getDeviceTitle = (device) => {
+	if (device.profile?.label) return device.profile.label;
+	return `${device.profile?.platform ?? "Unknown"} on ${device.profile?.os ?? "Unknown"}`;
+};
+var mapDevices = (devices, truncateKeys = false) => {
+	return devices.map((device) => ({
+		label: device.profile?.label,
+		type: device.profile?.type ? DeviceType$1[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]
+	}));
+};
+var printDevice = (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$1[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);
+var printDevices = (devices) => {
+	return devices.map(printDevice);
+};
+//#endregion
+//#region src/commands/device/info/info.ts
+var handler$12 = Effect.fn(function* () {
+	const { json } = yield* CommandConfig;
+	const device = (yield* ClientService).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;
+	}
+	if (json) yield* Console.log(JSON.stringify({
+		deviceKey: device.deviceKey.toHex(),
+		profile: {
+			...device.profile,
+			type: device.profile?.type ? DeviceType[device.profile?.type] : "UNKNOWN"
+		}
+	}, null, 2));
+	else yield* Console.log(print(printDevice(device)));
+});
+var info = Command.make("info", {}, handler$12).pipe(Command.withDescription("Show device info."));
+//#endregion
+//#region src/commands/device/list/list.ts
+var handler$11 = Effect.fn(function* () {
+	const { json } = yield* CommandConfig;
+	const devices = (yield* ClientService).halo.devices.get();
+	if (json) yield* Console.log(JSON.stringify(mapDevices(devices), null, 2));
+	else {
+		const formatted = printDevices(devices);
+		yield* Console.log(printList(formatted));
+	}
+});
+var list$2 = Command.make("list", {}, handler$11).pipe(Command.withDescription("List devices."));
+//#endregion
+//#region src/commands/device/update/update.ts
+var handler$10 = Effect.fn(function* ({ label }) {
+	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)));
+});
+var update$1 = Command.make("update", { label: Options.text("label").pipe(Options.withDescription("The device label.")) }, handler$10).pipe(Command.withDescription("Update device label."));
+//#endregion
+//#region src/commands/device/index.ts
+var device = Command.make("device").pipe(Command.withDescription("Manage HALO devices."), Command.withSubcommands([
+	info,
+	list$2,
+	update$1
+]));
+//#endregion
+//#region src/commands/edge/status.ts
+var __dxlog_file$3 = "/__w/dxos/dxos/packages/plugins/plugin-client/src/commands/edge/status.ts";
+var 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(void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 20
+	})));
+	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(Effect.catchSome((error) => {
+	if (error instanceof Error && error.message === "Identity not available") return Option.some(Console.error(error.message));
+	else return Option.none();
+}));
+var status = Command.make("status", {}, getStatus).pipe(Command.withDescription("Get the EDGE status for the current identity."));
+//#endregion
+//#region src/commands/edge/index.ts
+var edge = Command.make("edge").pipe(Command.withDescription("EDGE commands."), Command.withSubcommands([status]));
+//#endregion
+//#region src/commands/halo/create/create.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/plugins/plugin-client/src/commands/halo/create/create.ts";
+var handler$9 = Effect.fn(function* ({ agent, displayName }) {
+	const { json } = yield* CommandConfig;
+	const client = yield* ClientService;
+	invariant(!client.halo.identity.get(), "Identity already exists", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$2,
+		L: 34,
+		S: this,
+		A: ["!client.halo.identity.get()", "'Identity already exists'"]
+	});
+	const { invoke } = (yield* Plugin.Service).capabilities.get(Capabilities.OperationInvoker);
+	const identity = yield* invoke(ClientOperation.CreateIdentity, { displayName: Option.getOrUndefined(displayName) });
+	if (agent) yield* invoke(ClientOperation.CreateAgent);
+	const space = yield* Effect.promise(() => client.spaces.create({}, {
+		tags: [AppSpace.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({
+		identityDid: identity.identityDid,
+		displayName: identity.profile?.displayName
+	}, null, 2));
+	else yield* Console.log(print(printIdentity(identity)));
+});
+var create$1 = 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$9).pipe(Command.withDescription("Create a new identity."));
+//#endregion
+//#region src/commands/halo/credential/add/add.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/plugins/plugin-client/src/commands/halo/credential/add/add.ts";
+var handler$8 = Effect.fn(function* ({ credential }) {
+	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.", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 26,
+		S: this,
+		A: ["credentialHex", "'Invalid credential.'"]
+	});
+	if (!client.halo.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) => /* @__PURE__ */ 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) => /* @__PURE__ */ new Error(`Failed to decode credential: ${error}`)
+		});
+		yield* Effect.tryPromise({
+			try: () => client.halo.writeCredentials([credentialObj]),
+			catch: (error) => /* @__PURE__ */ 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);
+	})));
+});
+var add = Command.make("add", { credential: Args.text({ name: "credential" }).pipe(Args.withDescription("Credential as hex string."), Args.optional) }, handler$8).pipe(Command.withDescription("Import credential into HALO."));
+//#endregion
+//#region src/commands/halo/credential/list/list.ts
+var mapCredentials = (credentials) => {
+	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
+	}));
+};
+var printCredential = (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);
+};
+var handler$7 = Effect.fn(function* ({ type, spaceId, timeout, delay }) {
+	const { json } = yield* CommandConfig;
+	const client = yield* ClientService;
+	let credentials;
+	if (Option.isSome(spaceId)) {
+		const space = yield* getSpace(spaceId.value);
+		credentials = yield* Effect.tryPromise(() => space.internal.getCredentials());
+	} else {
+		if (!client.halo.identity) {
+			if (json) yield* Console.log(JSON.stringify({ error: "Profile not initialized" }, null, 2));
+			else yield* Console.log("Profile not initialized.");
+			return;
+		}
+		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();
+		})));
+		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));
+	}
+});
+var list$1 = 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$7).pipe(Command.withDescription("List HALO credentials."));
+//#endregion
+//#region src/commands/halo/credential/index.ts
+var credential = Command.make("credential").pipe(Command.withDescription("Manage HALO credentials."), Command.withSubcommands([add, list$1]));
+//#endregion
+//#region src/commands/halo/identity/identity.ts
+var handler$6 = Effect.fn(function* () {
+	const { json } = yield* CommandConfig;
+	const identity = (yield* ClientService).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({
+		identityDid: identity.did,
+		displayName: identity.profile?.displayName
+	}, null, 2));
+	else yield* Console.log(print(printIdentity({
+		identityDid: identity.did,
+		profile: identity.profile
+	})));
+});
+var identity = Command.make("identity", {}, handler$6).pipe(Command.withDescription("Get the current identity."));
+//#endregion
+//#region src/commands/halo/keys/keys.ts
+var handler$5 = Effect.fn(function* () {
+	const { json } = yield* CommandConfig;
+	const client = yield* ClientService;
+	const identity = client.halo.identity.get();
+	const device = client.halo.device;
+	if (json) yield* Console.log(JSON.stringify({
+		identityKey: identity?.identityKey.toHex(),
+		deviceKey: device?.deviceKey.toHex()
+	}, null, 2));
+	else {
+		const builder = FormBuilder.make({ title: "HALO Keys" }).pipe(FormBuilder.option("identityKey", Option.fromNullable(identity?.identityKey.truncate())), FormBuilder.option("deviceKey", Option.fromNullable(device?.deviceKey.truncate())));
+		yield* Console.log(print(FormBuilder.build(builder)));
+	}
+});
+var keys = Command.make("keys", {}, handler$5).pipe(Command.withDescription("Show HALO keys."));
+//#endregion
+//#region src/commands/halo/seed/seed.ts
+var handler$4 = Effect.fn(function* () {
+	const { json } = yield* CommandConfig;
+	const identityService = (yield* ClientService).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 result = yield* Effect.tryPromise(() => identityService.createRecoveryCredential({}));
+	if (json) yield* Console.log(JSON.stringify({ recoveryCode: result.recoveryCode }, null, 2));
+	else yield* Console.log(result.recoveryCode);
+});
+var seed = Command.make("seed", {}, handler$4).pipe(Command.withDescription("Generate a seedphrase that can be used for identity recovery."));
+//#endregion
+//#region src/commands/halo/share/share.ts
+var handler$3 = Effect.fn(function* ({ lifetime, open, host }) {
+	const { json } = yield* CommandConfig;
+	const client = yield* ClientService;
+	yield* Effect.try({
+		try: () => new URL(host),
+		catch: () => /* @__PURE__ */ new Error(`--host must be an absolute URL: ${host}`)
+	});
+	const invitation = yield* hostInvitation({
+		observable: client.halo.share({
+			authMethod: Invitation.AuthMethod.SHARED_SECRET,
+			persistent: true,
+			lifetime
+		}),
+		callbacks: { onConnecting: (invitation) => Effect.gen(function* () {
+			const invitationCode = InvitationEncoder.encode(invitation);
+			const authCode = invitation.authCode;
+			yield* copyToClipboard(authCode).pipe(Effect.catchAll(() => Effect.void));
+			const url = new URL(host);
+			url.searchParams.set("deviceInvitationCode", invitationCode);
+			if (!json) {
+				yield* Console.log(`\nSecret: ${authCode} (copied to clipboard)\n`);
+				yield* Console.log(`\nInvitation: ${invitationCode}\n`);
+				yield* Console.log(`\nURL: ${url.toString()}\n`);
+			}
+			if (open) yield* openBrowser(url.toString()).pipe(Effect.catchAll(() => Console.error(`Failed to open browser: ${url.toString()}`)));
+		}) },
+		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)));
+	}
+});
+var share = Command.make("share", {
+	lifetime: Options.integer("lifetime").pipe(Options.withDescription("Lifetime of the invitation in seconds."), Options.withDefault(720 * 60)),
+	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$3).pipe(Command.withDescription("Create HALO (device) invitation."));
+//#endregion
+//#region src/commands/halo/update/update.ts
+var handler$2 = Effect.fn(function* ({ displayName }) {
+	const { json } = yield* CommandConfig;
+	const client = yield* ClientService;
+	if (!client.halo.identity.get()) {
+		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({
+		identityDid: updatedIdentity.did,
+		displayName: updatedIdentity.profile?.displayName
+	}, null, 2));
+	else yield* Console.log(print(printIdentity({
+		identityDid: updatedIdentity.did,
+		profile: updatedIdentity.profile
+	})));
+});
+var update = Command.make("update", { displayName: Options.text("displayName").pipe(Options.withDescription("The display name of the identity.")) }, handler$2).pipe(Command.withDescription("Update identity profile."));
+//#endregion
+//#region src/commands/halo/index.ts
+var halo = Command.make("halo").pipe(Command.withDescription("Manage HALO identity."), Command.withSubcommands([
+	create$1,
+	credential,
+	identity,
+	keys,
+	seed,
+	share,
+	update
+]));
+//#endregion
+//#region src/commands/profile/util.ts
+/**
+* Pretty prints profile creation result with ANSI colors.
+*/
+var printProfileCreated = (name, path) => FormBuilder.make({ title: "Profile created" }).pipe(FormBuilder.set("name", name), FormBuilder.set("path", path), FormBuilder.build);
+/**
+* Pretty prints profile deletion result with ANSI colors.
+*/
+var printProfileDeleted = (name) => FormBuilder.make({ title: "Profile deleted" }).pipe(FormBuilder.set("name", name), FormBuilder.build);
+/**
+* Pretty prints profile reset result with ANSI colors.
+*/
+var printProfileReset = (profile) => FormBuilder.make({ title: "Profile reset" }).pipe(FormBuilder.set("profile", profile), FormBuilder.build);
+/**
+* Pretty prints a profile with ANSI colors.
+*/
+var printProfile = (profile) => {
+	const title = profile.isCurrent ? `${profile.name} (current)` : profile.name;
+	return FormBuilder.make({ title }).pipe(FormBuilder.set("fullPath", profile.fullPath), FormBuilder.set("storagePath", profile.storagePath), FormBuilder.set("edge", profile.edge ?? "<none>"), FormBuilder.build);
+};
+//#endregion
+//#region src/commands/profile/create.ts
+var makeTemplate = (edgeUrl) => trim`
+  version: 1
+  runtime:
+    client:
+      storage:
+        persistent: true
+      edgeFeatures:
+        signaling: true
+        subductionReplicator: true
+        feedReplicator: true
+        agents: true
+    services:
+      edge:
+        url: ${edgeUrl}
+`;
+var TEMPLATES = {
+	default: makeTemplate("https://edge-production.dxos.workers.dev"),
+	main: makeTemplate("https://edge-main.dxos.workers.dev"),
+	dev: makeTemplate("https://edge.dxos.workers.dev"),
+	local: makeTemplate("http://localhost:8787")
+};
+var 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)));
+}));
+//#endregion
+//#region src/commands/profile/delete.ts
+var 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)));
+}));
+//#endregion
+//#region src/commands/profile/import.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-client/src/commands/profile/import.ts";
+var handler$1 = Effect.fn(function* ({ file, dataDir, force }) {
+	const dataDirValue = Option.getOrUndefined(dataDir);
+	const { json, profile } = yield* CommandConfig;
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const config = yield* ConfigService$1;
+	const { createLevel, createStorageObjects, importProfileData, decodeProfileArchive } = yield* Effect.promise(() => import("@dxos/client-services"));
+	let storageConfig;
+	if (!dataDirValue) {
+		if (!force) {
+			yield* Console.log(`Will overwrite profile: ${profile}`);
+			if (!(yield* Prompt.confirm({
+				message: `Delete all data? (Profile: ${profile})`,
+				initial: false
+			}).pipe(Prompt.run))) 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 }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 61,
+			S: this
+		});
+		if (json) yield* Console.log(JSON.stringify({ error: "Data directory already exists" }, null, 2));
+		else yield* Console.log("Data directory already exists.");
+		return;
+	}
+	const archive = decodeProfileArchive(yield* fs.readFile(file));
+	yield* Console.log(`Importing archive with ${archive.storage.length} entries`);
+	const { storage } = createStorageObjects(storageConfig);
+	const level = yield* Effect.tryPromise({
+		try: () => createLevel(storageConfig),
+		catch: (error) => /* @__PURE__ */ new Error(`Failed to create level: ${error}`)
+	});
+	yield* Console.log("Beginning profile import...");
+	yield* Effect.tryPromise({
+		try: () => importProfileData({
+			storage,
+			level
+		}, archive),
+		catch: (error) => /* @__PURE__ */ 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));
+});
+var 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$1).pipe(Command.withDescription("Import profile."));
+//#endregion
+//#region src/commands/profile/inspect.ts
+var handler = Effect.fn(function* ({ file, storage }) {
+	const { json } = yield* CommandConfig;
+	const fs = yield* FileSystem.FileSystem;
+	const { decodeProfileArchive } = yield* Effect.promise(() => import("@dxos/client-services"));
+	const archive = decodeProfileArchive(yield* fs.readFile(file));
+	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}`);
+			}
+		}
+	}
+});
+var 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."));
+//#endregion
+//#region src/commands/profile/list.ts
+var 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 profileFiles = (yield* fs.readDirectory(profileDir)).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));
+	}
+}));
+//#endregion
+//#region src/commands/profile/reset.ts
+var 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$1;
+	const { json, profile } = yield* CommandConfig;
+	const path = config.values.runtime?.client?.storage?.dataRoot ?? getProfilePath(DX_DATA, profile);
+	if (!force) {
+		if (!(yield* Prompt.confirm({
+			message: `Are you sure you want to reset the profile (${profile})?`,
+			initial: false
+		}))) 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)));
+}));
+//#endregion
+//#region src/commands/profile/index.ts
+var profile = Command.make("profile").pipe(Command.withDescription("Profile commands."), Command.withSubcommands([
+	create,
+	del,
+	importCommand,
+	inspect,
+	list,
+	reset
+]));
+//#endregion
+//#region src/ClientPlugin.node.ts
+var ClientPlugin = Plugin.define(meta).pipe(AppPlugin.addCommandModule({ commands: [
+	account,
+	config,
+	device,
+	edge,
+	halo,
+	profile
+] }), AppPlugin.addOperationHandlerModule({ activate: OperationHandler }), Plugin.addModule((options) => ({
+	id: Capability.getModuleTag(Client),
+	activatesOn: ActivationEvents.Startup,
+	firesAfterActivation: [ClientEvents.ClientReady],
+	activate: () => Client(options)
+})), Plugin.addModule({
+	activatesOn: ClientEvents.ClientReady,
+	firesBeforeActivation: [AppActivationEvents.SetupSchema],
+	activate: SchemaDefs
+}), Plugin.addModule({
+	activatesOn: ClientEvents.ClientReady,
+	firesBeforeActivation: [ClientEvents.SetupMigration],
+	activate: Migrations
+}), Plugin.addModule({
+	activatesOn: ActivationEvents.SetupProcessManager,
+	activate: LayerSpecs
+}), Plugin.make);
+//#endregion
+export { ClientPlugin, ClientPlugin as default };
+
+//# sourceMappingURL=ClientPlugin.node.mjs.map