@dxos/cli-util 0.0.0 → 0.8.4-main.03d5cd7b56

package/dist/lib/node-esm/chunk-N5LOOWPE.mjs

@@ -0,0 +1,27 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/services/command-config.ts
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+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"
+  });
+};
+
+export {
+  __export,
+  CommandConfig
+};
+//# sourceMappingURL=chunk-N5LOOWPE.mjs.map

package/dist/lib/node-esm/chunk-N5LOOWPE.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "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": ";;;;;;;;AAIA,YAAYA,aAAa;AACzB,YAAYC,YAAY;AACxB,YAAYC,WAAW;AAEhB,IAAMC,gBAAN,MAAMA,uBAA8BC,YAAI,eAAA,EAAA,EAAA;EAS7C,OAAOC,SAAuDF,eAAcG,KAAYC,WAAI,CAACC,WAAWA,OAAOC,IAAI,CAAA;EACnH,OAAOC,YAA0DP,eAAcG,KACtEC,WAAI,CAACC,WAAWA,OAAOG,OAAO,CAAA;EAGvC,OAAOC,YAAkBC,cAAQV,gBAAe;IAC9CM,MAAM;IACNE,SAAS;IACTG,SAAS;IACTC,UAAU;EACZ,CAAA;AACF;",
+  "names": ["Context", "Effect", "Layer", "CommandConfig", "Tag", "isJson", "pipe", "map", "config", "json", "isVerbose", "verbose", "layerTest", "succeed", "profile", "logLevel"]
+}

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

@@ -0,0 +1,554 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  CommandConfig,
+  __export
+} from "./chunk-N5LOOWPE.mjs";
+
+// src/util/form-builder.ts
+var form_builder_exports = {};
+__export(form_builder_exports, {
+  build: () => build,
+  each: () => each,
+  make: () => make,
+  nest: () => nest,
+  nestedOption: () => nestedOption,
+  option: () => option,
+  set: () => set,
+  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 Pipeable from "effect/Pipeable";
+var FormBuilderImpl = class {
+  entries = [];
+  title;
+  prefix;
+  constructor(options = {}) {
+    this.title = options.title;
+    this.prefix = options.prefix ?? "- ";
+  }
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments);
+  }
+};
+var make = (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;
+  return {
+    maxKeyLen,
+    targetWidth
+  };
+};
+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) {
+    const builder = builderOrKey;
+    const key = keyOrValue;
+    const value = valueOrColor;
+    return setImpl(builder, key, value, color);
+  } else {
+    const key = builderOrKey;
+    const value = keyOrValue;
+    const color2 = valueOrColor;
+    return (builder) => setImpl(builder, key, value, color2);
+  }
+}
+var nestImpl = (parent, key, builder) => {
+  const nestedBuilder = {
+    ...builder,
+    title: void 0,
+    entries: builder.entries
+  };
+  let valueDoc = build(nestedBuilder);
+  valueDoc = Doc.indent(valueDoc, 2);
+  parent.entries.push({
+    key,
+    value: valueDoc,
+    isNested: true
+  });
+  return parent;
+};
+function nest(parentOrKey, keyOrBuilder, builder) {
+  if (parentOrKey instanceof FormBuilderImpl) {
+    const parent = parentOrKey;
+    const key = keyOrBuilder;
+    return nestImpl(parent, key, builder);
+  } else {
+    const key = parentOrKey;
+    const builder2 = keyOrBuilder;
+    return (parent) => nestImpl(parent, key, builder2);
+  }
+}
+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) {
+    const builder = builderOrKey;
+    const key = keyOrValue;
+    const value = valueOrColor;
+    return optionImpl(builder, key, value, color);
+  } else {
+    const key = builderOrKey;
+    const value = keyOrValue;
+    const color2 = valueOrColor;
+    return (builder) => optionImpl(builder, key, value, color2);
+  }
+}
+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) {
+    const builder = builderOrKey;
+    const key = keyOrValue;
+    return nestedOptionImpl(builder, key, value);
+  } else {
+    const key = builderOrKey;
+    const value2 = keyOrValue;
+    return (builder) => nestedOptionImpl(builder, key, value2);
+  }
+}
+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) {
+    const builder = builderOrCondition;
+    const condition = conditionOrOp;
+    return whenImpl(builder, condition, ...ops);
+  } else {
+    const condition = builderOrCondition;
+    const allOps = [
+      conditionOrOp,
+      ...ops
+    ].filter((op) => typeof op === "function");
+    return (builder) => whenImpl(builder, condition, ...allOps);
+  }
+}
+var eachImpl = (builder, items, fn3) => {
+  items.forEach((item) => fn3(item)(builder));
+  return builder;
+};
+function each(builderOrItems, itemsOrFn, fn3) {
+  if (builderOrItems instanceof FormBuilderImpl) {
+    const builder = builderOrItems;
+    const items = itemsOrFn;
+    return eachImpl(builder, items, fn3);
+  } else {
+    const items = builderOrItems;
+    const fn4 = itemsOrFn;
+    return (builder) => eachImpl(builder, items, fn4);
+  }
+}
+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;
+};
+
+// src/util/options.ts
+import * as Options from "@effect/cli/Options";
+import { Key } from "@dxos/echo";
+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."))
+};
+
+// 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";
+var print = (doc) => AnsiDoc.render(doc, {
+  style: "pretty"
+});
+var printList = (items) => AnsiDoc.render(Doc2.vsep(items.map((item) => Doc2.cat(item, Doc2.hardLine))), {
+  style: "pretty"
+});
+
+// src/util/runtime.ts
+import * as Effect2 from "effect/Effect";
+import { ClientService } from "@dxos/client";
+var withTypes = (...types) => Effect2.gen(function* () {
+  const client = yield* ClientService;
+  yield* Effect2.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 { ClientService as ClientService2 } from "@dxos/client";
+import { Database } from "@dxos/echo";
+import { BaseError } from "@dxos/errors";
+import { QueueService } from "@dxos/functions";
+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* () {
+  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* () {
+  const client = yield* ClientService2;
+  return Option2.getOrElse(spaceId, () => {
+    const personal = 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 getSpace2 = Effect3.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(Option2.flatMap((id) => Option2.fromNullable(client.spaces.get(id))), Option2.orElse(() => Option2.fromNullable(getPersonalSpace(client))), Option2.orElse(() => Option2.fromNullable(client.spaces.get()[0])));
+    };
+    const space = resolveSpace().pipe(Option2.getOrUndefined);
+    if (space) {
+      yield* Effect3.promise(() => space.waitUntilReady());
+    }
+    return space;
+  });
+  const NO_DB_STUB = {
+    get db() {
+      throw new Error("Space not found");
+    }
+  };
+  const db = Layer.scoped(Database.Service, Effect3.acquireRelease(Effect3.gen(function* () {
+    const space = yield* getSpace2();
+    if (!space) {
+      return NO_DB_STUB;
+    }
+    return {
+      db: space.db
+    };
+  }), (holder) => holder === NO_DB_STUB ? Effect3.void : Effect3.promise(() => holder.db.flush())));
+  const queue = Layer.effect(QueueService, Effect3.gen(function* () {
+    const space = yield* getSpace2();
+    if (!space) {
+      return {
+        queues: {
+          get: (_dxn) => {
+            throw new Error("Queues not available");
+          },
+          create: () => {
+            throw new Error("Queues not available");
+          }
+        },
+        queue: void 0
+      };
+    }
+    return {
+      queues: space.queues,
+      queue: void 0
+    };
+  }));
+  return Layer.merge(db, queue);
+};
+var waitForSync = Effect3.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* Effect3.promise(() => space.internal.syncToEdge({
+    onProgress: (state) => log2.info("syncing", {
+      state: state ?? "no connection to edge"
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 107, S: this })
+  }));
+  yield* Console.log("Sync complete");
+});
+var flushAndSync = Effect3.fn(function* (opts) {
+  yield* Database.flush(opts);
+  const spaceId = yield* Database.spaceId;
+  const space = yield* getSpace(spaceId);
+  yield* waitForSync(space);
+});
+var SpaceNotFoundError = class extends BaseError.extend("SpaceNotFoundError", "Space not found") {
+  constructor(spaceId, options) {
+    super({
+      context: {
+        spaceId
+      },
+      ...options
+    });
+  }
+};
+
+// src/util/space-format.ts
+import * as Duration from "effect/Duration";
+import * as Effect4 from "effect/Effect";
+import { SpaceState } from "@dxos/client/echo";
+var DEFAULT_OPTIONS = {
+  verbose: false,
+  truncateKeys: false,
+  waitSeconds: 0
+};
+var READ_TIMEOUT_SECONDS = 2;
+var tryWithFallback = (label, run, fallback) => Effect4.tryPromise(run).pipe(Effect4.timeoutFail({
+  duration: Duration.seconds(READ_TIMEOUT_SECONDS),
+  onTimeout: () => new Error(`${label} timed out`)
+}), Effect4.catchAll(() => Effect4.succeed(fallback)));
+var tryWithFallbackSync = (read, fallback) => {
+  try {
+    return read();
+  } catch {
+    return fallback;
+  }
+};
+var formatSpace = Effect4.fn(function* (space, options = {}) {
+  const { waitSeconds } = {
+    ...DEFAULT_OPTIONS,
+    ...options
+  };
+  if (waitSeconds > 0) {
+    yield* Effect4.tryPromise(() => space.waitUntilReady()).pipe(Effect4.timeoutFail({
+      duration: Duration.seconds(waitSeconds),
+      onTimeout: () => new Error("waitUntilReady timed out")
+    }), Effect4.catchAll(() => Effect4.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 syncStateRaw = yield* tryWithFallback("getSyncState", () => space.internal.db.coreDatabase.getSyncState(), {
+    peers: {}
+  });
+  const syncState = aggregateSyncState(syncStateRaw);
+  const name = ready ? tryWithFallbackSync(() => space.properties.name, void 0) : "loading...";
+  const members = tryWithFallbackSync(() => space.members.get().length, 0);
+  const objects = tryWithFallbackSync(() => space.internal.db.coreDatabase.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,
+    // appliedEpoch,
+    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 "\u21C5";
+    } else {
+      return "\u2191";
+    }
+  } else {
+    if (down) {
+      return "\u2193";
+    } else {
+      return "\u2713";
+    }
+  }
+};
+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);
+
+// 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* (effect2) {
+  const timeout2 = yield* Config.integer("TIMEOUT").pipe(Config.option);
+  const duration = timeout2.pipe(Option3.map(Duration2.millis), Option3.getOrElse(() => Duration2.infinity));
+  return yield* effect2.pipe(Effect5.timeout(duration));
+});
+export {
+  CommandConfig,
+  Common,
+  form_builder_exports as FormBuilder,
+  SpaceNotFoundError,
+  copyToClipboard,
+  flushAndSync,
+  formatSpace,
+  getSpace,
+  openBrowser,
+  print,
+  printList,
+  printSpace,
+  spaceIdWithDefault,
+  spaceLayer,
+  waitForSync,
+  withTimeout,
+  withTypes
+};
+//# sourceMappingURL=index.mjs.map