npm - @dxos/cli-util - Versions diffs - 0.9.0 → 0.9.1-staging.ee54ba693a - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/dist/lib/node-esm/index.mjs +308 -154
package/dist/lib/node-esm/index.mjs.map +4 -4
package/dist/lib/node-esm/meta.json +1 -1
package/dist/types/src/index.d.ts +1 -0
package/dist/types/src/index.d.ts.map +1 -1
package/dist/types/src/oauth/index.d.ts +3 -0
package/dist/types/src/oauth/index.d.ts.map +1 -0
package/dist/types/src/oauth/recovery.d.ts +26 -0
package/dist/types/src/oauth/recovery.d.ts.map +1 -0
package/dist/types/src/oauth/server.d.ts +28 -0
package/dist/types/src/oauth/server.d.ts.map +1 -0
package/dist/types/src/util/space.d.ts +2 -2
package/dist/types/src/util/space.d.ts.map +1 -1
package/dist/types/tsconfig.tsbuildinfo +1 -1
package/package.json +20 -16
package/src/index.ts +1 -0
package/src/oauth/index.ts +6 -0
package/src/oauth/recovery.ts +76 -0
package/src/oauth/server.ts +157 -0
package/src/util/space.ts +6 -17

package/dist/lib/node-esm/index.mjs CHANGED Viewed

@@ -4,21 +4,270 @@ import {
   __export
 } from "./chunk-N5LOOWPE.mjs";
+// src/oauth/server.ts
+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 Effect2 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";
+// src/util/platform.ts
+import * as Effect from "effect/Effect";
+import { spawn } from "node:child_process";
+var copyToClipboard = (text4) => 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(text4);
+      proc.stdin?.end();
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          if (platform === "linux") {
+            const proc2 = spawn("xsel", [
+              "--clipboard",
+              "--input"
+            ]);
+            proc2.stdin?.write(text4);
+            proc2.stdin?.end();
+            proc2.on("close", (code2) => {
+              if (code2 === 0) {
+                resolve();
+              } else {
+                reject(new Error("Failed to copy to clipboard"));
+              }
+            });
+            proc2.on("error", reject);
+          } else {
+            reject(new Error("Failed to copy to clipboard"));
+          }
+        }
+      });
+      proc.on("error", reject);
+    });
+  },
+  catch: (error) => new Error(`Failed to copy to clipboard: ${error}`)
+});
+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(new Error("Failed to open browser"));
+        }
+      });
+      proc.on("error", reject);
+    });
+  },
+  catch: (error) => new Error(`Failed to open browser: ${error}`)
+});
+// src/oauth/server.ts
+var OAUTH_TIMEOUT_MS = 5 * 60 * 1e3;
+var getRelayPageHtml = (authUrl) => `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <script>
+    window.location.href = '${authUrl.replace(/'/g, "\\'")}';
+  </script>
+</head>
+<body></body>
+</html>
+`;
+var startOAuthCallbackServer = (callbackPath) => Effect2.gen(function* () {
+  const port = yield* Effect2.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 router = HttpRouter.empty.pipe(HttpRouter.get("/oauth-relay", Effect2.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, Effect2.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"
+      }
+    });
+  })));
+  const app = router.pipe(HttpServer.serve());
+  const serverLayer = app.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) => Effect2.race(Effect2.gen(function* () {
+    while (true) {
+      if (yield* Ref.get(received)) {
+        break;
+      }
+      yield* Effect2.sleep("500 millis");
+    }
+    const result = yield* Ref.get(outcome);
+    return yield* Option.match(result, {
+      onNone: () => Effect2.fail(new Error("OAuth callback received but no result")),
+      onSome: (value) => value.success ? Effect2.succeed(value.params) : Effect2.fail(new Error(`OAuth flow failed: ${value.reason}`))
+    });
+  }), Effect2.sleep(`${timeoutMs} millis`).pipe(Effect2.flatMap(() => Effect2.fail(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(Effect2.catchAll(() => Effect2.void))
+  };
+});
+// src/oauth/recovery.ts
+import * as Effect3 from "effect/Effect";
+import { EntityId, SpaceId } from "@dxos/keys";
+var RECOVERY_CALLBACK_PATH = "/redirect/oauth-recovery";
+var performRecoveryOAuthFlow = Effect3.fn(function* (params) {
+  const server = yield* startOAuthCallbackServer(RECOVERY_CALLBACK_PATH);
+  return yield* Effect3.gen(function* () {
+    const initiateUrl = new URL("/oauth/initiate", params.edgeBaseUrl).toString();
+    const response = yield* Effect3.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) => new Error(`OAuth initiate request failed: ${error instanceof Error ? error.message : String(error)}`)
+    });
+    const envelope = yield* Effect3.tryPromise({
+      try: () => response.json(),
+      catch: (error) => new Error(`OAuth initiate response parse failed: ${String(error)}`)
+    });
+    if (!envelope.success || !envelope.data?.authUrl) {
+      return yield* Effect3.fail(new Error(`OAuth initiation failed: ${envelope.error?.message ?? "unknown error"}`));
+    }
+    yield* server.open(envelope.data.authUrl);
+    const callbackParams = yield* server.waitForResult(OAUTH_TIMEOUT_MS);
+    const recoveryProof = callbackParams.recoveryProof;
+    if (!recoveryProof) {
+      return yield* Effect3.fail(new Error("OAuth recovery completed but no recoveryProof was returned."));
+    }
+    return {
+      recoveryProof
+    };
+  }).pipe(Effect3.ensuring(server.stop()));
+});
 // src/util/form-builder.ts
 var form_builder_exports = {};
 __export(form_builder_exports, {
-  build: () => build,
+  build: () => build2,
   each: () => each,
-  make: () => make,
+  make: () => make3,
   nest: () => nest,
   nestedOption: () => nestedOption,
   option: () => option,
-  set: () => set,
+  set: () => set2,
   when: () => when
 });
 import * as Ansi from "@effect/printer-ansi/Ansi";
 import * as Doc from "@effect/printer/Doc";
-import * as Option from "effect/Option";
+import * as Option2 from "effect/Option";
 import * as Pipeable from "effect/Pipeable";
 var FormBuilderImpl = class {
   entries = [];
@@ -32,7 +281,7 @@ var FormBuilderImpl = class {
     return Pipeable.pipeArguments(this, arguments);
   }
 };
-var make = (props) => new FormBuilderImpl(props);
+var make3 = (props) => new FormBuilderImpl(props);
 var calculateDimensions = (entries, prefix) => {
   const maxKeyLen = Math.max(0, ...entries.map((entry) => entry.key.length));
   const targetWidth = prefix.length + maxKeyLen + 2;
@@ -64,7 +313,7 @@ var setImpl = (builder, key, value, color) => {
   }
   return builder;
 };
-function set(builderOrKey, keyOrValue, valueOrColor, color) {
+function set2(builderOrKey, keyOrValue, valueOrColor, color) {
   if (builderOrKey instanceof FormBuilderImpl) {
     const builder = builderOrKey;
     const key = keyOrValue;
@@ -83,7 +332,7 @@ var nestImpl = (parent, key, builder) => {
     title: void 0,
     entries: builder.entries
   };
-  let valueDoc = build(nestedBuilder);
+  let valueDoc = build2(nestedBuilder);
   valueDoc = Doc.indent(valueDoc, 2);
   parent.entries.push({
     key,
@@ -104,7 +353,7 @@ function nest(parentOrKey, keyOrBuilder, builder) {
   }
 }
 var optionImpl = (builder, key, value, color) => {
-  if (Option.isSome(value)) {
+  if (Option2.isSome(value)) {
     return setImpl(builder, key, value.value, color);
   }
   return builder;
@@ -123,7 +372,7 @@ function option(builderOrKey, keyOrValue, valueOrColor, color) {
   }
 }
 var nestedOptionImpl = (builder, key, value) => {
-  if (Option.isSome(value)) {
+  if (Option2.isSome(value)) {
     return nestImpl(builder, key, value.value);
   }
   return builder;
@@ -161,22 +410,22 @@ function when(builderOrCondition, conditionOrOp, ...ops) {
     return (builder) => whenImpl(builder, condition, ...allOps);
   }
 }
-var eachImpl = (builder, items, fn3) => {
-  items.forEach((item) => fn3(item)(builder));
+var eachImpl = (builder, items, fn4) => {
+  items.forEach((item) => fn4(item)(builder));
   return builder;
 };
-function each(builderOrItems, itemsOrFn, fn3) {
+function each(builderOrItems, itemsOrFn, fn4) {
   if (builderOrItems instanceof FormBuilderImpl) {
     const builder = builderOrItems;
     const items = itemsOrFn;
-    return eachImpl(builder, items, fn3);
+    return eachImpl(builder, items, fn4);
   } else {
     const items = builderOrItems;
-    const fn4 = itemsOrFn;
-    return (builder) => eachImpl(builder, items, fn4);
+    const fn5 = itemsOrFn;
+    return (builder) => eachImpl(builder, items, fn5);
   }
 }
-var build = (builder) => {
+var build2 = (builder) => {
   const { targetWidth } = calculateDimensions(builder.entries, builder.prefix);
   const entryLines = [];
   builder.entries.forEach(({ key, value, isNested }) => {
@@ -212,96 +461,6 @@ var Common = {
   spaceId: Options.text("space-id").pipe(Options.withSchema(Key.SpaceId), Options.withDescription("Space ID."))
 };
-// src/util/platform.ts
-import * as Effect from "effect/Effect";
-import { spawn } from "node:child_process";
-var copyToClipboard = (text3) => 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(text3);
-      proc.stdin?.end();
-      proc.on("close", (code) => {
-        if (code === 0) {
-          resolve();
-        } else {
-          if (platform === "linux") {
-            const proc2 = spawn("xsel", [
-              "--clipboard",
-              "--input"
-            ]);
-            proc2.stdin?.write(text3);
-            proc2.stdin?.end();
-            proc2.on("close", (code2) => {
-              if (code2 === 0) {
-                resolve();
-              } else {
-                reject(new Error("Failed to copy to clipboard"));
-              }
-            });
-            proc2.on("error", reject);
-          } else {
-            reject(new Error("Failed to copy to clipboard"));
-          }
-        }
-      });
-      proc.on("error", reject);
-    });
-  },
-  catch: (error) => new Error(`Failed to copy to clipboard: ${error}`)
-});
-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(new Error("Failed to open browser"));
-        }
-      });
-      proc.on("error", reject);
-    });
-  },
-  catch: (error) => new Error(`Failed to open browser: ${error}`)
-});
 // src/util/printer.ts
 import * as AnsiDoc from "@effect/printer-ansi/AnsiDoc";
 import * as Doc2 from "@effect/printer/Doc";
@@ -313,35 +472,34 @@ var printList = (items) => AnsiDoc.render(Doc2.vsep(items.map((item) => Doc2.cat
 });
 // src/util/runtime.ts
-import * as Effect2 from "effect/Effect";
+import * as Effect4 from "effect/Effect";
 import { ClientService } from "@dxos/client";
-var withTypes = (...types) => Effect2.gen(function* () {
+var withTypes = (...types) => Effect4.gen(function* () {
   const client = yield* ClientService;
-  yield* Effect2.promise(() => client.addTypes(types));
+  yield* Effect4.promise(() => client.addTypes(types));
 });
 // src/util/space.ts
 import * as Console from "effect/Console";
-import * as Effect3 from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option2 from "effect/Option";
-import { getPersonalSpace } from "@dxos/app-toolkit";
+import * as Effect5 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import * as Option3 from "effect/Option";
+import { AppSpace } from "@dxos/app-toolkit";
 import { ClientService as ClientService2 } from "@dxos/client";
-import { Database, Feed } from "@dxos/echo";
-import { createFeedServiceLayer } from "@dxos/echo-client";
+import { Database } from "@dxos/echo";
 import { BaseError } from "@dxos/errors";
 import { log as log2 } from "@dxos/log";
 import { EdgeReplicationSetting } from "@dxos/protocols/proto/dxos/echo/metadata";
 import { isBun } from "@dxos/util";
 var __dxlog_file = "/__w/dxos/dxos/packages/devtools/cli-util/src/util/space.ts";
-var getSpace = (spaceId) => Effect3.gen(function* () {
+var getSpace = (spaceId) => Effect5.gen(function* () {
   const client = yield* ClientService2;
-  return yield* Option2.fromNullable(client.spaces.get(spaceId));
-}).pipe(Effect3.catchTag("NoSuchElementException", () => Effect3.fail(new SpaceNotFoundError(spaceId))));
-var spaceIdWithDefault = (spaceId) => Effect3.gen(function* () {
+  return yield* Option3.fromNullable(client.spaces.get(spaceId));
+}).pipe(Effect5.catchTag("NoSuchElementException", () => Effect5.fail(new SpaceNotFoundError(spaceId))));
+var spaceIdWithDefault = (spaceId) => Effect5.gen(function* () {
   const client = yield* ClientService2;
-  return Option2.getOrElse(spaceId, () => {
-    const personal = getPersonalSpace(client);
+  return Option3.getOrElse(spaceId, () => {
+    const personal = AppSpace.getPersonalSpace(client);
     if (!personal) {
       throw new Error("No space ID provided and no personal space found.");
     }
@@ -349,17 +507,17 @@ var spaceIdWithDefault = (spaceId) => Effect3.gen(function* () {
   });
 });
 var spaceLayer = (spaceId$, fallbackToPersonalSpace = false) => {
-  const getSpace2 = Effect3.fn(function* () {
+  const getSpace2 = Effect5.fn(function* () {
     const client = yield* ClientService2;
     const resolveSpace = () => {
       if (!fallbackToPersonalSpace) {
-        return spaceId$.pipe(Option2.flatMap((id) => Option2.fromNullable(client.spaces.get(id))));
+        return spaceId$.pipe(Option3.flatMap((id) => Option3.fromNullable(client.spaces.get(id))));
       }
-      return spaceId$.pipe(Option2.flatMap((id) => Option2.fromNullable(client.spaces.get(id))), Option2.orElse(() => Option2.fromNullable(getPersonalSpace(client))), Option2.orElse(() => Option2.fromNullable(client.spaces.get()[0])));
+      return spaceId$.pipe(Option3.flatMap((id) => Option3.fromNullable(client.spaces.get(id))), Option3.orElse(() => Option3.fromNullable(AppSpace.getPersonalSpace(client))), Option3.orElse(() => Option3.fromNullable(client.spaces.get()[0])));
     };
-    const space = resolveSpace().pipe(Option2.getOrUndefined);
+    const space = resolveSpace().pipe(Option3.getOrUndefined);
     if (space) {
-      yield* Effect3.promise(() => space.waitUntilReady());
+      yield* Effect5.promise(() => space.waitUntilReady());
     }
     return space;
   });
@@ -368,7 +526,7 @@ var spaceLayer = (spaceId$, fallbackToPersonalSpace = false) => {
       throw new Error("Space not found");
     }
   };
-  const db = Layer.scoped(Database.Service, Effect3.acquireRelease(Effect3.gen(function* () {
+  const db = Layer2.scoped(Database.Service, Effect5.acquireRelease(Effect5.gen(function* () {
     const space = yield* getSpace2();
     if (!space) {
       return NO_DB_STUB;
@@ -376,32 +534,25 @@ var spaceLayer = (spaceId$, fallbackToPersonalSpace = false) => {
     return {
       db: space.db
     };
-  }), (holder) => holder === NO_DB_STUB ? Effect3.void : Effect3.promise(() => holder.db.flush())));
-  const feed = Layer.unwrapEffect(Effect3.gen(function* () {
-    const space = yield* getSpace2();
-    if (!space) {
-      return Feed.notAvailable;
-    }
-    return createFeedServiceLayer(space.queues);
-  }));
-  return Layer.merge(db, feed);
+  }), (holder) => holder === NO_DB_STUB ? Effect5.void : Effect5.promise(() => holder.db.flush())));
+  return db;
 };
-var waitForSync = Effect3.fn(function* (space) {
+var waitForSync = Effect5.fn(function* (space) {
   if (!isBun()) {
     return;
   }
   if (space.internal.data.edgeReplication !== EdgeReplicationSetting.ENABLED) {
     yield* Console.log("Edge replication is disabled, enabling...");
-    yield* Effect3.promise(() => space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED));
+    yield* Effect5.promise(() => space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED));
   }
-  yield* Effect3.promise(() => space.internal.syncToEdge({
+  yield* Effect5.promise(() => space.internal.syncToEdge({
     onProgress: (state) => log2.info("syncing", {
       state: state ?? "no connection to edge"
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 94, S: this })
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 86, S: this })
   }));
   yield* Console.log("Sync complete");
 });
-var flushAndSync = Effect3.fn(function* (opts) {
+var flushAndSync = Effect5.fn(function* (opts) {
   yield* Database.flush(opts);
   const spaceId = yield* Database.spaceId;
   const space = yield* getSpace(spaceId);
@@ -420,7 +571,7 @@ var SpaceNotFoundError = class extends BaseError.extend("SpaceNotFoundError", "S
 // src/util/space-format.ts
 import * as Duration from "effect/Duration";
-import * as Effect4 from "effect/Effect";
+import * as Effect6 from "effect/Effect";
 import { SpaceState } from "@dxos/client/echo";
 var DEFAULT_OPTIONS = {
   verbose: false,
@@ -428,10 +579,10 @@ var DEFAULT_OPTIONS = {
   waitSeconds: 0
 };
 var READ_TIMEOUT_SECONDS = 2;
-var tryWithFallback = (label, run, fallback) => Effect4.tryPromise(run).pipe(Effect4.timeoutFail({
+var tryWithFallback = (label, run, fallback) => Effect6.tryPromise(run).pipe(Effect6.timeoutFail({
   duration: Duration.seconds(READ_TIMEOUT_SECONDS),
   onTimeout: () => new Error(`${label} timed out`)
-}), Effect4.catchAll(() => Effect4.succeed(fallback)));
+}), Effect6.catchAll(() => Effect6.succeed(fallback)));
 var tryWithFallbackSync = (read, fallback) => {
   try {
     return read();
@@ -439,16 +590,16 @@ var tryWithFallbackSync = (read, fallback) => {
     return fallback;
   }
 };
-var formatSpace = Effect4.fn(function* (space, options = {}) {
+var formatSpace = Effect6.fn(function* (space, options = {}) {
   const { waitSeconds } = {
     ...DEFAULT_OPTIONS,
     ...options
   };
   if (waitSeconds > 0) {
-    yield* Effect4.tryPromise(() => space.waitUntilReady()).pipe(Effect4.timeoutFail({
+    yield* Effect6.tryPromise(() => space.waitUntilReady()).pipe(Effect6.timeoutFail({
       duration: Duration.seconds(waitSeconds),
       onTimeout: () => new Error("waitUntilReady timed out")
-    }), Effect4.catchAll(() => Effect4.void));
+    }), Effect6.catchAll(() => Effect6.void));
   }
   const state = tryWithFallbackSync(() => space.state.get(), SpaceState.SPACE_INITIALIZING);
   const ready = state === SpaceState.SPACE_READY;
@@ -505,35 +656,38 @@ var getSyncIndicator = (up, down) => {
     }
   }
 };
-var printSpace = (spaceData) => make({
+var printSpace = (spaceData) => make3({
   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);
+}).pipe(set2("id", spaceData.id), set2("state", spaceData.state), set2("key", spaceData.key), set2("members", spaceData.members), set2("objects", spaceData.objects), set2("epoch", spaceData.epoch ?? "<none>"), set2("startup", spaceData.startup ? `${spaceData.startup}ms` : "<none>"), set2("syncState", spaceData.syncState), set2("automergeRoot", spaceData.automergeRoot ?? "<none>"), build2);
 // src/util/timeout.ts
 import * as Config from "effect/Config";
 import * as Duration2 from "effect/Duration";
-import * as Effect5 from "effect/Effect";
-import * as Option3 from "effect/Option";
-var withTimeout = Effect5.fnUntraced(function* (effect) {
+import * as Effect7 from "effect/Effect";
+import * as Option4 from "effect/Option";
+var withTimeout = Effect7.fnUntraced(function* (effect) {
   const timeout2 = yield* Config.integer("TIMEOUT").pipe(Config.option);
-  const duration = timeout2.pipe(Option3.map(Duration2.millis), Option3.getOrElse(() => Duration2.infinity));
-  return yield* effect.pipe(Effect5.timeout(duration));
+  const duration = timeout2.pipe(Option4.map(Duration2.millis), Option4.getOrElse(() => Duration2.infinity));
+  return yield* effect.pipe(Effect7.timeout(duration));
 });
 export {
   CommandConfig,
   Common,
   form_builder_exports as FormBuilder,
+  OAUTH_TIMEOUT_MS,
   SpaceNotFoundError,
   copyToClipboard,
   flushAndSync,
   formatSpace,
   getSpace,
   openBrowser,
+  performRecoveryOAuthFlow,
   print,
   printList,
   printSpace,
   spaceIdWithDefault,
   spaceLayer,
+  startOAuthCallbackServer,
   waitForSync,
   withTimeout,
   withTypes