@wirecat/mail-cli 0.0.0-stage → 0.1.0

package/dist/bundle/chunk-NPGVOZVK.js

@@ -0,0 +1,2 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);

package/dist/bundle/chunk-OTUOZ33L.js

@@ -0,0 +1,82 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  MAX_SECRET_INPUT,
+  bufferedInput,
+  inputPolicy
+} from "./chunk-CH6RXYAX.js";
+import {
+  CliError
+} from "./chunk-5BVIWP3S.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/terminal/prompt.js
+import { createInterface } from "node:readline";
+import { Writable } from "node:stream";
+var readSecret = /* @__PURE__ */ __name(async (prompt, { input = process.stdin, output = process.stderr, echo = false, signal: givenSignal } = {}) => {
+  const policy = inputPolicy(input);
+  const signals = [givenSignal, policy.signal].filter((one) => one !== void 0);
+  const signal = signals.length ? AbortSignal.any(signals) : void 0;
+  const cancelled = /* @__PURE__ */ __name(() => new CliError("cancelled", "cancelled \u2014 nothing was stored"), "cancelled");
+  if (signal?.aborted)
+    throw cancelled();
+  if (input.isTTY && policy.noInput)
+    throw new CliError("validation_error", "interactive input is disabled \u2014 provide the input through a pipe", {
+      reason: "input.required"
+    });
+  if (!input.isTTY) {
+    return (await bufferedInput(input, {
+      maxBytes: Math.min(policy.maxBytes ?? MAX_SECRET_INPUT, MAX_SECRET_INPUT),
+      ...signal ? { signal } : {}
+    })).toString("utf8").trim();
+  }
+  let muted = false;
+  const shim = new Writable({
+    write(chunk, _encoding, done) {
+      if (!muted)
+        output.write(chunk);
+      done();
+    }
+  });
+  const reader = createInterface({ input, output: shim, terminal: true });
+  const abort = /* @__PURE__ */ __name(() => reader.close(), "abort");
+  let bytes = 0;
+  let inputFailure;
+  const data = /* @__PURE__ */ __name((chunk) => {
+    bytes += Buffer.byteLength(chunk);
+    if (bytes > Math.min(policy.maxBytes ?? MAX_SECRET_INPUT, MAX_SECRET_INPUT)) {
+      inputFailure = new CliError("validation_error", "secret input exceeds its byte limit", {
+        reason: "input.too-large",
+        retryable: false
+      });
+      reader.close();
+    }
+  }, "data");
+  const inputError = /* @__PURE__ */ __name((error) => {
+    inputFailure = error;
+    reader.close();
+  }, "inputError");
+  input.on("data", data).on("error", inputError);
+  try {
+    const answer = await new Promise((resolve, reject) => {
+      const cancel = /* @__PURE__ */ __name(() => reject(inputFailure ?? cancelled()), "cancel");
+      reader.once("SIGINT", cancel);
+      reader.once("close", cancel);
+      signal?.addEventListener("abort", abort, { once: true });
+      reader.question(prompt, resolve);
+      muted = !echo;
+    });
+    return answer.trim();
+  } finally {
+    input.off("data", data).off("error", inputError);
+    signal?.removeEventListener("abort", abort);
+    reader.close();
+    output.write("\n");
+  }
+}, "readSecret");
+
+export {
+  readSecret
+};

package/dist/bundle/chunk-P7P5MNAU.js

@@ -0,0 +1,46 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/executable.js
+import { existsSync } from "node:fs";
+import { win32 } from "node:path";
+var variable = /* @__PURE__ */ __name((env, name) => Object.entries(env).find(([key]) => key.toUpperCase() === name)?.[1], "variable");
+var executableOnPath = /* @__PURE__ */ __name((command, env, platform = process.platform, exists = existsSync) => {
+  if (platform !== "win32" || win32.isAbsolute(command))
+    return command;
+  if (/[\\/]/.test(command))
+    return command;
+  const extensions = win32.extname(command) ? [""] : (variable(env, "PATHEXT") ?? ".EXE;.COM;.CMD;.BAT").split(";").filter((ext) => /^\.[a-z0-9]+$/i.test(ext));
+  for (const entry of (variable(env, "PATH") ?? "").split(";")) {
+    const directory = entry.replace(/^"(.*)"$/, "$1");
+    for (const extension of extensions) {
+      const candidate = win32.join(directory, command + extension);
+      if (exists(candidate))
+        return candidate;
+    }
+  }
+  return command;
+}, "executableOnPath");
+var executableEnvironment = /* @__PURE__ */ __name((env, platform = process.platform) => {
+  if (platform !== "win32")
+    return env;
+  const configured = variable(env, "COMSPEC");
+  const system = variable(env, "SYSTEMROOT");
+  const shell = configured ? configured : system && win32.isAbsolute(system) ? win32.join(system, "System32", "cmd.exe") : void 0;
+  if (!shell)
+    return env;
+  const result = { ...env };
+  for (const key of Object.keys(result))
+    if (key.toUpperCase() === "COMSPEC")
+      delete result[key];
+  result.comspec = shell;
+  return result;
+}, "executableEnvironment");
+
+export {
+  executableOnPath,
+  executableEnvironment
+};

package/dist/bundle/chunk-QLEUNU6G.js

@@ -0,0 +1,537 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  createRenderer,
+  fieldsOf,
+  processStreams,
+  projectFields
+} from "./chunk-J3QXTBD2.js";
+import {
+  CliError,
+  singleLine
+} from "./chunk-5BVIWP3S.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/sends/permissions.js
+var LEVELS = ["deny", "readonly", "ask", "allow"];
+var DANGEROUS = /* @__PURE__ */ new Set(["messages.delete", "bot.messages.delete", "topics.delete", "chats.delete", "chats.clear"]);
+var skipFlagFor = /* @__PURE__ */ __name((key) => DANGEROUS.has(key) ? "--allow-dangerous" : "--yes", "skipFlagFor");
+var DEFAULT_PERMISSIONS = {
+  "messages.delete": "ask",
+  "account.sessions.end": "ask",
+  "bot.messages.delete": "ask",
+  "topics.enable": "ask",
+  "topics.delete": "ask",
+  "chats.delete": "ask",
+  "chats.clear": "ask",
+  // NEED-568: a rule writes to people with nobody typing a command; it waits for the owner's own allow.
+  "replies.send": "deny",
+  // NEED-1662: an agent that changes settings, schedules or recipients could lift its own limits; the owner opts in.
+  "mcp.authority": "deny",
+  // NEED-1663: writes no level stopped before, so MCP could not offer them; over MCP `ask` goes ahead.
+  "store.backup": "ask",
+  "store.restore": "ask",
+  "store.migrate": "ask",
+  "store.repair": "ask",
+  "store.reset": "ask",
+  "store.clear": "ask",
+  "store.decrypt": "ask",
+  "store.copies.delete": "ask",
+  "server.start": "ask",
+  "server.stop": "ask",
+  "server.restart": "ask",
+  "models.download": "ask",
+  "images.models.download": "ask",
+  "schedule.run": "ask",
+  "schedule.exec": "ask",
+  "doctor.reports.create": "ask"
+};
+var KEYED_UNDER_HOUSEKEEPING = new Set(Object.keys(DEFAULT_PERMISSIONS).filter((key) => /^(store|server|models|images|schedule|doctor)\./.test(key)));
+var AUTHORITY_KEY = "mcp.authority";
+var authorityAllowed = /* @__PURE__ */ __name((levels) => {
+  const { level } = levelFor(levels, AUTHORITY_KEY);
+  return level === "allow" || level === "ask";
+}, "authorityAllowed");
+var BOT_API_KEY = "bot.api";
+var isBotApi = /* @__PURE__ */ __name((path) => path[0] === "bot" && path[1] === "api", "isBotApi");
+var botApiAllowed = /* @__PURE__ */ __name((levels) => {
+  const { level } = levelFor(levels, BOT_API_KEY, { ...DEFAULT_PERMISSIONS, [BOT_API_KEY]: "deny" });
+  return level === "allow" || level === "ask";
+}, "botApiAllowed");
+var RESOURCES = [
+  "messages",
+  "drafts",
+  "reactions",
+  "polls",
+  "topics",
+  "chats",
+  "contacts",
+  "account",
+  "bot",
+  "conversations",
+  "tags",
+  "mentions",
+  "search",
+  "searches",
+  "tasks",
+  "replies",
+  "attachments",
+  "stats",
+  "store",
+  "metadata",
+  "mcp",
+  "server",
+  "models",
+  "schedule",
+  "doctor",
+  "images"
+];
+var layerPermissions = /* @__PURE__ */ __name((layers) => {
+  const levels = {};
+  const sources = {};
+  for (const [from, layer] of layers) {
+    const nearer = Object.keys(levels);
+    for (const [key, level] of Object.entries(layer ?? {})) {
+      if (nearer.some((named2) => key === named2 || key.startsWith(`${named2}.`)))
+        continue;
+      levels[key] = level;
+      sources[key] = from;
+    }
+  }
+  return { levels, sources };
+}, "layerPermissions");
+var CEILING_KEY = "*";
+var ALLOWED = { level: "allow", key: null };
+var ORDER = { deny: 0, readonly: 1, ask: 2, allow: 3 };
+var nearest = /* @__PURE__ */ __name((levels, key) => {
+  for (let parts = key.split("."); parts.length > 0; parts = parts.slice(0, -1)) {
+    const named2 = parts.join(".");
+    const level = levels[named2];
+    if (level)
+      return { level, key: named2, depth: parts.length };
+  }
+  return void 0;
+}, "nearest");
+var levelFor = /* @__PURE__ */ __name((permissions, key, defaults = DEFAULT_PERMISSIONS) => {
+  const found = profileLevel(permissions, key, defaults);
+  const ceiling = permissions[CEILING_KEY];
+  return ceiling && ORDER[ceiling] < ORDER[found.level] ? { level: ceiling, key: CEILING_KEY } : found;
+}, "levelFor");
+var profileLevel = /* @__PURE__ */ __name((permissions, key, defaults) => {
+  const own = nearest(permissions, key);
+  const builtIn = nearest(defaults, key);
+  if (!builtIn || own && own.depth >= builtIn.depth)
+    return own ? { level: own.level, key: own.key } : ALLOWED;
+  if (!own || ORDER[builtIn.level] <= ORDER[own.level])
+    return { level: builtIn.level, key: builtIn.key };
+  return { level: own.level, key: own.key };
+}, "profileLevel");
+var CHAT_KEYS = {
+  settings: "chats.update",
+  "requests.accept": "chats.requests.confirm",
+  "requests.decline": "chats.requests.reject",
+  "link.create": "chats.links.create",
+  "link.reset": "chats.links.reset",
+  "link.revoke": "chats.links.remove",
+  "link.update": "chats.links.update"
+};
+var ACCOUNT_KEYS = {
+  "contact-add": "contacts.add",
+  "contact-remove": "contacts.remove",
+  "contact-import": "contacts.import",
+  "contact-rename": "contacts.rename",
+  "contact-block": "contacts.block",
+  "contact-unblock": "contacts.unblock",
+  profile: "account.update",
+  "folder-create": "chats.folders.create",
+  "folder-update": "chats.folders.update",
+  "folder-delete": "chats.folders.delete",
+  "folder-order": "chats.folders.order",
+  "folder-join": "chats.folders.join",
+  "sessions-end": "account.sessions.end",
+  "chat-mute": "chats.mute",
+  "chat-unmute": "chats.unmute",
+  "chat-archive": "chats.archive",
+  "chat-unarchive": "chats.unarchive",
+  "chat-pin": "chats.pin",
+  "chat-unpin": "chats.unpin",
+  "chat-mark-unread": "chats.mark-unread",
+  "message-star": "messages.star",
+  "message-unstar": "messages.unstar",
+  privacy: "account.privacy.set"
+};
+var KIND_KEYS = {
+  message: "messages.send",
+  forward: "messages.forward",
+  edit: "messages.edit",
+  pin: "messages.pin",
+  reaction: "reactions",
+  read: "chats.mark-read",
+  delete: "messages.delete"
+};
+var keyForWrite = /* @__PURE__ */ __name((kind, action) => {
+  if (kind === "chat")
+    return CHAT_KEYS[action] ?? `chats.${action ?? "update"}`;
+  if (kind === "account") {
+    const key = ACCOUNT_KEYS[action];
+    if (!key)
+      throw new Error(`an account change without a known action: ${action}`);
+    return key;
+  }
+  return KIND_KEYS[kind];
+}, "keyForWrite");
+var writeOfKey = /* @__PURE__ */ __name((key) => {
+  const account = Object.entries(ACCOUNT_KEYS).find(([, named2]) => named2 === key)?.[0];
+  if (account)
+    return { kind: "account", action: account };
+  const kind = Object.entries(KIND_KEYS).find(([, named2]) => named2 === key || key.startsWith(`${named2}.`))?.[0];
+  if (kind)
+    return { kind };
+  if (key === "messages.unpin")
+    return { kind: "pin" };
+  if (key.startsWith("chats.")) {
+    const action = Object.entries(CHAT_KEYS).find(([, named2]) => named2 === key)?.[0] ?? key.slice("chats.".length);
+    return { kind: "chat", action };
+  }
+  return {};
+}, "writeOfKey");
+var NAMED_WRITE_KEYS = [
+  "drafts",
+  "store.gaps.repair",
+  "messages.sync-first",
+  "messages.server-search",
+  "messages.press",
+  "chats.start",
+  "chats.app",
+  "stats.messages.counters.sync",
+  "stats.messages.show.sync-first",
+  "stats.messages.top.sync-first",
+  "stats.contacts.top.sync-first",
+  "account.sessions.list",
+  "attachments.extract",
+  "attachments.move",
+  "attachments.update",
+  "bot.callbacks.answer",
+  "bot.chats.action",
+  "bot.chats.admins.add",
+  "bot.chats.admins.remove",
+  "bot.chats.leave",
+  "bot.chats.members.remove",
+  "bot.chats.moderate",
+  "bot.messages.delete",
+  "bot.messages.edit",
+  "bot.messages.pin",
+  "bot.messages.send",
+  "bot.messages.unpin",
+  "chats.admins.add",
+  "chats.admins.remove",
+  "chats.links.create",
+  "chats.links.reset",
+  "chats.links.remove",
+  "chats.links.update",
+  "chats.members.add",
+  "chats.members.remove",
+  "chats.moderate",
+  "conversations.embeddings",
+  "conversations.links",
+  "polls.close",
+  "polls.create",
+  "polls.vote",
+  "searches.clear",
+  "searches.create",
+  "searches.delete",
+  "contacts.aliases.set",
+  "contacts.aliases.remove",
+  "contacts.notes.add",
+  "contacts.notes.edit",
+  "contacts.notes.remove",
+  "tags.rebuild",
+  "metadata.sync",
+  "mentions.rebuild",
+  "mentions.confirm",
+  "mentions.reject",
+  "tags.add",
+  "tags.remove",
+  "tasks.add",
+  "tasks.claim",
+  "tasks.close",
+  "tasks.duplicates.defer",
+  "tasks.duplicates.reject",
+  "tasks.link",
+  "tasks.merge",
+  "tasks.update",
+  "tasks.release",
+  "tasks.scan",
+  "tasks.unmerge",
+  "topics.create",
+  "topics.edit",
+  "topics.enable"
+];
+var WRITE_KEYS = [
+  .../* @__PURE__ */ new Set([
+    ...NAMED_WRITE_KEYS,
+    ...Object.keys(DEFAULT_PERMISSIONS),
+    ...Object.values(KIND_KEYS),
+    ...Object.values(ACCOUNT_KEYS),
+    ...Object.values(CHAT_KEYS)
+  ])
+];
+var HOUSEKEEPING = /* @__PURE__ */ new Set([
+  "help",
+  "guide",
+  "config",
+  "session",
+  "doctor",
+  "commands",
+  "complete",
+  "upgrade",
+  "skill",
+  "models",
+  "server",
+  // What a schedule runs is checked by its own key when it runs; an agent runs read-only.
+  "schedule",
+  "runs",
+  "sends",
+  "recipients",
+  "flood",
+  "mcp",
+  // Its commands read the rules or flip the pause switch; what a rule sends is checked as `replies.send`.
+  "replies"
+]);
+var BOT_HOUSEKEEPING = /* @__PURE__ */ new Set(["auth", "list", "sends", "recipients", "mcp"]);
+var STORE_MAINTENANCE = /* @__PURE__ */ new Set(["info", "check", "copies"]);
+var SHOW_MESSAGES = /* @__PURE__ */ new Set(["inbox", "review", "watch", "serve", "store", "conversations", "projects"]);
+var readKeysForCommand = /* @__PURE__ */ __name((path) => {
+  if (path[0] === "bot")
+    return readKeysForCommand(path.slice(1)).map((key2) => `bot.${key2}`);
+  const key = keyForCommand(path);
+  if (!key)
+    return [];
+  if (path[0] === "attachments" && path[1] === "download")
+    return [key, "messages", "chats"];
+  if (path[0] === "attachments" && (path[1] === "extract" || path[1] === "show"))
+    return [key, "messages"];
+  if (path[0] === "store" && path[1] === "gaps" && path[2] === "repair")
+    return [key, "messages"];
+  if (path[0] === "store" && ["reset", "clear", "decrypt"].includes(path[1] ?? ""))
+    return [key, "messages"];
+  if (path[0] === "search") {
+    if (path[1] === "notes")
+      return [key];
+    if (path[1] === "topics")
+      return [key, "topics"];
+    if (path[1] === "conversations")
+      return [key, "messages", "conversations"];
+    return [key, "messages"];
+  }
+  if (path[0] !== "stats")
+    return [key];
+  const resource = path[1] === "charts" ? "chats" : path[1];
+  return [
+    .../* @__PURE__ */ new Set([
+      key,
+      "messages",
+      ...["chats", "contacts", "tasks"].includes(resource ?? "") ? [resource] : []
+    ])
+  ];
+}, "readKeysForCommand");
+var keyForCommand = /* @__PURE__ */ __name((path) => {
+  if (path.length === 0)
+    return null;
+  const [top, next] = path;
+  if (top === "bot") {
+    if (next === void 0 || BOT_HOUSEKEEPING.has(next))
+      return null;
+    const inner = keyForCommand(path.slice(1));
+    return `bot.${inner ?? path.slice(1).join(".")}`;
+  }
+  if (KEYED_UNDER_HOUSEKEEPING.has(path.join(".")))
+    return path.join(".");
+  if (top === void 0 || HOUSEKEEPING.has(top) || top === "search" && next === "runs")
+    return null;
+  if (top === "images" && next === "models")
+    return null;
+  if (top === "attachments" && (next === "check" || next === "jobs"))
+    return null;
+  if (top === "attachments" && next === "download")
+    return "messages";
+  if (top === "store" && next !== void 0 && STORE_MAINTENANCE.has(next))
+    return null;
+  if (top === "conversations" && next === "links")
+    return path[2] === "rebuild" ? "conversations.links.rebuild" : "conversations.links";
+  if (top === "conversations" && (next === "embeddings" || next === "embed") || top === "images" && next === "embed" || top === "conversations" && next === "rebuild")
+    return "conversations.embeddings";
+  if (top === "attachments" && next === "list" || top === "chats" && next === "documents")
+    return "messages";
+  if (top === "mentions")
+    return next === "rebuild" || next === "confirm" || next === "reject" ? `mentions.${next}` : "messages";
+  if (top === "store" && (next === "gaps" || next === "jobs"))
+    return path.join(".");
+  if (SHOW_MESSAGES.has(top) || top === "contacts" && (next === "context" || next === "prepare" || next === "events"))
+    return "messages";
+  if (RESOURCES.includes(top))
+    return path.join(".");
+  return void 0;
+}, "keyForCommand");
+var RESOURCE_KEY = new RegExp(`^(${RESOURCES.join("|")})(\\.[a-z][a-z-]*)*$`);
+var COMMAND_PATH_KEY = /^[a-z][a-z-]*(\.[a-zA-Z][a-zA-Z-]*)*$/;
+var permissionOverrides = /* @__PURE__ */ __name((entries = [], shape = RESOURCE_KEY) => {
+  const levels = {};
+  const example = shape === RESOURCE_KEY ? "messages.send=allow" : "api=readonly";
+  for (const entry of entries) {
+    const [key = "", level = "", extra] = entry.split("=");
+    if (!shape.test(key) || !LEVELS.includes(level) || extra !== void 0)
+      throw new CliError("validation_error", `--permission takes a command path and level, e.g. ${example} (deny, readonly, ask, allow)`);
+    levels[key] = level;
+  }
+  return levels;
+}, "permissionOverrides");
+var assertOverridesTighten = /* @__PURE__ */ __name((overrides, profile, defaults = DEFAULT_PERMISSIONS) => {
+  for (const [key, level] of Object.entries(overrides)) {
+    const under = Object.keys(profile).filter((named2) => named2.startsWith(`${key}.`));
+    const lifted = [key, ...under].find((named2) => ORDER[level] > ORDER[levelFor(profile, named2, defaults).level]);
+    if (lifted !== void 0)
+      throw new CliError("validation_error", `--permission ${key}=${level} would loosen ${lifted} from ${levelFor(profile, lifted, defaults).level}; it only tightens \u2014 change the profile's permissions to loosen it`, { key, lifted });
+  }
+}, "assertOverridesTighten");
+var assertRetentionEvidenceRead = /* @__PURE__ */ __name((permissions) => {
+  for (const permission of ["stats.chats.retention", "chats"]) {
+    if (levelFor(permissions, permission).level === "deny")
+      throw new CliError("permission_error", `profile denies ${permission}`, { permission });
+  }
+}, "assertRetentionEvidenceRead");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/cli/result-fields.js
+var named = /* @__PURE__ */ __name((work) => {
+  try {
+    return work();
+  } catch (error) {
+    if (error instanceof CliError && error.code === "validation_error")
+      throw new CliError("validation_error", "--json takes comma-separated field paths, for example --json=id,text", {
+        param: "--json"
+      });
+    throw error;
+  }
+}, "named");
+var fieldsOf2 = /* @__PURE__ */ __name((value) => named(() => fieldsOf(value)), "fieldsOf");
+var projectCommands = /* @__PURE__ */ __name((commands, fields) => commands.map((command) => ({
+  ...projectFields(command, fields),
+  path: command.path,
+  name: command.name,
+  origin: command.origin,
+  effects: command.effects,
+  commands: projectCommands(command.commands, fields)
+})), "projectCommands");
+var projectFields2 = /* @__PURE__ */ __name((value, fields) => named(() => {
+  if (value && typeof value === "object" && "cli" in value && typeof value.cli === "string" && "contract" in value && "commands" in value && Array.isArray(value.commands))
+    return { ...value, commands: projectCommands(value.commands, fields) };
+  return projectFields(value, fields);
+}), "projectFields");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/output-detail.js
+var RARELY_SET = ["editedAt", "replyTo", "forwardedFrom", "reactions"];
+var BRIEF = ["locator", "chatTitle", "timestamp", "senderName", "excerpt", "score"];
+var isHit = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && typeof value.locator === "string" && typeof value.text === "string", "isHit");
+var shaped = /* @__PURE__ */ __name((hit, detail) => {
+  if (detail === "brief")
+    return Object.fromEntries(BRIEF.flatMap((key) => hit[key] === void 0 || hit[key] === null ? [] : [[key, hit[key]]]));
+  const { text, providerMetadata, ...rest } = hit;
+  for (const key of RARELY_SET)
+    if (rest[key] === null)
+      delete rest[key];
+  const metadata = rest.email ? void 0 : providerMetadata;
+  return {
+    ...rest,
+    ...typeof rest.excerpt === "string" ? {} : { text },
+    ...metadata === void 0 ? {} : { providerMetadata: metadata }
+  };
+}, "shaped");
+var atDetail = /* @__PURE__ */ __name((value, detail = "default") => {
+  if (detail === "full")
+    return value;
+  if (Array.isArray(value))
+    return value.map((item) => isHit(item) ? shaped(item, detail) : item);
+  if (isHit(value))
+    return shaped(value, detail);
+  if (typeof value === "object" && value !== null && Array.isArray(value.items))
+    return { ...value, items: atDetail(value.items, detail) };
+  return value;
+}, "atDetail");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/output.js
+var resolveOutput = /* @__PURE__ */ __name(({ json, jsonl, quiet, streams = processStreams, tty, color, fields, hitDetail, env = process.env, capture } = {}) => {
+  const interactive = tty ?? process.stdout.isTTY === true;
+  const format = jsonl ? "jsonl" : json || !interactive ? "json" : "pretty";
+  const painted = format === "pretty" && (color ?? (env.NO_COLOR === void 0 && env.TERM !== "dumb" && !env.CI));
+  const printing = createRenderer({ format, color: painted, streams });
+  const rendered = capture ? { ...printing, result: capture, stream: /* @__PURE__ */ __name((items) => capture([...items]), "stream") } : printing;
+  const level = hitDetail ?? (fields === void 0 ? "default" : "full");
+  const standard = format === "pretty" ? rendered : {
+    ...rendered,
+    result: /* @__PURE__ */ __name((value) => rendered.result(atDetail(value, level)), "result"),
+    stream: /* @__PURE__ */ __name((items) => rendered.stream(atDetail([...items], level)), "stream")
+  };
+  const created = standard;
+  const paths = fields === void 0 ? void 0 : fieldsOf2(fields);
+  const renderer = format === "pretty" ? oneLineFields(created) : paths ? {
+    ...created,
+    result: /* @__PURE__ */ __name((value) => created.result(projectFields2(value, paths)), "result"),
+    stream: /* @__PURE__ */ __name((items) => created.stream([...items].map((item) => projectFields2(item, paths))), "stream")
+  } : created;
+  return { format, color: painted, streams, renderer: quiet ? silence(renderer) : renderer };
+}, "resolveOutput");
+var MULTI_LINE = /* @__PURE__ */ new Set(["text", "description"]);
+var oneLineFields = /* @__PURE__ */ __name((renderer) => ({
+  ...renderer,
+  result: /* @__PURE__ */ __name((value) => renderer.result(oneLine(value)), "result"),
+  stream: /* @__PURE__ */ __name((items) => renderer.stream([...items].map((item) => oneLine(item))), "stream")
+}), "oneLineFields");
+var oneLine = /* @__PURE__ */ __name((value, key) => {
+  if (typeof value === "string")
+    return key !== void 0 && MULTI_LINE.has(key) ? value : singleLine(value);
+  if (Array.isArray(value))
+    return value.map((item) => oneLine(item, key));
+  if (value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    return Object.fromEntries(Object.entries(value).map(([field, item]) => [field, oneLine(item, field)]));
+  }
+  return value;
+}, "oneLine");
+var silence = /* @__PURE__ */ __name((renderer) => ({
+  ...renderer,
+  note: /* @__PURE__ */ __name(() => {
+  }, "note"),
+  success: /* @__PURE__ */ __name(() => {
+  }, "success"),
+  warn: /* @__PURE__ */ __name(() => {
+  }, "warn")
+}), "silence");
+
+export {
+  LEVELS,
+  skipFlagFor,
+  DEFAULT_PERMISSIONS,
+  AUTHORITY_KEY,
+  authorityAllowed,
+  BOT_API_KEY,
+  isBotApi,
+  botApiAllowed,
+  RESOURCES,
+  layerPermissions,
+  CEILING_KEY,
+  levelFor,
+  keyForWrite,
+  writeOfKey,
+  WRITE_KEYS,
+  readKeysForCommand,
+  keyForCommand,
+  RESOURCE_KEY,
+  COMMAND_PATH_KEY,
+  permissionOverrides,
+  assertOverridesTighten,
+  assertRetentionEvidenceRead,
+  fieldsOf2 as fieldsOf,
+  projectFields2 as projectFields,
+  resolveOutput
+};