@struktoai/mirage-node 0.0.3 → 0.0.5-alpha.1

package/dist/chunk-TWRQCQWU.js

@@ -0,0 +1,1153 @@
+import {
+  redactEmailConfig
+} from "./chunk-CRC4YWXB.js";
+
+// src/resource/email/email.ts
+import {
+  BaseResource,
+  PathSpec as PathSpec2,
+  ResourceName as ResourceName6,
+  makeResolveGlob,
+  mountKey as mountKey3,
+  mountPrefixOf as mountPrefixOf6
+} from "@struktoai/mirage-core";
+
+// src/accessor/email.ts
+import { Accessor, loadOptionalPeer } from "@struktoai/mirage-core";
+var EmailAccessor = class extends Accessor {
+  config;
+  clientPromise = null;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  async getImap() {
+    this.clientPromise ??= (async () => {
+      const mod = await loadOptionalPeer(
+        () => import("imapflow"),
+        { feature: "EmailAccessor", packageName: "imapflow" }
+      );
+      const client = new mod.ImapFlow({
+        host: this.config.imapHost,
+        port: this.config.imapPort,
+        secure: this.config.useSsl,
+        auth: { user: this.config.username, pass: this.config.password },
+        logger: false
+      });
+      await client.connect();
+      return client;
+    })();
+    try {
+      return await this.clientPromise;
+    } catch (err) {
+      this.clientPromise = null;
+      throw err;
+    }
+  }
+  async close() {
+    if (this.clientPromise === null) return;
+    try {
+      const c = await this.clientPromise;
+      await c.logout();
+    } catch {
+    }
+    this.clientPromise = null;
+  }
+};
+
+// src/commands/builtin/email/index.ts
+import { ResourceName as ResourceName4, makeGenericCommands } from "@struktoai/mirage-core";
+
+// src/commands/builtin/email/find.ts
+import {
+  ResourceName,
+  command,
+  findGeneric,
+  resolveGlobOf,
+  specOf,
+  walkFind
+} from "@struktoai/mirage-core";
+
+// src/core/email/readdir.ts
+import {
+  enoent,
+  IndexEntry,
+  PathSpec as PathSpecCtor,
+  mountKey,
+  mountPrefixOf,
+  compareCodePoints
+} from "@struktoai/mirage-core";
+
+// src/core/email/_parse.ts
+import { loadOptionalPeer as loadOptionalPeer2 } from "@struktoai/mirage-core";
+var parserPromise = null;
+async function getParser() {
+  parserPromise ??= (async () => {
+    const mod = await loadOptionalPeer2(
+      () => import("mailparser"),
+      { feature: "parseRfc822", packageName: "mailparser" }
+    );
+    return mod.simpleParser;
+  })();
+  return parserPromise;
+}
+function toAddr(a) {
+  if (a === void 0) return { name: "", email: "" };
+  return { name: a.name, email: a.address ?? "" };
+}
+function toAddrList(list) {
+  if (list === void 0) return [];
+  const objs = Array.isArray(list) ? list : [list];
+  return objs.flatMap((obj) => obj.value.map((a) => toAddr(a)));
+}
+function rawDateHeader(parsed) {
+  const found = parsed.headerLines.find((h) => h.key === "date");
+  if (found === void 0) return "";
+  const colon = found.line.indexOf(":");
+  return colon === -1 ? "" : found.line.slice(colon + 1).trim();
+}
+function fromParsed(parsed, headersOnly) {
+  const text = headersOnly ? "" : parsed.text ?? "";
+  const html = headersOnly ? "" : typeof parsed.html === "string" ? parsed.html : "";
+  const attachments = headersOnly ? [] : parsed.attachments.map((a) => ({
+    filename: a.filename ?? "unnamed",
+    content_type: a.contentType,
+    size: a.size
+  }));
+  const refsRaw = parsed.references;
+  const references = typeof refsRaw === "string" ? refsRaw.split(/\s+/).filter((s) => s !== "") : refsRaw ?? [];
+  return {
+    from: toAddr(parsed.from?.value[0]),
+    reply_to: toAddrList(parsed.replyTo),
+    to: toAddrList(parsed.to),
+    cc: toAddrList(parsed.cc),
+    subject: parsed.subject ?? "",
+    date: rawDateHeader(parsed),
+    body_text: text,
+    body_html: html,
+    snippet: text.slice(0, 100),
+    message_id: parsed.messageId ?? "",
+    in_reply_to: typeof parsed.inReplyTo === "string" && parsed.inReplyTo !== "" ? parsed.inReplyTo : null,
+    references,
+    has_attachments: attachments.length > 0,
+    attachments
+  };
+}
+async function parseRfc822(raw, headersOnly = false) {
+  const parser = await getParser();
+  const parsed = await parser(Buffer.from(raw), { skipHtmlToText: false });
+  return fromParsed(parsed, headersOnly);
+}
+async function parseWithPayloads(raw) {
+  const parser = await getParser();
+  const parsed = await parser(Buffer.from(raw));
+  return parsed.attachments.map((a) => ({
+    filename: a.filename ?? "unnamed",
+    content_type: a.contentType,
+    size: a.size,
+    payload: new Uint8Array(a.content)
+  }));
+}
+
+// src/core/email/_client.ts
+function internalDateOf(value) {
+  if (value === void 0) return "";
+  if (typeof value === "string") return value;
+  return value.toISOString();
+}
+async function listFolderEntries(accessor) {
+  const imap = await accessor.getImap();
+  const tree = await imap.list();
+  return tree.map((m) => ({ name: m.pathAsListed, specialUse: m.specialUse ?? null }));
+}
+async function listFolders(accessor) {
+  return (await listFolderEntries(accessor)).map((entry) => entry.name);
+}
+async function lockMailbox(imap, folder) {
+  try {
+    return await imap.getMailboxLock(folder);
+  } catch (error) {
+    const answered = error.responseText !== void 0;
+    if (answered) throw new Error(`no such mailbox '${folder}'`);
+    throw error;
+  }
+}
+async function listMessageUids(accessor, folder, searchCriteria = "ALL", maxResults = null) {
+  const imap = await accessor.getImap();
+  const lock = await lockMailbox(imap, folder);
+  try {
+    const query = parseSearchCriteria(searchCriteria);
+    const uidsRaw = await imap.search(query, { uid: true });
+    if (uidsRaw === false) throw new Error(`IMAP rejected the search: ${searchCriteria}`);
+    const uids = uidsRaw.map((n) => String(n));
+    if (maxResults !== null && uids.length > maxResults) {
+      return uids.slice(uids.length - maxResults);
+    }
+    return uids;
+  } finally {
+    lock.release();
+  }
+}
+var FLAG_KEYS = {
+  SEEN: "seen",
+  ANSWERED: "answered",
+  FLAGGED: "flagged",
+  DRAFT: "draft",
+  DELETED: "deleted"
+};
+var TEXT_KEYS = {
+  BODY: "body",
+  TEXT: "text",
+  SUBJECT: "subject",
+  FROM: "from",
+  TO: "to"
+};
+var DATE_KEYS = {
+  ON: "on",
+  SINCE: "since",
+  BEFORE: "before",
+  SENTON: "sentOn",
+  SENTSINCE: "sentSince",
+  SENTBEFORE: "sentBefore"
+};
+function andQueries(left, right) {
+  const collides = Object.keys(right).some((key) => key in left);
+  if (!collides) return { ...left, ...right };
+  return { not: { or: [{ not: left }, { not: right }] } };
+}
+var CriteriaParser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  tokens;
+  index = 0;
+  peek() {
+    return this.tokens[this.index];
+  }
+  take() {
+    const token = this.peek();
+    if (token === void 0) throw new Error("email: truncated IMAP search criteria");
+    this.index += 1;
+    return token;
+  }
+  atEnd() {
+    return this.index >= this.tokens.length;
+  }
+  /** One or more keys juxtaposed, which IMAP reads as AND. */
+  parseSequence(stopAtParen = false) {
+    let query = null;
+    while (!this.atEnd()) {
+      if (stopAtParen && this.peek() === ")") break;
+      const next = this.parseKey();
+      query = query === null ? next : andQueries(query, next);
+    }
+    return query ?? { all: true };
+  }
+  parseKey() {
+    const token = this.take();
+    if (token === "(") {
+      const inner = this.parseSequence(true);
+      if (this.peek() !== ")") throw new Error("email: unbalanced IMAP search criteria");
+      this.index += 1;
+      return inner;
+    }
+    const word = token.toUpperCase();
+    if (word === "ALL") return { all: true };
+    if (word === "NOT") return { not: this.parseKey() };
+    if (word === "OR") return { or: [this.parseKey(), this.parseKey()] };
+    if (word === "UNSEEN") return { seen: false };
+    const flag = FLAG_KEYS[word];
+    if (flag !== void 0) return { [flag]: true };
+    const textKey = TEXT_KEYS[word];
+    if (textKey !== void 0) return { [textKey]: this.take() };
+    const dateKey = DATE_KEYS[word];
+    if (dateKey !== void 0) {
+      const parsed = parseImapDate(this.take());
+      if (parsed === null) throw new Error(`email: bad date in IMAP search criteria: ${token}`);
+      return { [dateKey]: parsed };
+    }
+    throw new Error(`email: unsupported IMAP search key '${token}'`);
+  }
+};
+function parseSearchCriteria(criteria) {
+  if (criteria === "ALL" || criteria === "") return { all: true };
+  return new CriteriaParser(tokenizeCriteria(criteria)).parseSequence();
+}
+function tokenizeCriteria(criteria) {
+  const tokens = [];
+  let i = 0;
+  while (i < criteria.length) {
+    const char = criteria.charAt(i);
+    if (char === " ") {
+      i += 1;
+      continue;
+    }
+    if (char === "(" || char === ")") {
+      tokens.push(char);
+      i += 1;
+      continue;
+    }
+    if (char === '"') {
+      let value = "";
+      let j = i + 1;
+      while (j < criteria.length && criteria.charAt(j) !== '"') {
+        if (criteria.charAt(j) === "\\" && j + 1 < criteria.length) j += 1;
+        value += criteria.charAt(j);
+        j += 1;
+      }
+      tokens.push(value);
+      i = j + 1;
+      continue;
+    }
+    let end = i;
+    while (end < criteria.length && !" ()".includes(criteria.charAt(end))) end += 1;
+    tokens.push(criteria.slice(i, end));
+    i = end;
+  }
+  return tokens;
+}
+function parseImapDate(s) {
+  const m = /^(\d{1,2})-([A-Za-z]{3})-(\d{4})$/.exec(s);
+  if (m === null) return null;
+  const months = {
+    Jan: 0,
+    Feb: 1,
+    Mar: 2,
+    Apr: 3,
+    May: 4,
+    Jun: 5,
+    Jul: 6,
+    Aug: 7,
+    Sep: 8,
+    Oct: 9,
+    Nov: 10,
+    Dec: 11
+  };
+  const day = Number.parseInt(m[1] ?? "0", 10);
+  const monKey = (m[2] ?? "").slice(0, 1).toUpperCase() + (m[2] ?? "").slice(1).toLowerCase();
+  const mon = months[monKey];
+  const year = Number.parseInt(m[3] ?? "1970", 10);
+  if (mon === void 0) return null;
+  const value = new Date(Date.UTC(year, mon, day));
+  if (value.getUTCMonth() !== mon || value.getUTCDate() !== day) return null;
+  return value;
+}
+async function fetchRawMessage(accessor, folder, uid) {
+  const imap = await accessor.getImap();
+  const lock = await lockMailbox(imap, folder);
+  try {
+    const msg = await imap.fetchOne(uid, { source: true, uid: true }, { uid: true });
+    if (msg === false) {
+      throw new Error(`email: uid ${uid} not found in ${folder}`);
+    }
+    return msg.source instanceof Buffer ? new Uint8Array(msg.source) : new Uint8Array(0);
+  } finally {
+    lock.release();
+  }
+}
+async function fetchMessage(accessor, folder, uid) {
+  const imap = await accessor.getImap();
+  const lock = await lockMailbox(imap, folder);
+  try {
+    const msg = await imap.fetchOne(
+      uid,
+      { source: true, flags: true, uid: true, internalDate: true },
+      { uid: true }
+    );
+    if (msg === false) {
+      throw new Error(`email: uid ${uid} not found in ${folder}`);
+    }
+    const source = msg.source instanceof Buffer ? new Uint8Array(msg.source) : new Uint8Array(0);
+    const parsed = await parseRfc822(source);
+    return {
+      ...parsed,
+      uid,
+      flags: msg.flags !== void 0 ? [...msg.flags] : [],
+      internalDate: internalDateOf(msg.internalDate)
+    };
+  } finally {
+    lock.release();
+  }
+}
+async function fetchHeaders(accessor, folder, uids) {
+  if (uids.length === 0) return [];
+  const imap = await accessor.getImap();
+  const lock = await lockMailbox(imap, folder);
+  try {
+    const results = [];
+    for (const uid of uids) {
+      const msg = await imap.fetchOne(
+        uid,
+        { source: true, flags: true, uid: true, internalDate: true },
+        { uid: true }
+      );
+      if (msg === false) continue;
+      const source = msg.source instanceof Buffer ? new Uint8Array(msg.source) : new Uint8Array(0);
+      const parsed = await parseRfc822(source);
+      results.push({
+        ...parsed,
+        uid,
+        flags: msg.flags !== void 0 ? [...msg.flags] : [],
+        internalDate: internalDateOf(msg.internalDate)
+      });
+    }
+    return results;
+  } finally {
+    lock.release();
+  }
+}
+async function fetchAttachment(accessor, folder, uid, filename) {
+  const imap = await accessor.getImap();
+  const lock = await lockMailbox(imap, folder);
+  try {
+    const msg = await imap.fetchOne(uid, { source: true }, { uid: true });
+    if (msg === false) return null;
+    const source = msg.source instanceof Buffer ? new Uint8Array(msg.source) : new Uint8Array(0);
+    const attachments = await parseWithPayloads(source);
+    for (const att of attachments) {
+      if (att.filename === filename) return att.payload;
+    }
+    return null;
+  } finally {
+    lock.release();
+  }
+}
+
+// src/core/email/folders.ts
+async function listFolders2(accessor) {
+  return listFolders(accessor);
+}
+
+// src/core/email/render.ts
+var encoder = new TextEncoder();
+function messageDocument(message) {
+  const body = { ...message };
+  delete body.internalDate;
+  return body;
+}
+function messageJsonText(message) {
+  return JSON.stringify(messageDocument(message));
+}
+function messageJsonBytes(message) {
+  return encoder.encode(messageJsonText(message));
+}
+function messagesJsonBytes(messages) {
+  return encoder.encode(JSON.stringify(messages.map((m) => messageDocument(m))));
+}
+
+// src/core/email/readdir.ts
+var TITLE_MAX = 80;
+var UNSAFE = /[^\w\s\-.]/g;
+var MULTI_UNDERSCORE = /_+/g;
+var EPOCH_DATE = "1970-01-01";
+function sanitize(text) {
+  if (text.trim() === "") return "No_Subject";
+  let cleaned = text.replace(UNSAFE, "_").replace(/ /g, "_");
+  cleaned = cleaned.replace(MULTI_UNDERSCORE, "_").replace(/^_+|_+$/g, "");
+  if (cleaned.length > TITLE_MAX) cleaned = `${cleaned.slice(0, TITLE_MAX - 3)}...`;
+  return cleaned;
+}
+function msgFilename(subject, uid) {
+  return `${sanitize(subject)}__${uid}.email.json`;
+}
+var NAMED_ZONES = {
+  UT: 0,
+  UTC: 0,
+  GMT: 0,
+  Z: 0,
+  EST: -300,
+  EDT: -240,
+  CST: -360,
+  CDT: -300,
+  MST: -420,
+  MDT: -360,
+  PST: -480,
+  PDT: -420
+};
+function statedOffset(value) {
+  const numeric = /([+-])(\d{2}):?(\d{2})\s*$/.exec(value);
+  if (numeric !== null) {
+    const sign = numeric[1] === "-" ? -1 : 1;
+    return sign * (Number(numeric[2]) * 60 + Number(numeric[3]));
+  }
+  const named = /([A-Z]{1,3})\s*$/.exec(value.toUpperCase());
+  return NAMED_ZONES[named?.[1] ?? ""] ?? null;
+}
+function ymd(year, month, day) {
+  return `${year.toString().padStart(4, "0")}-${month.toString().padStart(2, "0")}-${day.toString().padStart(2, "0")}`;
+}
+function parseDate(value) {
+  if (value.trim() === "") return null;
+  const d = new Date(value);
+  if (Number.isNaN(d.getTime())) return null;
+  const offset = statedOffset(value);
+  if (offset === null) return ymd(d.getFullYear(), d.getMonth() + 1, d.getDate());
+  const shifted = new Date(d.getTime() + offset * 6e4);
+  return ymd(shifted.getUTCFullYear(), shifted.getUTCMonth() + 1, shifted.getUTCDate());
+}
+function dateBucket(message) {
+  return parseDate(message.date) ?? parseDate(message.internalDate) ?? EPOCH_DATE;
+}
+async function readdir(accessor, path, index) {
+  const prefix = mountPrefixOf(path.virtual, path.resourcePath);
+  const key = (path.pattern !== null ? path.dir : path).resourcePath;
+  const virtualKey = key !== "" ? `${prefix}/${key}` : prefix !== "" ? prefix : "/";
+  const parts = key === "" ? [] : key.split("/");
+  const depth = parts.length;
+  if (depth === 0) {
+    if (index !== void 0) {
+      const cached = await index.listDir(virtualKey);
+      if (cached.entries !== void 0 && cached.entries !== null) return cached.entries;
+    }
+    const folders = await listFolders2(accessor);
+    const entries = [];
+    for (const folderName of folders) {
+      const entry = new IndexEntry({
+        id: folderName,
+        name: folderName,
+        resourceType: "email/folder",
+        vfsName: folderName
+      });
+      entries.push([folderName, entry]);
+    }
+    if (index !== void 0) await index.setDir(virtualKey, entries);
+    return entries.map(([name]) => `${prefix}/${name}`);
+  }
+  if (depth === 1) {
+    const folderName = parts[0] ?? "";
+    if (index !== void 0) {
+      const cached = await index.listDir(virtualKey);
+      if (cached.entries !== void 0 && cached.entries !== null) return cached.entries;
+    }
+    if (index === void 0) throw enoent(path.virtual);
+    if (!(await listFolders2(accessor)).includes(folderName)) throw enoent(path.virtual);
+    const maxMessages = accessor.config.maxMessages;
+    const uids = await listMessageUids(accessor, folderName, "ALL", maxMessages);
+    const headersList = await fetchHeaders(accessor, folderName, uids);
+    const dateGroups = /* @__PURE__ */ new Map();
+    for (const hdr of headersList) {
+      const dateStr = dateBucket(hdr);
+      let bucket = dateGroups.get(dateStr);
+      if (bucket === void 0) {
+        bucket = [];
+        dateGroups.set(dateStr, bucket);
+      }
+      bucket.push(hdr);
+    }
+    const sortedDates = [...dateGroups.keys()].sort(compareCodePoints).reverse();
+    const dateEntries = [];
+    for (const dateStr of sortedDates) {
+      const dateEntry = new IndexEntry({
+        id: dateStr,
+        name: dateStr,
+        resourceType: "email/date",
+        vfsName: dateStr
+      });
+      dateEntries.push([dateStr, dateEntry]);
+      const msgEntries = [];
+      for (const hdr of dateGroups.get(dateStr) ?? []) {
+        const uid = hdr.uid;
+        const subject = hdr.subject || "No Subject";
+        const filename = msgFilename(subject, uid);
+        const msgEntry = new IndexEntry({
+          id: uid,
+          name: subject,
+          resourceType: "email/message",
+          vfsName: filename,
+          size: messageJsonBytes(hdr).byteLength
+        });
+        msgEntries.push([filename, msgEntry]);
+        const attachments = hdr.attachments;
+        if (attachments.length > 0) {
+          const attDirName = filename.replace(".email.json", "");
+          const attDirEntry = new IndexEntry({
+            id: uid,
+            name: attDirName,
+            resourceType: "email/attachment_dir",
+            vfsName: attDirName
+          });
+          msgEntries.push([attDirName, attDirEntry]);
+          const attEntries = [];
+          for (const att of attachments) {
+            const attEntry = new IndexEntry({
+              id: att.filename,
+              name: att.filename,
+              resourceType: "email/attachment",
+              vfsName: att.filename,
+              size: att.size
+            });
+            attEntries.push([att.filename, attEntry]);
+          }
+          const attDirVKey = `${virtualKey}/${dateStr}/${attDirName}`;
+          await index.setDir(attDirVKey, attEntries);
+        }
+      }
+      const dateVKey = `${virtualKey}/${dateStr}`;
+      await index.setDir(dateVKey, msgEntries);
+    }
+    await index.setDir(virtualKey, dateEntries);
+    return dateEntries.map(([name]) => `${prefix}/${key}/${name}`);
+  }
+  if (depth === 2 || depth === 3) {
+    if (index === void 0) throw enoent(path.virtual);
+    let cached = await index.listDir(virtualKey);
+    if (cached.entries !== void 0 && cached.entries !== null) return cached.entries;
+    const folderPath = prefix !== "" ? `${prefix}/${parts[0] ?? ""}` : `/${parts[0] ?? ""}`;
+    const folderSpec = new PathSpecCtor({
+      virtual: folderPath,
+      directory: folderPath,
+      resourcePath: mountKey(folderPath, prefix)
+    });
+    await readdir(accessor, folderSpec, index);
+    cached = await index.listDir(virtualKey);
+    if (cached.entries !== void 0 && cached.entries !== null) return cached.entries;
+    throw enoent(path.virtual);
+  }
+  throw enoent(path.virtual);
+}
+
+// src/core/email/stat.ts
+import {
+  FileStat,
+  FileType,
+  PathSpec,
+  enoent as enoent2,
+  guessType,
+  mountKey as mountKey2,
+  mountPrefixOf as mountPrefixOf2
+} from "@struktoai/mirage-core";
+async function stat(accessor, path, index) {
+  const prefix = mountPrefixOf2(path.virtual, path.resourcePath);
+  const key = path.resourcePath;
+  if (key === "") return new FileStat({ name: "/", type: FileType.DIRECTORY });
+  if (index === void 0) throw enoent2(path.virtual);
+  const virtualKey = prefix !== "" ? `${prefix}/${key}` : `/${key}`;
+  let result = await index.get(virtualKey);
+  if (result.entry === void 0 || result.entry === null) {
+    if (!key.includes("/")) {
+      const folders = await listFolders2(accessor);
+      if (folders.includes(key)) return new FileStat({ name: key, type: FileType.DIRECTORY });
+      throw enoent2(path.virtual);
+    }
+    const parentVirtual = virtualKey.slice(0, virtualKey.lastIndexOf("/")) || "/";
+    try {
+      await readdir(
+        accessor,
+        new PathSpec({
+          virtual: parentVirtual,
+          directory: parentVirtual,
+          resolved: false,
+          resourcePath: mountKey2(parentVirtual, prefix)
+        }),
+        index
+      );
+    } catch {
+      throw enoent2(path.virtual);
+    }
+    result = await index.get(virtualKey);
+    if (result.entry === void 0 || result.entry === null) throw enoent2(path.virtual);
+  }
+  const rt = result.entry.resourceType;
+  const vfsName = result.entry.vfsName !== "" ? result.entry.vfsName : result.entry.name;
+  if (rt === "email/folder") return new FileStat({ name: vfsName, type: FileType.DIRECTORY });
+  if (rt === "email/date") return new FileStat({ name: vfsName, type: FileType.DIRECTORY });
+  if (rt === "email/message") {
+    return new FileStat({
+      name: vfsName,
+      type: FileType.JSON,
+      size: result.entry.size,
+      extra: { uid: result.entry.id }
+    });
+  }
+  if (rt === "email/attachment_dir") {
+    return new FileStat({
+      name: vfsName,
+      type: FileType.DIRECTORY,
+      extra: { uid: result.entry.id }
+    });
+  }
+  if (rt === "email/attachment") {
+    return new FileStat({
+      name: vfsName,
+      type: guessType(vfsName),
+      size: result.entry.size,
+      extra: { attachment_id: result.entry.id }
+    });
+  }
+  return new FileStat({ name: vfsName, type: FileType.JSON, extra: { uid: result.entry.id } });
+}
+
+// src/core/email/read.ts
+import { eisdir, enoent as enoent3, gnuDirname, mountPrefixOf as mountPrefixOf3, stripSlash } from "@struktoai/mirage-core";
+async function read(accessor, path, index) {
+  const prefix = mountPrefixOf3(path.virtual, path.resourcePath);
+  const key = path.resourcePath;
+  if (index === void 0) throw enoent3(path.virtual);
+  const virtualKey = prefix !== "" ? `${prefix}/${key}` : `/${key}`;
+  const result = await index.get(virtualKey);
+  if (result.entry === void 0 || result.entry === null) throw enoent3(path.virtual);
+  const rt = result.entry.resourceType;
+  if (rt === "email/folder" || rt === "email/date" || rt === "email/attachment_dir") {
+    throw eisdir(path.virtual);
+  }
+  if (rt === "email/attachment") {
+    const parentKey = gnuDirname(virtualKey);
+    const parentResult = await index.get(parentKey);
+    if (parentResult.entry === void 0 || parentResult.entry === null) {
+      throw enoent3(path.virtual);
+    }
+    const uid2 = parentResult.entry.id;
+    const parts2 = stripSlash(virtualKey).split("/");
+    const folder2 = prefix !== "" ? parts2[1] ?? "" : parts2[0] ?? "";
+    const filename = result.entry.vfsName !== "" ? result.entry.vfsName : result.entry.name;
+    const data = await fetchAttachment(accessor, folder2, uid2, filename);
+    if (data === null) throw enoent3(path.virtual);
+    return data;
+  }
+  const parts = stripSlash(virtualKey).split("/");
+  const folder = prefix !== "" ? parts[1] ?? "" : parts[0] ?? "";
+  const uid = result.entry.id;
+  const msg = await fetchMessage(accessor, folder, uid);
+  return messageJsonBytes(msg);
+}
+
+// src/commands/builtin/email/io.ts
+async function* emailReadStream(accessor, path, index) {
+  yield await read(accessor, path, index);
+}
+var EMAIL_IO = {
+  readdir,
+  readBytes: read,
+  readStream: emailReadStream,
+  stat,
+  isMounted: () => true,
+  local: false
+};
+
+// src/commands/builtin/email/provision.ts
+import {
+  Precision,
+  ProvisionResult
+} from "@struktoai/mirage-core";
+async function fileReadProvision(_accessor, paths, _texts, opts) {
+  if (paths.length === 0) return new ProvisionResult({ precision: Precision.UNKNOWN });
+  const index = opts.index ?? void 0;
+  let ops = 0;
+  if (index !== void 0) {
+    for (const p of paths) {
+      const lookup = await index.get(p.virtual);
+      if (lookup.entry !== void 0 && lookup.entry !== null) ops += 1;
+    }
+  }
+  return new ProvisionResult({
+    networkReadLow: 0,
+    networkReadHigh: 0,
+    readOps: ops,
+    precision: Precision.EXACT
+  });
+}
+function metadataProvision(_accessor, _paths, _texts, _opts) {
+  return new ProvisionResult({
+    networkReadLow: 0,
+    networkReadHigh: 0,
+    readOps: 0,
+    precision: Precision.EXACT
+  });
+}
+
+// src/commands/builtin/email/find.ts
+var resolveGlob = resolveGlobOf(EMAIL_IO);
+async function findCommand(accessor, paths, texts, opts) {
+  const idx = opts.index ?? void 0;
+  const resolved = await resolveGlob(accessor, paths, idx);
+  const dirEmpty = async (spec) => (await readdir(accessor, spec, idx)).length === 0;
+  return findGeneric(
+    resolved,
+    texts,
+    opts,
+    (root, options) => walkFind(
+      root,
+      {
+        readdir: (spec, i) => readdir(accessor, spec, i),
+        stat: async (spec, i) => {
+          const st = await stat(accessor, spec, i);
+          const overlay = opts.ns?.statOverlay;
+          return overlay !== void 0 ? overlay(spec.virtual, st) : st;
+        },
+        links: opts.ns?.links ?? null
+      },
+      options,
+      idx
+    ),
+    void 0,
+    dirEmpty
+  );
+}
+var EMAIL_FIND = command({
+  name: "find",
+  resource: ResourceName.EMAIL,
+  spec: specOf("find"),
+  fn: findCommand,
+  provision: metadataProvision
+});
+
+// src/commands/builtin/email/grep.ts
+import {
+  IOResult,
+  ResourceName as ResourceName2,
+  command as command2,
+  compilePattern,
+  grepGeneric,
+  grepLines,
+  mountPrefixOf as mountPrefixOf4,
+  prefixAggregate,
+  resolveGlobOf as resolveGlobOf2,
+  specOf as specOf2
+} from "@struktoai/mirage-core";
+
+// src/core/email/scope.ts
+import { stripSlash as stripSlash2 } from "@struktoai/mirage-core";
+function detectScope(path) {
+  const key = stripSlash2(path.mountPath);
+  if (key === "") {
+    return { useNative: false, folder: null, resourcePath: "/" };
+  }
+  const parts = key.split("/").filter((s) => s !== "");
+  if (parts.length === 0) {
+    return { useNative: false, folder: null, resourcePath: "/" };
+  }
+  if (key.endsWith(".email.json")) {
+    return { useNative: false, folder: parts[0] ?? null, resourcePath: key };
+  }
+  if (parts.length <= 2) {
+    return { useNative: true, folder: parts[0] ?? null, resourcePath: key };
+  }
+  return { useNative: false, folder: parts[0] ?? null, resourcePath: key };
+}
+
+// src/core/email/search.ts
+function buildSearchCriteria(opts) {
+  const parts = [];
+  if (opts.unseen === true) parts.push("UNSEEN");
+  if (opts.text !== void 0 && opts.text !== null && opts.text !== "") {
+    parts.push(`TEXT "${opts.text}"`);
+  }
+  if (opts.subject !== void 0 && opts.subject !== null && opts.subject !== "") {
+    parts.push(`SUBJECT "${opts.subject}"`);
+  }
+  if (opts.fromAddr !== void 0 && opts.fromAddr !== null && opts.fromAddr !== "") {
+    parts.push(`FROM "${opts.fromAddr}"`);
+  }
+  if (opts.toAddr !== void 0 && opts.toAddr !== null && opts.toAddr !== "") {
+    parts.push(`TO "${opts.toAddr}"`);
+  }
+  if (opts.since !== void 0 && opts.since !== null && opts.since !== "") {
+    parts.push(`SINCE ${opts.since}`);
+  }
+  if (opts.before !== void 0 && opts.before !== null && opts.before !== "") {
+    parts.push(`BEFORE ${opts.before}`);
+  }
+  return parts.length > 0 ? parts.join(" ") : "ALL";
+}
+async function searchMessages(accessor, folder, opts = {}, maxResults = null) {
+  const criteria = buildSearchCriteria(opts);
+  return listMessageUids(accessor, folder, criteria, maxResults);
+}
+function buildVfsPath(prefix, folder, msg) {
+  const dateStr = dateBucket(msg);
+  const subject = sanitize(msg.subject !== "" ? msg.subject : "No Subject");
+  const filename = `${subject}__${msg.uid}.email.json`;
+  return [prefix, folder, dateStr, filename].filter((p) => p !== "").join("/");
+}
+async function searchAndFormat(accessor, scope, pattern, prefix, maxResults = null) {
+  const folder = scope.folder ?? "";
+  if (folder === "") return [];
+  const uids = await searchMessages(accessor, folder, { text: pattern }, maxResults);
+  const pairs = [];
+  for (const uid of uids) {
+    const msg = await fetchMessage(accessor, folder, uid);
+    const msgText = messageJsonText(msg);
+    const vfsPath = buildVfsPath(prefix, folder, msg);
+    pairs.push([vfsPath, msgText]);
+  }
+  return pairs;
+}
+
+// src/commands/builtin/email/grep.ts
+var resolveGlob2 = resolveGlobOf2(EMAIL_IO);
+var ENC = new TextEncoder();
+async function* emailStream(accessor, p, index) {
+  yield await read(accessor, p, index);
+}
+function parseFlags(flags) {
+  const toInt = (v) => typeof v === "string" ? Number.parseInt(v, 10) : null;
+  const aCtx = toInt(flags.A);
+  const bCtx = toInt(flags.B);
+  const cCtx = toInt(flags.C);
+  return {
+    ignoreCase: flags.i === true,
+    invert: flags.v === true,
+    lineNumbers: flags.n === true,
+    countOnly: flags.c === true,
+    filesOnly: flags.args_l === true || flags.l === true,
+    wholeWord: flags.w === true,
+    fixedString: flags.F === true,
+    onlyMatching: flags.o === true,
+    maxCount: toInt(flags.m),
+    quiet: flags.q === true,
+    afterContext: aCtx ?? cCtx ?? 0,
+    beforeContext: bCtx ?? cCtx ?? 0
+  };
+}
+function getPattern(texts, flags) {
+  if (typeof flags.e === "string") return flags.e;
+  if (texts.length > 0 && texts[0] !== void 0) return texts[0];
+  throw new Error("grep: usage: grep [flags] pattern [path]");
+}
+async function grepCommand(accessor, paths, texts, opts) {
+  let pattern;
+  try {
+    pattern = getPattern(texts, opts.flags);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [null, new IOResult({ exitCode: 2, stderr: ENC.encode(`${msg}
+`) })];
+  }
+  const f = parseFlags(opts.flags);
+  if (paths.length > 0) {
+    const first = paths[0];
+    if (first !== void 0) {
+      const scope = detectScope(first);
+      if (scope.useNative && !pattern.includes("\n")) {
+        const filePrefix = mountPrefixOf4(first.virtual, first.resourcePath) !== "" ? mountPrefixOf4(first.virtual, first.resourcePath) : "";
+        const pairs = await searchAndFormat(accessor, scope, pattern, filePrefix, f.maxCount ?? 50);
+        const lines = [];
+        for (const [vfsPath, msgText] of pairs) {
+          const matched = grepLines(
+            vfsPath,
+            [msgText],
+            compilePattern(pattern, f.ignoreCase, f.fixedString, f.wholeWord),
+            f
+          );
+          for (const line of matched) lines.push(`${vfsPath}:${line}`);
+        }
+        if (lines.length === 0) return [new Uint8Array(0), new IOResult({ exitCode: 1 })];
+        const out = ENC.encode(lines.join("\n") + "\n");
+        return [out, new IOResult()];
+      }
+    }
+  }
+  const resolved = paths.length > 0 ? await resolveGlob2(accessor, paths, opts.index ?? void 0) : [];
+  const stat2 = (p) => stat(accessor, p, opts.index ?? void 0);
+  const readdir2 = (p) => readdir(accessor, p, opts.index ?? void 0);
+  return grepGeneric(
+    "grep",
+    resolved,
+    texts,
+    opts,
+    stat2,
+    readdir2,
+    (p) => emailStream(accessor, p, opts.index ?? void 0)
+  );
+}
+var EMAIL_GREP = command2({
+  name: "grep",
+  resource: ResourceName2.EMAIL,
+  spec: specOf2("grep"),
+  fn: grepCommand,
+  aggregate: prefixAggregate,
+  provision: fileReadProvision
+});
+
+// src/commands/builtin/email/rg.ts
+import {
+  FlagView,
+  IOResult as IOResult2,
+  ResourceName as ResourceName3,
+  command as command3,
+  compilePattern as compilePattern2,
+  grepLines as grepLines2,
+  mountPrefixOf as mountPrefixOf5,
+  patternArg,
+  resolveGlobOf as resolveGlobOf3,
+  rgGeneric,
+  specOf as specOf3
+} from "@struktoai/mirage-core";
+var resolveGlob3 = resolveGlobOf3(EMAIL_IO);
+var ENC2 = new TextEncoder();
+async function* emailStream2(accessor, p, index) {
+  yield await read(accessor, p, index);
+}
+async function rgCommand(accessor, paths, texts, opts) {
+  const pattern = patternArg(texts, opts.flags);
+  if (pattern === null) {
+    return [
+      null,
+      new IOResult2({ exitCode: 2, stderr: ENC2.encode("rg: usage: rg [flags] pattern [path]\n") })
+    ];
+  }
+  const fl = new FlagView(opts.flags, specOf3("rg"));
+  const ignoreCase = fl.asBool("i");
+  const invert = fl.asBool("v");
+  const lineNumbers = fl.asBool("n");
+  const countOnly = fl.asBool("c");
+  const filesOnly = fl.asBool("args_l");
+  const wholeWord = fl.asBool("w");
+  const fixedString = fl.asBool("F");
+  const onlyMatching = fl.asBool("o");
+  const maxCount = fl.asInt("m") ?? null;
+  const pat = compilePattern2(pattern, ignoreCase, fixedString, wholeWord);
+  const lineOpts = {
+    invert,
+    lineNumbers,
+    countOnly,
+    filesOnly,
+    onlyMatching,
+    maxCount
+  };
+  if (paths.length > 0) {
+    const first = paths[0];
+    if (first !== void 0) {
+      const scope = detectScope(first);
+      if (scope.useNative && !pattern.includes("\n")) {
+        const filePrefix = mountPrefixOf5(first.virtual, first.resourcePath) !== "" ? mountPrefixOf5(first.virtual, first.resourcePath) : "";
+        const pairs = await searchAndFormat(accessor, scope, pattern, filePrefix, maxCount ?? 50);
+        const lines = [];
+        for (const [vfsPath, msgText] of pairs) {
+          const matched = grepLines2(vfsPath, [msgText], pat, lineOpts);
+          for (const line of matched) lines.push(`${vfsPath}:${line}`);
+        }
+        if (lines.length === 0) return [new Uint8Array(0), new IOResult2({ exitCode: 1 })];
+        const out = ENC2.encode(lines.join("\n") + "\n");
+        return [out, new IOResult2()];
+      }
+    }
+  }
+  const resolved = paths.length > 0 ? await resolveGlob3(accessor, paths, opts.index ?? void 0) : [];
+  const stat2 = (p) => stat(accessor, p, opts.index ?? void 0);
+  const readdir2 = (p) => readdir(accessor, p, opts.index ?? void 0);
+  return rgGeneric(
+    resolved,
+    texts,
+    opts,
+    stat2,
+    readdir2,
+    (p) => emailStream2(accessor, p, opts.index ?? void 0)
+  );
+}
+var EMAIL_RG = command3({
+  name: "rg",
+  resource: ResourceName3.EMAIL,
+  spec: specOf3("rg"),
+  fn: rgCommand
+});
+
+// src/commands/builtin/email/index.ts
+var EMAIL_OVERRIDES = /* @__PURE__ */ new Set(["find", "grep", "rg"]);
+var EMAIL_COMMANDS = [
+  ...makeGenericCommands(ResourceName4.EMAIL, EMAIL_IO, {
+    overrides: EMAIL_OVERRIDES
+  }),
+  ...EMAIL_FIND,
+  ...EMAIL_GREP,
+  ...EMAIL_RG
+];
+
+// src/ops/email/index.ts
+import { ResourceName as ResourceName5, makeGenericOps } from "@struktoai/mirage-core";
+var EMAIL_OPS = makeGenericOps(ResourceName5.EMAIL, EMAIL_IO);
+
+// src/resource/email/prompt.ts
+var EMAIL_PROMPT = `{prefix}
+  <folder>/
+    <yyyy-mm-dd>/
+      <subject>__<uid>.email.json
+      <subject>__<uid>/           # if attachments exist
+        <attachment-filename>
+  Folders include: INBOX, Sent, Drafts, etc. cat shows email as JSON.
+
+  To act on mail (list/read/send/reply/forward), use the himalaya CLI
+  if installed: himalaya --help`;
+var EMAIL_WRITE_PROMPT = `  Sending mail goes through the himalaya CLI if installed:
+    himalaya message send --to "to@email.com" --subject "Hi" --body "..."`;
+
+// src/resource/email/email.ts
+var resolveGlob4 = makeResolveGlob(readdir);
+var EmailResource = class extends BaseResource {
+  kind = ResourceName6.EMAIL;
+  cachesReads = true;
+  // Every listed file carries an exact size: .email.json is rendered at
+  // readdir from the full message source the listing already fetches, and an
+  // attachment's size is its decoded payload length.
+  sizesAlwaysKnown = true;
+  indexTtl = 86400;
+  prompt = EMAIL_PROMPT;
+  config;
+  accessor;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.accessor = new EmailAccessor(config);
+  }
+  open() {
+    return Promise.resolve();
+  }
+  async close() {
+    await this.accessor.close();
+    await super.close();
+  }
+  commands() {
+    return EMAIL_COMMANDS;
+  }
+  ops() {
+    return EMAIL_OPS;
+  }
+  readFile(p) {
+    return read(this.accessor, p, this.index);
+  }
+  readdir(p) {
+    return readdir(this.accessor, p, this.index);
+  }
+  stat(p) {
+    return stat(this.accessor, p, this.index);
+  }
+  glob(paths, prefix = "") {
+    const effective = prefix !== "" ? paths.map(
+      (p) => mountPrefixOf6(p.virtual, p.resourcePath) !== "" ? p : new PathSpec2({
+        virtual: p.virtual,
+        directory: p.directory,
+        ...p.pattern !== null ? { pattern: p.pattern } : {},
+        resolved: p.resolved,
+        resourcePath: mountKey3(p.virtual, prefix)
+      })
+    ) : paths;
+    return resolveGlob4(this.accessor, effective, this.index);
+  }
+  getState() {
+    return Promise.resolve({
+      type: this.kind,
+      config: redactEmailConfig(this.config)
+    });
+  }
+  loadState(_state) {
+    return Promise.resolve();
+  }
+};
+
+export {
+  EmailAccessor,
+  parseRfc822,
+  listFolderEntries,
+  listMessageUids,
+  fetchRawMessage,
+  fetchMessage,
+  fetchHeaders,
+  messageJsonBytes,
+  messagesJsonBytes,
+  EMAIL_COMMANDS,
+  EMAIL_OPS,
+  EMAIL_PROMPT,
+  EMAIL_WRITE_PROMPT,
+  EmailResource
+};
+//# sourceMappingURL=chunk-TWRQCQWU.js.map