@wirecat/zoom-cli 0.55.0 → 0.57.0

package/dist/bundle/chunk-5F7IOESV.js

@@ -0,0 +1,281 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  answeredWire
+} from "./chunk-AN3GVZTU.js";
+import {
+  CALLER_META_KEY,
+  PROXY_CLIENT_NAME,
+  StdioServerTransport,
+  callerOf,
+  serveStdio
+} from "./chunk-VPPYYWOH.js";
+import {
+  McpServer
+} from "./chunk-5D4AEUVA.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/mcp/all-profiles.js
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+var PROTOCOL = "2025-06-18";
+var START_MS = 3e4;
+var CHILD_IDLE_MS = 10 * 60 * 1e3;
+var startChild = /* @__PURE__ */ __name((spec, note, onExit) => {
+  const child = spawn(spec.command, spec.args, { env: spec.env, stdio: "pipe" });
+  const pending = /* @__PURE__ */ new Map();
+  let next = 1;
+  let buffer = "";
+  let gone;
+  const fail = /* @__PURE__ */ __name((error) => {
+    gone ??= error;
+    for (const waiter of pending.values())
+      waiter.reject(error);
+    pending.clear();
+  }, "fail");
+  child.on("error", () => fail(new Error("the profile's MCP server could not be started")));
+  child.on("exit", () => {
+    fail(new Error("the profile's MCP server stopped"));
+    onExit();
+  });
+  child.stdin.on("error", () => fail(new Error("the profile's MCP server closed its input")));
+  child.stderr.setEncoding("utf8");
+  let errors = "";
+  child.stderr.on("data", (chunk) => {
+    const lines = (errors + chunk).split("\n");
+    errors = lines.pop() ?? "";
+    for (const line of lines)
+      if (line.trim())
+        note(line);
+  });
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk;
+    for (let at = buffer.indexOf("\n"); at !== -1; at = buffer.indexOf("\n")) {
+      const line = buffer.slice(0, at);
+      buffer = buffer.slice(at + 1);
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (message.method !== void 0 && message.id !== void 0) {
+        send({ id: message.id, error: { code: -32601, message: "not offered through the all-profiles server" } });
+        continue;
+      }
+      if (typeof message.id !== "number")
+        continue;
+      const waiter = pending.get(message.id);
+      if (!waiter)
+        continue;
+      pending.delete(message.id);
+      if (message.error)
+        waiter.reject(new Error(message.error.message ?? "the profile's MCP server refused"));
+      else
+        waiter.resolve(message.result ?? {});
+    }
+  });
+  const send = /* @__PURE__ */ __name((message) => child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", ...message })}
+`), "send");
+  const request = /* @__PURE__ */ __name((method, params) => new Promise((resolve, reject) => {
+    if (gone)
+      return reject(gone);
+    const id = next++;
+    pending.set(id, { resolve, reject });
+    send({ id, method, params });
+  }), "request");
+  const close = /* @__PURE__ */ __name(() => new Promise((resolve) => {
+    if (child.exitCode !== null || child.signalCode !== null)
+      return resolve();
+    child.once("exit", () => resolve());
+    child.stdin.end();
+  }), "close");
+  const timer = setTimeout(() => fail(new Error("the profile's MCP server did not answer in time")), START_MS);
+  return request("initialize", {
+    protocolVersion: PROTOCOL,
+    capabilities: {},
+    clientInfo: { name: PROXY_CLIENT_NAME, version: "1" }
+  }).then(() => {
+    send({ method: "notifications/initialized" });
+    return { request, close };
+  }).catch(async (error) => {
+    await close();
+    throw error;
+  }).finally(() => clearTimeout(timer));
+}, "startChild");
+var pool = /* @__PURE__ */ __name((options) => {
+  const idleMs = options.idleMs ?? CHILD_IDLE_MS;
+  const note = options.note ?? (() => {
+  });
+  const running = /* @__PURE__ */ new Map();
+  const forget = /* @__PURE__ */ __name((profile, child) => {
+    const one = running.get(profile);
+    if (one?.child !== child)
+      return;
+    clearTimeout(one.timer);
+    running.delete(profile);
+  }, "forget");
+  const use = /* @__PURE__ */ __name(async (profile, work) => {
+    let one = running.get(profile);
+    if (!one) {
+      const child = startChild(options.child(profile), (line) => note(`${profile}: ${line}`), () => forget(profile, child));
+      child.catch(() => forget(profile, child));
+      one = { child };
+      running.set(profile, one);
+    }
+    clearTimeout(one.timer);
+    const entry = one;
+    try {
+      return await work(await entry.child);
+    } finally {
+      if (running.get(profile) === entry) {
+        entry.timer = setTimeout(() => {
+          forget(profile, entry.child);
+          void entry.child.then((child) => child.close()).catch(() => void 0);
+        }, idleMs);
+        entry.timer.unref();
+      }
+    }
+  }, "use");
+  const close = /* @__PURE__ */ __name(async () => {
+    const all = [...running.values()];
+    running.clear();
+    for (const one of all)
+      clearTimeout(one.timer);
+    await Promise.all(all.map((one) => one.child.then((child) => child.close()).catch(() => void 0)));
+  }, "close");
+  return { use, close };
+}, "pool");
+var withProfile = /* @__PURE__ */ __name((tool, profiles, name, signedIn = () => true) => {
+  const schema = tool.inputSchema;
+  const out = profiles.filter((profile) => !signedIn(profile));
+  const states = out.length === 0 ? "" : ` Signed in: ${profiles.filter(signedIn).join(", ") || "none"} \xB7 Not signed in: ${out.join(", ")}.`;
+  return {
+    ...tool,
+    inputSchema: {
+      ...tool.inputSchema,
+      properties: {
+        profile: {
+          type: "string",
+          enum: [...profiles],
+          oneOf: profiles.map((profile) => ({
+            const: profile,
+            title: signedIn(profile) ? profile : `${profile} \u2014 not signed in`
+          })),
+          description: `Which ${name} account, by its profile. If the owner did not name one, ask which \u2014 never guess.${states}`
+        },
+        ...schema.properties
+      },
+      required: ["profile", ...(schema.required ?? []).filter((field) => field !== "profile")]
+    }
+  };
+}, "withProfile");
+var refusal = /* @__PURE__ */ __name((text) => ({
+  isError: true,
+  content: [{ type: "text", text }]
+}), "refusal");
+var allProfilesServer = /* @__PURE__ */ __name((options) => {
+  const children = pool(options);
+  let listed;
+  const tools = /* @__PURE__ */ __name((profiles) => {
+    listed ??= children.use(profiles.find(signedIn) ?? profiles[0], (child) => child.request("tools/list", {})).then((answer) => answer.tools ?? []);
+    listed.catch(() => {
+      listed = void 0;
+    });
+    return listed;
+  }, "tools");
+  const signedIn = /* @__PURE__ */ __name((profile) => options.signedIn?.(profile) ?? true, "signedIn");
+  const build = /* @__PURE__ */ __name(() => {
+    const profiles = [...options.profiles()].sort();
+    const server = new McpServer({ name: options.command, version: options.version }, { capabilities: { tools: {} }, instructions: options.instructions });
+    server.server.setRequestHandler("tools/list", async () => ({
+      tools: profiles.length === 0 ? [] : (await tools(profiles)).map((one) => withProfile(one, profiles, options.name, signedIn))
+    }));
+    const callers = {
+      env: options.env ?? process.env,
+      client: /* @__PURE__ */ __name(() => server.server.getClientVersion(), "client"),
+      connectionId: randomUUID()
+    };
+    server.server.setRequestHandler("tools/call", async (request, ctx) => {
+      const { name, arguments: given = {}, _meta } = request.params;
+      const { profile, ...rest } = given;
+      if (typeof profile !== "string" || !profiles.includes(profile))
+        return refusal(`${name} needs "profile", one of: ${profiles.join(", ")}. If the owner did not say which account, ask.`);
+      if (!signedIn(profile))
+        return refusal(options.signIn?.(profile) ?? `profile ${profile} is not signed in.`);
+      try {
+        return await children.use(profile, (child) => (
+          // Children are shared by every session, so each call names its own caller.
+          child.request("tools/call", {
+            name,
+            arguments: rest,
+            _meta: { ..._meta, [CALLER_META_KEY]: callerOf(ctx, name, callers) }
+          })
+        ));
+      } catch (error) {
+        return refusal(`profile ${profile}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    });
+    return server;
+  }, "build");
+  return { build, close: /* @__PURE__ */ __name(() => children.close(), "close") };
+}, "allProfilesServer");
+var serveAllProfilesOverStdio = /* @__PURE__ */ __name(async (options, io = {}) => {
+  const { build, close } = allProfilesServer(options);
+  const own = io.stdin !== void 0 && io.stdin !== process.stdin;
+  const wire = answeredWire(io.stdin ?? process.stdin, io.stdout ?? process.stdout);
+  const handle = serveStdio(build, {
+    transport: new StdioServerTransport(wire.input, wire.output),
+    onerror: /* @__PURE__ */ __name((error) => options.note?.(`mcp: ${error.message}`), "onerror")
+  });
+  const ended = await new Promise((resolve) => {
+    wire.ended.then(() => resolve("input"));
+    if (own)
+      io.signal?.addEventListener("abort", () => resolve("stopped"), { once: true });
+    else {
+      process.once("SIGINT", () => resolve("stopped"));
+      process.once("SIGTERM", () => resolve("stopped"));
+    }
+  });
+  try {
+    if (ended === "input")
+      await wire.answered();
+    wire.release();
+    await handle.close();
+  } finally {
+    await close();
+  }
+}, "serveAllProfilesOverStdio");
+var serveAllProfilesOverHttp = /* @__PURE__ */ __name(async (options, http) => {
+  const { build, close } = allProfilesServer(options);
+  const { serveOverHttp } = await import("./serve-HIJTFAW7.js");
+  const listening = await serveOverHttp(build, {
+    ...http,
+    appName: options.command,
+    onError: /* @__PURE__ */ __name((error) => options.note?.(`mcp: ${error.message}`), "onError")
+  }).catch(async (error) => {
+    await close();
+    throw error;
+  });
+  return {
+    url: listening.url,
+    close: /* @__PURE__ */ __name(async () => {
+      try {
+        await listening.close();
+      } finally {
+        await close();
+      }
+    }, "close")
+  };
+}, "serveAllProfilesOverHttp");
+
+export {
+  CHILD_IDLE_MS,
+  withProfile,
+  allProfilesServer,
+  serveAllProfilesOverStdio,
+  serveAllProfilesOverHttp
+};

package/dist/bundle/chunk-5QESMCQK.js

@@ -0,0 +1,122 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  unit
+} from "./chunk-CLMXBW53.js";
+import {
+  CliError
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/embeddings/remote.js
+import { setTimeout } from "node:timers/promises";
+var OPENAI_URL = "https://api.openai.com/v1";
+var OPENAI_MODELS = {
+  "text-embedding-3-small": { dims: 1536, perMillion: 0.02 },
+  "text-embedding-3-large": { dims: 3072, perMillion: 0.13 }
+};
+var DEFAULT_OPENAI_MODEL = "text-embedding-3-small";
+var PER_REQUEST = 256;
+var LOCAL = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+var isLocal = /* @__PURE__ */ __name((baseUrl) => LOCAL.has(new URL(baseUrl).hostname), "isLocal");
+var remoteModel = /* @__PURE__ */ __name(({ model = DEFAULT_OPENAI_MODEL, baseUrl, dims }) => {
+  const known = baseUrl === void 0 ? OPENAI_MODELS[model] : void 0;
+  if (baseUrl === void 0 && !known) {
+    throw new CliError("validation_error", `OpenAI has no embedding model ${model} here \u2014 one of: ${Object.keys(OPENAI_MODELS).join(", ")}; another server takes --base-url`);
+  }
+  const size = dims ?? known?.dims;
+  if (size === void 0)
+    throw new CliError("validation_error", "with --base-url, say the vector size with --dims");
+  return {
+    provider: baseUrl === void 0 ? "openai" : `url:${new URL(baseUrl).host}`,
+    model,
+    dims: size,
+    baseUrl: baseUrl ?? OPENAI_URL,
+    shorten: known !== void 0 && size !== known.dims,
+    ...known ? { price: { perMillion: known.perMillion, read: "2026-10-02" } } : {}
+  };
+}, "remoteModel");
+var remoteKey = /* @__PURE__ */ __name(({ provider, model, dims }) => `${provider}:${model}:${dims}`, "remoteKey");
+var openRemote = /* @__PURE__ */ __name((remote, apiKey, { concurrency = 4, fetch: post = fetch, tries = 5 } = {}) => {
+  const request = /* @__PURE__ */ __name(async (input) => {
+    for (let attempt = 1; ; attempt++) {
+      let response;
+      try {
+        response = await post(`${remote.baseUrl.replace(/\/$/, "")}/embeddings`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            ...apiKey ? { authorization: `Bearer ${apiKey}` } : {}
+          },
+          body: JSON.stringify({
+            model: remote.model,
+            input,
+            encoding_format: "float",
+            ...remote.shorten ? { dimensions: remote.dims } : {}
+          })
+        });
+      } catch {
+        if (attempt >= tries)
+          throw new CliError("network_error", `${remote.provider} could not be reached`);
+        await setTimeout(1e3 * attempt);
+        continue;
+      }
+      if (response.ok) {
+        const body = await response.json();
+        const data = [...body.data ?? []].sort((a, b) => a.index - b.index);
+        if (data.length !== input.length || data.some(({ embedding }) => embedding.length !== remote.dims)) {
+          throw new CliError("invalid_response", `${remote.provider} answered with vectors of another number or size than ${input.length} \xD7 ${remote.dims}`);
+        }
+        return data.map(({ embedding }) => unit(Float32Array.from(embedding)));
+      }
+      const code = await errorCode(response);
+      if (response.status === 401 || response.status === 403) {
+        throw new CliError("authentication_error", `${remote.provider} refused the key (HTTP ${response.status}${code}) \u2014 set it again with \`models keys set\``);
+      }
+      const again = response.status === 429 || response.status >= 500;
+      if (!again || attempt >= tries) {
+        throw new CliError(response.status === 429 ? "rate_limited" : "provider_error", `${remote.provider} answered HTTP ${response.status}${code}`);
+      }
+      const wait = Number(response.headers.get("retry-after"));
+      await setTimeout(Number.isFinite(wait) && wait > 0 ? wait * 1e3 : 1e3 * 2 ** attempt);
+    }
+  }, "request");
+  return {
+    model: { id: remote.model, dims: remote.dims },
+    embed: /* @__PURE__ */ __name(async (texts) => {
+      const parts = [];
+      for (let start = 0; start < texts.length; start += PER_REQUEST)
+        parts.push(texts.slice(start, start + PER_REQUEST));
+      const results = new Array(parts.length);
+      let next = 0;
+      await Promise.all(Array.from({ length: Math.min(concurrency, parts.length) }, async () => {
+        for (let index = next++; index < parts.length; index = next++)
+          results[index] = await request(parts[index]);
+      }));
+      return results.flat();
+    }, "embed"),
+    close: /* @__PURE__ */ __name(async () => {
+    }, "close")
+  };
+}, "openRemote");
+var errorCode = /* @__PURE__ */ __name(async (response) => {
+  try {
+    const body = await response.json();
+    const code = body.error?.code ?? body.error?.type;
+    return typeof code === "string" && /^[\w.-]{1,64}$/.test(code) ? `, ${code}` : "";
+  } catch {
+    return "";
+  }
+}, "errorCode");
+
+export {
+  OPENAI_URL,
+  OPENAI_MODELS,
+  DEFAULT_OPENAI_MODEL,
+  isLocal,
+  remoteModel,
+  remoteKey,
+  openRemote
+};

package/dist/bundle/chunk-6M6FJV5D.js

@@ -0,0 +1,138 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CliError
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/tasks/model.js
+var TASK_KINDS = ["question", "request", "mention", "promise"];
+var TASK_STATES = ["open", "done", "dismissed"];
+var TASK_ORIGINS = ["rule", "agent", "owner"];
+var TASK_VERDICTS = ["useful", "not_useful"];
+function closeTask(task, state, by, at, reason) {
+  if (task.state !== "open")
+    throw new CliError("validation_error", `task ${task.id} is already ${task.state}`, { reason: "task.closed" });
+  const { claimedBy: _by, claimedUntil: _until, ...unclaimed } = task;
+  return { ...unclaimed, state, closedAt: at, closedBy: by, ...reason === void 0 ? {} : { reason } };
+}
+__name(closeTask, "closeTask");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/tasks/service.js
+function createTaskService({ store, now = /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "now"), newId = /* @__PURE__ */ __name(() => crypto.randomUUID(), "newId") }) {
+  async function find(id) {
+    const task = await store.get(id);
+    if (!task)
+      throw new CliError("not_found", `no task ${id}`);
+    return task;
+  }
+  __name(find, "find");
+  return {
+    /**
+     * A rule never makes a second task from a source it has seen, whatever that task's state, so a
+     * dismissed one stays dismissed — nor from a message attached or merged into a task. A person or an agent may
+     * add a task of another kind to it. A task a rule opens goes through the host's duplicate check.
+     */
+    async add(input) {
+      const rule = input.origin === "rule";
+      const existing = await store.findBySource(input.account, input.source, rule ? { linked: true } : void 0);
+      const same = rule ? existing[0] : existing.find((task2) => task2.kind === input.kind);
+      if (same)
+        return { task: same, created: false };
+      const task = { ...input, id: newId(), state: "open", createdAt: now() };
+      await store.insert(task);
+      if (!rule || !store.reviewDuplicates)
+        return { task, created: true };
+      return { task, created: true, review: await store.reviewDuplicates(task.id) };
+    },
+    async close(id, { as, by, reason }) {
+      const task = closeTask(await find(id), as, by, now(), reason);
+      await store.update(task);
+      return task;
+    },
+    list: /* @__PURE__ */ __name((filter = {}) => store.list(filter), "list"),
+    async stats(filter = {}) {
+      const byGroup = /* @__PURE__ */ new Map();
+      for (const task of await store.list(filter))
+        byGroup.set(task.group, [...byGroup.get(task.group) ?? [], task]);
+      return [...byGroup].map(([group, tasks]) => {
+        const open = tasks.filter((task) => task.state === "open");
+        const closeMs = tasks.flatMap((task) => task.closedAt ? [task.closedAt.getTime() - task.createdAt.getTime()] : []);
+        const oldestOpenAt = open.map((task) => task.createdAt).sort((a, b) => a.getTime() - b.getTime())[0];
+        return {
+          group,
+          open: open.length,
+          ...oldestOpenAt ? { oldestOpenAt } : {},
+          ...closeMs.length > 0 ? { medianCloseMs: median(closeMs) } : {}
+        };
+      });
+    }
+  };
+}
+__name(createTaskService, "createTaskService");
+function median(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  const upper = sorted[middle] ?? 0;
+  return sorted.length % 2 === 1 ? upper : ((sorted[middle - 1] ?? 0) + upper) / 2;
+}
+__name(median, "median");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/tasks/store.js
+function matches(task, filter) {
+  return (filter.account === void 0 || task.account === filter.account) && (filter.state === void 0 || task.state === filter.state) && (filter.group === void 0 || task.group === filter.group) && (filter.kind === void 0 || task.kind === filter.kind) && (filter.createdBefore === void 0 || task.createdAt < filter.createdBefore);
+}
+__name(matches, "matches");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/domain/knowledge.js
+var FACT_TYPES = ["fact", "statement", "question", "decision", "promise"];
+var FACT_STATUSES = ["proposed", "accepted", "superseded", "reversed"];
+var MEMORY_KINDS = ["summary", "digest", "preference"];
+var MEMORY_STATUSES = ["proposed", "confirmed", "stale", "superseded"];
+var MEMORY_SCOPES = ["personal", "work"];
+var WORK_TASK_TYPES = ["bug", "feature", "chore"];
+var TASK_TYPES = [...WORK_TASK_TYPES, ...TASK_KINDS];
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/store/sqlite/link-kinds.js
+var LINK_KINDS = [
+  "links-to",
+  "blocked-by",
+  "follow-up-of",
+  "about",
+  "member-of",
+  "labelled",
+  "answered-by",
+  "evidence",
+  "created-from",
+  "duplicate-of",
+  "related-to",
+  "assigned-to",
+  "attached"
+];
+var LINK_ORIGINS = ["file", "owner", "suggested", "message"];
+var LINK_SOURCES = [...LINK_ORIGINS, "calendar"];
+var RELATION_KINDS = ["member-of", "related-to"];
+var linkKind = /* @__PURE__ */ __name((kind) => `'${kind}'`, "linkKind");
+
+export {
+  LINK_KINDS,
+  LINK_ORIGINS,
+  LINK_SOURCES,
+  RELATION_KINDS,
+  linkKind,
+  TASK_KINDS,
+  TASK_STATES,
+  TASK_ORIGINS,
+  TASK_VERDICTS,
+  createTaskService,
+  matches,
+  FACT_TYPES,
+  FACT_STATUSES,
+  MEMORY_KINDS,
+  MEMORY_STATUSES,
+  MEMORY_SCOPES,
+  WORK_TASK_TYPES,
+  TASK_TYPES
+};

package/dist/bundle/chunk-6MX5T6AQ.js

@@ -0,0 +1,17 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  resolvePaths
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// dist/folders.js
+var loginService = /* @__PURE__ */ __name((configDir) => `zoom-cli:${configDir}`, "loginService");
+var zmPaths = /* @__PURE__ */ __name((options = {}) => resolvePaths({ appName: "zm", ...options }), "zmPaths");
+
+export {
+  loginService,
+  zmPaths
+};