@dxos/cli-util 0.9.1-staging.ee54ba693a → 0.11.0

package/dist/lib/chunk-command-config.mjs

@@ -0,0 +1,18 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Context from "effect/Context";
+//#region src/services/command-config.ts
+var CommandConfig = class CommandConfig extends Context.Tag("CommandConfig")() {
+	static isJson = CommandConfig.pipe(Effect.map((config) => config.json));
+	static isVerbose = CommandConfig.pipe(Effect.map((config) => config.verbose));
+	static layerTest = Layer.succeed(CommandConfig, {
+		json: true,
+		verbose: false,
+		profile: "default",
+		logLevel: "info"
+	});
+};
+//#endregion
+export { CommandConfig as t };
+
+//# sourceMappingURL=chunk-command-config.mjs.map

package/dist/lib/chunk-command-config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-command-config.mjs","names":[],"sources":["../../src/services/command-config.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\n\nexport class CommandConfig extends Context.Tag('CommandConfig')<\n  CommandConfig,\n  {\n    json: boolean;\n    verbose: boolean;\n    profile: string;\n    logLevel: string;\n  }\n>() {\n  static isJson: Effect.Effect<boolean, never, CommandConfig> = CommandConfig.pipe(Effect.map((config) => config.json));\n  static isVerbose: Effect.Effect<boolean, never, CommandConfig> = CommandConfig.pipe(\n    Effect.map((config) => config.verbose),\n  );\n\n  static layerTest = Layer.succeed(CommandConfig, {\n    json: true,\n    verbose: false,\n    profile: 'default',\n    logLevel: 'info',\n  });\n}\n"],"mappings":";;;;AAQA,IAAa,gBAAb,MAAa,sBAAsB,QAAQ,IAAI,eAAe,CAAC,CAQ7D,CAAC,CAAC;CACF,OAAO,SAAuD,cAAc,KAAK,OAAO,KAAK,WAAW,OAAO,IAAI,CAAC;CACpH,OAAO,YAA0D,cAAc,KAC7E,OAAO,KAAK,WAAW,OAAO,OAAO,CACvC;CAEA,OAAO,YAAY,MAAM,QAAQ,eAAe;EAC9C,MAAM;EACN,SAAS;EACT,SAAS;EACT,UAAU;CACZ,CAAC;AACH"}

package/dist/lib/index.mjs

@@ -0,0 +1,601 @@
+import { t as CommandConfig } from "./chunk-command-config.mjs";
+import * as BunHttpServer from "@effect/platform-bun/BunHttpServer";
+import * as HttpRouter from "@effect/platform/HttpRouter";
+import * as HttpServer from "@effect/platform/HttpServer";
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
+import * as Scope from "effect/Scope";
+import { getPort } from "get-port-please";
+import { spawn } from "node:child_process";
+import { EntityId, SpaceId } from "@dxos/keys";
+import * as Ansi from "@effect/printer-ansi/Ansi";
+import * as Doc from "@effect/printer/Doc";
+import * as Pipeable from "effect/Pipeable";
+import * as Options from "@effect/cli/Options";
+import { Database, Key } from "@dxos/echo";
+import * as AnsiDoc from "@effect/printer-ansi/AnsiDoc";
+import { ClientService } from "@dxos/client";
+import * as Console from "effect/Console";
+import { AppSpace } from "@dxos/app-toolkit";
+import { BaseError } from "@dxos/errors";
+import { log } from "@dxos/log";
+import { EdgeReplicationSetting } from "@dxos/protocols/proto/dxos/echo/metadata";
+import { isBun } from "@dxos/util";
+import * as Duration from "effect/Duration";
+import { SpaceState } from "@dxos/client/echo";
+import * as Config from "effect/Config";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/util/platform.ts
+/**
+* Copy text to the system clipboard.
+* Supports macOS (pbcopy), Windows (clip), and Linux (xclip/xsel).
+*/
+var copyToClipboard = (text) => Effect.tryPromise({
+	try: () => {
+		return new Promise((resolve, reject) => {
+			const platform = process.platform;
+			let command;
+			let args;
+			if (platform === "darwin") {
+				command = "pbcopy";
+				args = [];
+			} else if (platform === "win32") {
+				command = "clip";
+				args = [];
+			} else {
+				command = "xclip";
+				args = ["-selection", "clipboard"];
+			}
+			const proc = spawn(command, args);
+			proc.stdin?.write(text);
+			proc.stdin?.end();
+			proc.on("close", (code) => {
+				if (code === 0) resolve();
+				else if (platform === "linux") {
+					const proc2 = spawn("xsel", ["--clipboard", "--input"]);
+					proc2.stdin?.write(text);
+					proc2.stdin?.end();
+					proc2.on("close", (code2) => {
+						if (code2 === 0) resolve();
+						else reject(/* @__PURE__ */ new Error("Failed to copy to clipboard"));
+					});
+					proc2.on("error", reject);
+				} else reject(/* @__PURE__ */ new Error("Failed to copy to clipboard"));
+			});
+			proc.on("error", reject);
+		});
+	},
+	catch: (error) => /* @__PURE__ */ new Error(`Failed to copy to clipboard: ${error}`)
+});
+/**
+* Open a URL in the system's default browser.
+* Supports macOS (open), Windows (start), and Linux (xdg-open).
+*/
+var openBrowser = (url) => Effect.tryPromise({
+	try: () => {
+		return new Promise((resolve, reject) => {
+			const platform = process.platform;
+			let command;
+			let args;
+			if (platform === "darwin") {
+				command = "open";
+				args = [url];
+			} else if (platform === "win32") {
+				command = "start";
+				args = [url];
+			} else {
+				command = "xdg-open";
+				args = [url];
+			}
+			const proc = spawn(command, args);
+			proc.on("close", (code) => {
+				if (code === 0) resolve();
+				else reject(/* @__PURE__ */ new Error("Failed to open browser"));
+			});
+			proc.on("error", reject);
+		});
+	},
+	catch: (error) => /* @__PURE__ */ new Error(`Failed to open browser: ${error}`)
+});
+//#endregion
+//#region src/oauth/server.ts
+/** Default timeout for a full OAuth browser round-trip. */
+var OAUTH_TIMEOUT_MS = 300 * 1e3;
+/**
+* Relay page that performs a top-level redirect to Edge's `authUrl`. Edge finalizes the flow
+* by redirecting the browser back to this server's callback path (bsky.social nullifies
+* `window.opener`, so a popup + postMessage relay can't be used).
+*/
+var getRelayPageHtml = (authUrl) => `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <script>
+    window.location.href = '${authUrl.replace(/'/g, "\\'")}';
+  <\/script>
+</head>
+<body></body>
+</html>
+`;
+/**
+* Starts a local Bun HTTP server that relays the browser to Edge's auth URL and captures Edge's
+* eventual top-level redirect back to `callbackPath`. Generic over the callback shape: all query
+* params are captured and returned; an `error` query param fails the wait.
+*
+* Used by both the integration-connect flow (`/redirect/oauth`) and the identity-recovery login
+* flow (`/redirect/oauth-recovery`).
+*/
+var startOAuthCallbackServer = (callbackPath) => Effect.gen(function* () {
+	const port = yield* Effect.promise(() => getPort({ random: true }));
+	const origin = `http://localhost:${port}`;
+	const received = yield* Ref.make(false);
+	const outcome = yield* Ref.make(Option.none());
+	const parseUrl = (rawUrl) => new URL(rawUrl.startsWith("http") ? rawUrl : `http://localhost${rawUrl}`);
+	const serverLayer = HttpRouter.empty.pipe(HttpRouter.get("/oauth-relay", Effect.gen(function* () {
+		const request = yield* HttpServerRequest.HttpServerRequest;
+		const authUrl = parseUrl(request.url).searchParams.get("authUrl");
+		if (!authUrl) return yield* HttpServerResponse.text("Missing authUrl parameter", { status: 400 });
+		return yield* HttpServerResponse.text(getRelayPageHtml(authUrl), { headers: { "Content-Type": "text/html" } });
+	})), HttpRouter.get(callbackPath, Effect.gen(function* () {
+		if (Option.isSome(yield* Ref.get(outcome))) return yield* HttpServerResponse.text("Already received.", { status: 400 });
+		const request = yield* HttpServerRequest.HttpServerRequest;
+		const params = parseUrl(request.url).searchParams;
+		const error = params.get("error");
+		if (error) {
+			yield* Ref.set(outcome, Option.some({
+				success: false,
+				reason: error
+			}));
+			yield* Ref.set(received, true);
+			return yield* HttpServerResponse.text(`<html><body><h1>Authentication failed</h1><p>${error}</p></body></html>`, {
+				status: 400,
+				headers: { "Content-Type": "text/html" }
+			});
+		}
+		const captured = {};
+		for (const [key, value] of params.entries()) captured[key] = value;
+		yield* Ref.set(outcome, Option.some({
+			success: true,
+			params: captured
+		}));
+		yield* Ref.set(received, true);
+		return yield* HttpServerResponse.text("<html><body><h1>Authentication successful! You can close this window.</h1></body></html>", { headers: { "Content-Type": "text/html" } });
+	}))).pipe(HttpServer.serve()).pipe(Layer.provide(BunHttpServer.layer({ port })));
+	const scope = yield* Scope.make();
+	yield* Layer.build(serverLayer).pipe(Scope.extend(scope));
+	const waitForResult = (timeoutMs = OAUTH_TIMEOUT_MS) => Effect.race(Effect.gen(function* () {
+		while (true) {
+			if (yield* Ref.get(received)) break;
+			yield* Effect.sleep("500 millis");
+		}
+		const result = yield* Ref.get(outcome);
+		return yield* Option.match(result, {
+			onNone: () => Effect.fail(/* @__PURE__ */ new Error("OAuth callback received but no result")),
+			onSome: (value) => value.success ? Effect.succeed(value.params) : Effect.fail(/* @__PURE__ */ new Error(`OAuth flow failed: ${value.reason}`))
+		});
+	}), Effect.sleep(`${timeoutMs} millis`).pipe(Effect.flatMap(() => Effect.fail(/* @__PURE__ */ new Error("OAuth flow timed out")))));
+	return {
+		port,
+		origin,
+		open: (authUrl) => openBrowser(`${origin}/oauth-relay?authUrl=${encodeURIComponent(authUrl)}`),
+		waitForResult,
+		stop: () => Scope.close(scope, Exit.void).pipe(Effect.catchAll(() => Effect.void))
+	};
+});
+//#endregion
+//#region src/oauth/recovery.ts
+/** Path Edge redirects the browser to after a recovery/register OAuth round-trip. */
+var RECOVERY_CALLBACK_PATH = "/redirect/oauth-recovery";
+/**
+* Drives the gate's OAuth identity-recovery flow from a CLI: starts a local callback server, asks
+* Edge to begin a `recovery`-purpose OAuth flow (advertising the local server as the redirect
+* origin via the `Origin` header), opens the browser, and resolves with the one-time
+* `recoveryProof` Edge carries back in its redirect. The caller redeems the proof via
+* `client.halo.recoverIdentity({ recoveryProof })`.
+*
+* Recovery runs before any identity exists, so no auth header is sent — Edge resolves the user's
+* space / token server-side from the recovery binding, and the `spaceId` / `accessTokenId` in the
+* request are unused (random values satisfy request validation).
+*/
+var performRecoveryOAuthFlow = Effect.fn(function* (params) {
+	const server = yield* startOAuthCallbackServer(RECOVERY_CALLBACK_PATH);
+	return yield* Effect.gen(function* () {
+		const initiateUrl = new URL("/oauth/initiate", params.edgeBaseUrl).toString();
+		const response = yield* Effect.tryPromise({
+			try: () => fetch(initiateUrl, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"Origin": server.origin
+				},
+				body: JSON.stringify({
+					provider: params.provider,
+					scopes: params.scopes,
+					spaceId: SpaceId.random(),
+					accessTokenId: EntityId.random(),
+					purpose: "recovery",
+					loginHint: params.loginHint
+				})
+			}),
+			catch: (error) => /* @__PURE__ */ new Error(`OAuth initiate request failed: ${error instanceof Error ? error.message : String(error)}`)
+		});
+		const envelope = yield* Effect.tryPromise({
+			try: () => response.json(),
+			catch: (error) => /* @__PURE__ */ new Error(`OAuth initiate response parse failed: ${String(error)}`)
+		});
+		if (!envelope.success || !envelope.data?.authUrl) return yield* Effect.fail(/* @__PURE__ */ new Error(`OAuth initiation failed: ${envelope.error?.message ?? "unknown error"}`));
+		yield* server.open(envelope.data.authUrl);
+		const recoveryProof = (yield* server.waitForResult(OAUTH_TIMEOUT_MS)).recoveryProof;
+		if (!recoveryProof) return yield* Effect.fail(/* @__PURE__ */ new Error("OAuth recovery completed but no recoveryProof was returned."));
+		return { recoveryProof };
+	}).pipe(Effect.ensuring(server.stop()));
+});
+//#endregion
+//#region src/util/form-builder.ts
+var form_builder_exports = /* @__PURE__ */ __exportAll({
+	build: () => build,
+	each: () => each,
+	make: () => make,
+	nest: () => nest,
+	nestedOption: () => nestedOption,
+	option: () => option,
+	set: () => set,
+	when: () => when
+});
+var FormBuilderImpl = class {
+	entries = [];
+	title;
+	prefix;
+	constructor(options = {}) {
+		this.title = options.title;
+		this.prefix = options.prefix ?? "- ";
+	}
+	pipe() {
+		return Pipeable.pipeArguments(this, arguments);
+	}
+};
+/**
+* Creates a new FormBuilder instance.
+*/
+var make = (props) => new FormBuilderImpl(props);
+var calculateDimensions = (entries, prefix) => {
+	const maxKeyLen = Math.max(0, ...entries.map((entry) => entry.key.length));
+	return {
+		maxKeyLen,
+		targetWidth: prefix.length + maxKeyLen + 2
+	};
+};
+var buildKeyLine = (prefix, key, targetWidth) => {
+	return Doc.annotate(Doc.fill(targetWidth)(Doc.text(prefix + key + ": ")), Ansi.blackBright);
+};
+var setImpl = (builder, key, value, color) => {
+	if (value !== void 0) {
+		let valueDoc;
+		if (typeof value === "object" && value !== null) valueDoc = value;
+		else valueDoc = Doc.text(String(value));
+		if (color) {
+			const ansi = typeof color === "function" ? color(value) : color;
+			valueDoc = Doc.annotate(valueDoc, ansi);
+		}
+		builder.entries.push({
+			key,
+			value: valueDoc,
+			isNested: false
+		});
+	}
+	return builder;
+};
+function set(builderOrKey, keyOrValue, valueOrColor, color) {
+	if (builderOrKey instanceof FormBuilderImpl) return setImpl(builderOrKey, keyOrValue, valueOrColor, color);
+	else {
+		const key = builderOrKey;
+		const value = keyOrValue;
+		const color = valueOrColor;
+		return (builder) => setImpl(builder, key, value, color);
+	}
+}
+var nestImpl = (parent, key, builder) => {
+	let valueDoc = build({
+		...builder,
+		title: void 0,
+		entries: builder.entries
+	});
+	valueDoc = Doc.indent(valueDoc, 2);
+	parent.entries.push({
+		key,
+		value: valueDoc,
+		isNested: true
+	});
+	return parent;
+};
+function nest(parentOrKey, keyOrBuilder, builder) {
+	if (parentOrKey instanceof FormBuilderImpl) return nestImpl(parentOrKey, keyOrBuilder, builder);
+	else {
+		const key = parentOrKey;
+		const builder = keyOrBuilder;
+		return (parent) => nestImpl(parent, key, builder);
+	}
+}
+var optionImpl = (builder, key, value, color) => {
+	if (Option.isSome(value)) return setImpl(builder, key, value.value, color);
+	return builder;
+};
+function option(builderOrKey, keyOrValue, valueOrColor, color) {
+	if (builderOrKey instanceof FormBuilderImpl) return optionImpl(builderOrKey, keyOrValue, valueOrColor, color);
+	else {
+		const key = builderOrKey;
+		const value = keyOrValue;
+		const color = valueOrColor;
+		return (builder) => optionImpl(builder, key, value, color);
+	}
+}
+var nestedOptionImpl = (builder, key, value) => {
+	if (Option.isSome(value)) return nestImpl(builder, key, value.value);
+	return builder;
+};
+function nestedOption(builderOrKey, keyOrValue, value) {
+	if (builderOrKey instanceof FormBuilderImpl) return nestedOptionImpl(builderOrKey, keyOrValue, value);
+	else {
+		const key = builderOrKey;
+		const value = keyOrValue;
+		return (builder) => nestedOptionImpl(builder, key, value);
+	}
+}
+var whenImpl = (builder, condition, ...ops) => {
+	if (condition) for (const op of ops) op(builder);
+	return builder;
+};
+function when(builderOrCondition, conditionOrOp, ...ops) {
+	if (builderOrCondition instanceof FormBuilderImpl) return whenImpl(builderOrCondition, conditionOrOp, ...ops);
+	else {
+		const condition = builderOrCondition;
+		const allOps = [conditionOrOp, ...ops].filter((op) => typeof op === "function");
+		return (builder) => whenImpl(builder, condition, ...allOps);
+	}
+}
+var eachImpl = (builder, items, fn) => {
+	items.forEach((item) => fn(item)(builder));
+	return builder;
+};
+function each(builderOrItems, itemsOrFn, fn) {
+	if (builderOrItems instanceof FormBuilderImpl) return eachImpl(builderOrItems, itemsOrFn, fn);
+	else {
+		const items = builderOrItems;
+		const fn = itemsOrFn;
+		return (builder) => eachImpl(builder, items, fn);
+	}
+}
+/**
+* Builds the final document.
+*/
+var build = (builder) => {
+	const { targetWidth } = calculateDimensions(builder.entries, builder.prefix);
+	const entryLines = [];
+	builder.entries.forEach(({ key, value, isNested }) => {
+		const keyLine = buildKeyLine(builder.prefix, key, targetWidth);
+		if (isNested) entryLines.push(Doc.hcat([
+			keyLine,
+			Doc.hardLine,
+			value
+		]));
+		else entryLines.push(Doc.hcat([keyLine, value]));
+	});
+	const entriesDoc = Doc.vsep(entryLines);
+	if (builder.title) {
+		const titleDoc = Doc.hcat([Doc.annotate(Doc.text(builder.title), Ansi.combine(Ansi.bold, Ansi.cyan))]);
+		return Doc.cat(titleDoc, Doc.cat(Doc.line, entriesDoc));
+	}
+	return entriesDoc;
+};
+//#endregion
+//#region src/util/format.ts
+var BYTE_UNITS = [
+	"B",
+	"KB",
+	"MB",
+	"GB",
+	"TB"
+];
+/**
+* Format a byte count using binary units.
+*/
+var formatBytes = (bytes) => {
+	let value = bytes;
+	let unit = 0;
+	while (value >= 1024 && unit < BYTE_UNITS.length - 1) {
+		value /= 1024;
+		unit++;
+	}
+	return `${unit === 0 ? value : value.toFixed(1)} ${BYTE_UNITS[unit]}`;
+};
+//#endregion
+//#region src/util/options.ts
+var Common = {
+	functionId: Options.text("function-id").pipe(Options.withDescription("EDGE Function ID.")),
+	spaceId: Options.text("space-id").pipe(Options.withSchema(Key.SpaceId), Options.withDescription("Space ID."))
+};
+//#endregion
+//#region src/util/printer.ts
+/**
+* Pretty print document.
+*/
+var print = (doc) => AnsiDoc.render(doc, { style: "pretty" });
+/**
+* Pretty prints a list of documents with ANSI colors.
+*/
+var printList = (items) => AnsiDoc.render(Doc.vsep(items.map((item) => Doc.cat(item, Doc.hardLine))), { style: "pretty" });
+//#endregion
+//#region src/util/runtime.ts
+/** @deprecated Migrate to providing types via plugin capabilities. */
+var withTypes = (...types) => Effect.gen(function* () {
+	const client = yield* ClientService;
+	yield* Effect.promise(() => client.addTypes(types));
+});
+//#endregion
+//#region src/util/space.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/devtools/cli-util/src/util/space.ts";
+var getSpace = (spaceId) => Effect.gen(function* () {
+	const client = yield* ClientService;
+	return yield* Option.fromNullable(client.spaces.get(spaceId));
+}).pipe(Effect.catchTag("NoSuchElementException", () => Effect.fail(new SpaceNotFoundError(spaceId))));
+var spaceIdWithDefault = (spaceId) => Effect.gen(function* () {
+	const client = yield* ClientService;
+	return Option.getOrElse(spaceId, () => {
+		const personal = AppSpace.getPersonalSpace(client);
+		if (!personal) throw new Error("No space ID provided and no personal space found.");
+		return personal.id;
+	});
+});
+var spaceLayer = (spaceId$, fallbackToPersonalSpace = false) => {
+	const getSpace = Effect.fn(function* () {
+		const client = yield* ClientService;
+		const resolveSpace = () => {
+			if (!fallbackToPersonalSpace) return spaceId$.pipe(Option.flatMap((id) => Option.fromNullable(client.spaces.get(id))));
+			return spaceId$.pipe(Option.flatMap((id) => Option.fromNullable(client.spaces.get(id))), Option.orElse(() => Option.fromNullable(AppSpace.getPersonalSpace(client))), Option.orElse(() => Option.fromNullable(client.spaces.get()[0])));
+		};
+		const space = resolveSpace().pipe(Option.getOrUndefined);
+		if (space) yield* Effect.promise(() => space.waitUntilReady());
+		return space;
+	});
+	const NO_DB_STUB = { get db() {
+		throw new Error("Space not found");
+	} };
+	return Layer.scoped(Database.Service, Effect.acquireRelease(Effect.gen(function* () {
+		const space = yield* getSpace();
+		if (!space) return NO_DB_STUB;
+		return { db: space.db };
+	}), (holder) => holder === NO_DB_STUB ? Effect.void : Effect.promise(() => holder.db.flush())));
+};
+var waitForSync = Effect.fn(function* (space) {
+	if (!isBun()) return;
+	if (space.internal.data.edgeReplication !== EdgeReplicationSetting.ENABLED) {
+		yield* Console.log("Edge replication is disabled, enabling...");
+		yield* Effect.promise(() => space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED));
+	}
+	yield* Effect.promise(() => space.internal.syncToEdge({ onProgress: (state) => log.info("syncing", { state: state ?? "no connection to edge" }, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 114,
+		S: this
+	}) }));
+	yield* Console.log("Sync complete");
+});
+var flushAndSync = Effect.fn(function* (opts) {
+	yield* Database.flush(opts);
+	yield* waitForSync(yield* getSpace(yield* Database.spaceId));
+});
+var SpaceNotFoundError = class extends BaseError.extend("SpaceNotFoundError", "Space not found") {
+	constructor(spaceId, options) {
+		super({
+			context: { spaceId },
+			...options
+		});
+	}
+};
+//#endregion
+//#region src/util/space-format.ts
+var DEFAULT_OPTIONS = {
+	verbose: false,
+	truncateKeys: false,
+	waitSeconds: 0
+};
+/**
+* Per-async-read internal timeout. Some `space.internal.*` getters do
+* filesystem / network IO and can themselves hang on a partially-loaded
+* space; cap each one so the command can never be held hostage by SDK
+* internals.
+*/
+var READ_TIMEOUT_SECONDS = 2;
+var tryWithFallback = (label, run, fallback) => Effect.tryPromise(run).pipe(Effect.timeoutFail({
+	duration: Duration.seconds(READ_TIMEOUT_SECONDS),
+	onTimeout: () => /* @__PURE__ */ new Error(`${label} timed out`)
+}), Effect.catchAll(() => Effect.succeed(fallback)));
+var tryWithFallbackSync = (read, fallback) => {
+	try {
+		return read();
+	} catch {
+		return fallback;
+	}
+};
+var formatSpace = Effect.fn(function* (space, options = {}) {
+	const { waitSeconds } = {
+		...DEFAULT_OPTIONS,
+		...options
+	};
+	if (waitSeconds > 0) yield* Effect.tryPromise(() => space.waitUntilReady()).pipe(Effect.timeoutFail({
+		duration: Duration.seconds(waitSeconds),
+		onTimeout: () => /* @__PURE__ */ new Error("waitUntilReady timed out")
+	}), Effect.catchAll(() => Effect.void));
+	const state = tryWithFallbackSync(() => space.state.get(), SpaceState.SPACE_INITIALIZING);
+	const ready = state === SpaceState.SPACE_READY;
+	const metrics = tryWithFallbackSync(() => space.internal.data.metrics, void 0);
+	const startup = metrics?.open && metrics?.ready ? metrics.ready.getTime() - metrics.open.getTime() : void 0;
+	const pipeline = tryWithFallbackSync(() => space.internal.data.pipeline, void 0);
+	const epoch = pipeline?.currentEpoch?.subject.assertion.number;
+	const syncState = aggregateSyncState(yield* tryWithFallback("getAutomergeSyncState", () => space.internal.db.getAutomergeSyncState(), { peers: {} }));
+	const name = ready ? tryWithFallbackSync(() => space.properties.name, void 0) : "loading...";
+	const members = tryWithFallbackSync(() => space.members.get().length, 0);
+	const objects = tryWithFallbackSync(() => space.internal.db.getAllObjectIds().length, 0);
+	const key = options.truncateKeys ? tryWithFallbackSync(() => space.key.truncate(), "") : tryWithFallbackSync(() => space.key.toHex(), "");
+	return {
+		id: space.id,
+		state: SpaceState[state],
+		name,
+		members,
+		objects,
+		key,
+		epoch,
+		startup,
+		automergeRoot: pipeline?.spaceRootUrl,
+		syncState: `${syncState.count} ${getSyncIndicator(syncState.up, syncState.down)} (${syncState.peers} peers)`
+	};
+});
+var aggregateSyncState = (syncState) => {
+	const peers = Object.keys(syncState.peers ?? {}).length;
+	const missingOnLocal = Math.max(...Object.values(syncState.peers ?? {}).map((peer) => peer.missingOnLocal), 0);
+	const missingOnRemote = Math.max(...Object.values(syncState.peers ?? {}).map((peer) => peer.missingOnRemote), 0);
+	const differentDocuments = Math.max(...Object.values(syncState.peers ?? {}).map((peer) => peer.differentDocuments), 0);
+	return {
+		count: missingOnLocal + missingOnRemote + differentDocuments,
+		peers,
+		up: missingOnRemote > 0 || differentDocuments > 0,
+		down: missingOnLocal > 0 || differentDocuments > 0
+	};
+};
+var getSyncIndicator = (up, down) => {
+	if (up) if (down) return "⇅";
+	else return "↑";
+	else if (down) return "↓";
+	else return "✓";
+};
+/**
+* Pretty prints a space with ANSI colors.
+*/
+var printSpace = (spaceData) => make({ title: spaceData.name ?? spaceData.id }).pipe(set("id", spaceData.id), set("state", spaceData.state), set("key", spaceData.key), set("members", spaceData.members), set("objects", spaceData.objects), set("epoch", spaceData.epoch ?? "<none>"), set("startup", spaceData.startup ? `${spaceData.startup}ms` : "<none>"), set("syncState", spaceData.syncState), set("automergeRoot", spaceData.automergeRoot ?? "<none>"), build);
+//#endregion
+//#region src/util/timeout.ts
+var withTimeout = Effect.fnUntraced(function* (effect) {
+	const duration = (yield* Config.integer("TIMEOUT").pipe(Config.option)).pipe(Option.map(Duration.millis), Option.getOrElse(() => Duration.infinity));
+	return yield* effect.pipe(Effect.timeout(duration));
+});
+//#endregion
+export { CommandConfig, Common, form_builder_exports as FormBuilder, OAUTH_TIMEOUT_MS, SpaceNotFoundError, copyToClipboard, flushAndSync, formatBytes, formatSpace, getSpace, openBrowser, performRecoveryOAuthFlow, print, printList, printSpace, spaceIdWithDefault, spaceLayer, startOAuthCallbackServer, waitForSync, withTimeout, withTypes };
+
+//# sourceMappingURL=index.mjs.map