@struktoai/mirage-node 0.0.1-alpha.1

package/dist/chunk-OYJXYJTE.js

@@ -0,0 +1,2358 @@
+import {
+  redactEmailConfig
+} from "./chunk-H74QYTN7.js";
+
+// src/resource/email/email.ts
+import {
+  PathSpec as PathSpec7,
+  RAMIndexCacheStore,
+  ResourceName as ResourceName25
+} 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;
+    })();
+    return this.clientPromise;
+  }
+  async close() {
+    if (this.clientPromise === null) return;
+    try {
+      const c = await this.clientPromise;
+      await c.logout();
+    } catch {
+    }
+    this.clientPromise = null;
+  }
+};
+
+// src/commands/builtin/email/basename.ts
+import {
+  IOResult,
+  ResourceName,
+  command,
+  specOf
+} from "@struktoai/mirage-core";
+var ENC = new TextEncoder();
+function basenameOf(p) {
+  const trimmed = p.replace(/\/+$/, "");
+  const idx = trimmed.lastIndexOf("/");
+  return idx === -1 ? trimmed : trimmed.slice(idx + 1);
+}
+function basenameCommand(_accessor, _paths, texts, _opts) {
+  const lines = texts.map((t) => basenameOf(t));
+  const out = ENC.encode(lines.join("\n") + "\n");
+  return [out, new IOResult()];
+}
+var EMAIL_BASENAME = command({
+  name: "basename",
+  resource: ResourceName.EMAIL,
+  spec: specOf("basename"),
+  fn: basenameCommand
+});
+
+// src/commands/builtin/email/cat.ts
+import {
+  AsyncLineIterator,
+  IOResult as IOResult2,
+  ResourceName as ResourceName2,
+  command as command2,
+  resolveSource,
+  specOf as specOf2,
+  wrapBytes
+} from "@struktoai/mirage-core";
+
+// src/core/email/glob.ts
+import { PathSpec as PathSpecCtor2 } from "@struktoai/mirage-core";
+
+// src/core/email/readdir.ts
+import { IndexEntry, PathSpec as PathSpecCtor } 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 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]),
+    to: toAddrList(parsed.to),
+    cc: toAddrList(parsed.cc),
+    subject: parsed.subject ?? "",
+    date: parsed.date instanceof Date ? parsed.date.toUTCString() : "",
+    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
+async function listFolders(accessor) {
+  const imap = await accessor.getImap();
+  const tree = await imap.list();
+  return tree.map((m) => m.path);
+}
+async function listMessageUids(accessor, folder, searchCriteria = "ALL", maxResults = null) {
+  const imap = await accessor.getImap();
+  const lock = await imap.getMailboxLock(folder);
+  try {
+    const query = parseSearchCriteria(searchCriteria);
+    const uidsRaw = await imap.search(query, { uid: true });
+    if (uidsRaw === false) return [];
+    const uids = uidsRaw.map((n) => String(n));
+    if (maxResults !== null && uids.length > maxResults) {
+      return uids.slice(uids.length - maxResults);
+    }
+    return uids;
+  } finally {
+    lock.release();
+  }
+}
+function parseSearchCriteria(criteria) {
+  if (criteria === "ALL" || criteria === "") return { all: true };
+  const out = {};
+  const tokens = tokenizeCriteria(criteria);
+  let i = 0;
+  while (i < tokens.length) {
+    const tok = (tokens[i] ?? "").toUpperCase();
+    if (tok === "UNSEEN") {
+      out.unseen = true;
+      i += 1;
+      continue;
+    }
+    if (tok === "TEXT" || tok === "SUBJECT" || tok === "FROM" || tok === "TO" || tok === "SINCE" || tok === "BEFORE") {
+      const v = tokens[i + 1] ?? "";
+      if (tok === "TEXT") out.text = v;
+      else if (tok === "SUBJECT") out.subject = v;
+      else if (tok === "FROM") out.from = v;
+      else if (tok === "TO") out.to = v;
+      else if (tok === "SINCE") {
+        const d = parseImapDate(v);
+        if (d !== null) out.since = d;
+      } else {
+        const d = parseImapDate(v);
+        if (d !== null) out.before = d;
+      }
+      i += 2;
+      continue;
+    }
+    i += 1;
+  }
+  return out;
+}
+function tokenizeCriteria(criteria) {
+  const tokens = [];
+  let i = 0;
+  while (i < criteria.length) {
+    if (criteria[i] === " ") {
+      i += 1;
+      continue;
+    }
+    if (criteria[i] === '"') {
+      const end2 = criteria.indexOf('"', i + 1);
+      if (end2 === -1) {
+        tokens.push(criteria.slice(i + 1));
+        break;
+      }
+      tokens.push(criteria.slice(i + 1, end2));
+      i = end2 + 1;
+      continue;
+    }
+    let end = criteria.indexOf(" ", i);
+    if (end === -1) end = criteria.length;
+    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] ?? 0;
+  const year = Number.parseInt(m[3] ?? "1970", 10);
+  return new Date(Date.UTC(year, mon, day));
+}
+async function fetchMessage(accessor, folder, uid) {
+  const imap = await accessor.getImap();
+  const lock = await imap.getMailboxLock(folder);
+  try {
+    const msg = await imap.fetchOne(uid, { source: true, flags: true, uid: 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] : []
+    };
+  } finally {
+    lock.release();
+  }
+}
+async function fetchHeaders(accessor, folder, uids) {
+  if (uids.length === 0) return [];
+  const imap = await accessor.getImap();
+  const lock = await imap.getMailboxLock(folder);
+  try {
+    const results = [];
+    for (const uid of uids) {
+      const msg = await imap.fetchOne(uid, { headers: true, flags: true, uid: true }, { uid: true });
+      if (msg === false) continue;
+      const headers = msg.headers instanceof Buffer ? new Uint8Array(msg.headers) : new Uint8Array(0);
+      const parsed = await parseRfc822(headers, true);
+      results.push({
+        ...parsed,
+        uid,
+        flags: msg.flags !== void 0 ? [...msg.flags] : []
+      });
+    }
+    return results;
+  } finally {
+    lock.release();
+  }
+}
+async function fetchAttachment(accessor, folder, uid, filename) {
+  const imap = await accessor.getImap();
+  const lock = await imap.getMailboxLock(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/readdir.ts
+var TITLE_MAX = 80;
+var UNSAFE = /[^\w\s\-.]/g;
+var MULTI_UNDERSCORE = /_+/g;
+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`;
+}
+function dateFromHeader(dateStr) {
+  if (dateStr === "") return "1970-01-01";
+  const d = new Date(dateStr);
+  if (Number.isNaN(d.getTime())) return "1970-01-01";
+  const yyyy = d.getUTCFullYear().toString().padStart(4, "0");
+  const mm = (d.getUTCMonth() + 1).toString().padStart(2, "0");
+  const dd = d.getUTCDate().toString().padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}`;
+}
+function enoent(p) {
+  const e = new Error(`ENOENT: ${p}`);
+  e.code = "ENOENT";
+  return e;
+}
+async function readdir(accessor, path, index) {
+  const prefix = path.prefix;
+  const raw = path.pattern !== null ? path.directory : path.original;
+  let p = raw;
+  if (prefix !== "" && p.startsWith(prefix)) p = p.slice(prefix.length) || "/";
+  const key = p.replace(/^\/+|\/+$/g, "");
+  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.original);
+    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 = dateFromHeader(hdr.date);
+      let bucket = dateGroups.get(dateStr);
+      if (bucket === void 0) {
+        bucket = [];
+        dateGroups.set(dateStr, bucket);
+      }
+      bucket.push(hdr);
+    }
+    const sortedDates = [...dateGroups.keys()].sort().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
+        });
+        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.original);
+    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({ original: folderPath, directory: 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.original);
+  }
+  throw enoent(path.original);
+}
+
+// src/core/email/glob.ts
+var SCOPE_ERROR = 1e3;
+function fnmatch(name, pattern) {
+  const re = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\?/g, ".").replace(/\*/g, ".*");
+  return new RegExp(`^${re}$`).test(name);
+}
+async function resolveGlob(accessor, paths, index) {
+  const result = [];
+  for (const p of paths) {
+    if (p.resolved) {
+      result.push(p);
+      continue;
+    }
+    if (p.pattern !== null && p.pattern !== "") {
+      const entries = await readdir(accessor, p, index);
+      const matched = [];
+      for (const entry of entries) {
+        const trimmed = entry.replace(/\/+$/, "");
+        const base = trimmed.split("/").pop() ?? trimmed;
+        if (!fnmatch(base, p.pattern)) continue;
+        matched.push(PathSpecCtor2.fromStrPath(trimmed, p.prefix));
+      }
+      const truncated = matched.length > SCOPE_ERROR ? matched.slice(0, SCOPE_ERROR) : matched;
+      result.push(...truncated);
+    } else {
+      result.push(p);
+    }
+  }
+  return result;
+}
+
+// src/core/email/read.ts
+var ENC2 = new TextEncoder();
+function enoent2(p) {
+  const e = new Error(`ENOENT: ${p}`);
+  e.code = "ENOENT";
+  return e;
+}
+function eisdir(p) {
+  const e = new Error(`EISDIR: ${p}`);
+  e.code = "EISDIR";
+  return e;
+}
+function dirname(p) {
+  const norm = p.replace(/\/+$/, "");
+  const idx = norm.lastIndexOf("/");
+  if (idx <= 0) return "/";
+  return norm.slice(0, idx);
+}
+async function read(accessor, path, index) {
+  const prefix = path.prefix;
+  let p = path.original;
+  if (prefix !== "" && p.startsWith(prefix)) p = p.slice(prefix.length) || "/";
+  const key = p.replace(/^\/+|\/+$/g, "");
+  if (index === void 0) throw enoent2(path.original);
+  const virtualKey = prefix !== "" ? `${prefix}/${key}` : `/${key}`;
+  const result = await index.get(virtualKey);
+  if (result.entry === void 0 || result.entry === null) throw enoent2(path.original);
+  const rt = result.entry.resourceType;
+  if (rt === "email/folder" || rt === "email/date" || rt === "email/attachment_dir") {
+    throw eisdir(path.original);
+  }
+  if (rt === "email/attachment") {
+    const parentKey = dirname(virtualKey);
+    const parentResult = await index.get(parentKey);
+    if (parentResult.entry === void 0 || parentResult.entry === null) {
+      throw enoent2(path.original);
+    }
+    const uid2 = parentResult.entry.id;
+    const parts2 = virtualKey.replace(/^\/+|\/+$/g, "").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 enoent2(path.original);
+    return data;
+  }
+  const parts = virtualKey.replace(/^\/+|\/+$/g, "").split("/");
+  const folder = prefix !== "" ? parts[1] ?? "" : parts[0] ?? "";
+  const uid = result.entry.id;
+  const msg = await fetchMessage(accessor, folder, uid);
+  return ENC2.encode(JSON.stringify(msg));
+}
+
+// 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.original);
+      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/cat.ts
+var ENC3 = new TextEncoder();
+async function* numberLinesStream(source) {
+  let num = 1;
+  const lineIter = new AsyncLineIterator(source);
+  for await (const line of lineIter) {
+    yield ENC3.encode(`     ${String(num)}	`);
+    yield line;
+    yield ENC3.encode("\n");
+    num += 1;
+  }
+}
+async function catCommand(accessor, paths, _texts, opts) {
+  const nFlag = opts.flags.n === true;
+  if (paths.length > 0) {
+    const resolved = await resolveGlob(accessor, paths, opts.index ?? void 0);
+    const first = resolved[0];
+    if (first === void 0) return [null, new IOResult2()];
+    const data = await read(accessor, first, opts.index ?? void 0);
+    const io = new IOResult2({ reads: { [first.stripPrefix]: data }, cache: [first.stripPrefix] });
+    if (nFlag) return [numberLinesStream(wrapBytes(data)), io];
+    return [data, io];
+  }
+  try {
+    const source = resolveSource(opts.stdin, "cat: missing operand");
+    if (nFlag) return [numberLinesStream(source), new IOResult2()];
+    return [source, new IOResult2()];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [null, new IOResult2({ exitCode: 1, stderr: ENC3.encode(`${msg}
+`) })];
+  }
+}
+var EMAIL_CAT = command2({
+  name: "cat",
+  resource: ResourceName2.EMAIL,
+  spec: specOf2("cat"),
+  fn: catCommand,
+  provision: fileReadProvision
+});
+
+// src/commands/builtin/email/dirname.ts
+import {
+  IOResult as IOResult3,
+  ResourceName as ResourceName3,
+  command as command3,
+  specOf as specOf3
+} from "@struktoai/mirage-core";
+var ENC4 = new TextEncoder();
+function dirnameOf(p) {
+  const trimmed = p.replace(/\/+$/, "");
+  const idx = trimmed.lastIndexOf("/");
+  if (idx === -1) return ".";
+  if (idx === 0) return "/";
+  return trimmed.slice(0, idx);
+}
+function dirnameCommand(_accessor, _paths, texts, _opts) {
+  const lines = texts.map((t) => dirnameOf(t));
+  const out = ENC4.encode(lines.join("\n") + "\n");
+  return [out, new IOResult3()];
+}
+var EMAIL_DIRNAME = command3({
+  name: "dirname",
+  resource: ResourceName3.EMAIL,
+  spec: specOf3("dirname"),
+  fn: dirnameCommand
+});
+
+// src/commands/builtin/email/find.ts
+import {
+  IOResult as IOResult4,
+  PathSpec,
+  ResourceName as ResourceName4,
+  command as command4,
+  specOf as specOf4
+} from "@struktoai/mirage-core";
+var ENC5 = new TextEncoder();
+function fnmatch2(name, pattern) {
+  const re = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\?/g, ".").replace(/\*/g, ".*");
+  return new RegExp(`^${re}$`).test(name);
+}
+async function walk(accessor, path, index, maxDepth, depth) {
+  if (maxDepth !== null && depth > maxDepth) return [];
+  let children;
+  try {
+    children = await readdir(accessor, path, index ?? void 0);
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const child of children) {
+    const isFolder = child.endsWith("/");
+    const trimmed = isFolder ? child.replace(/\/+$/, "") : child;
+    results.push(trimmed);
+    if (isFolder) {
+      const childSpec = new PathSpec({
+        original: trimmed,
+        directory: trimmed,
+        resolved: false,
+        prefix: path.prefix
+      });
+      const sub = await walk(accessor, childSpec, index, maxDepth, depth + 1);
+      results.push(...sub);
+    }
+  }
+  return results;
+}
+async function findCommand(accessor, paths, _texts, opts) {
+  const resolved = await resolveGlob(accessor, paths, opts.index ?? void 0);
+  const p0 = resolved[0] ?? new PathSpec({
+    original: "/",
+    directory: "/",
+    resolved: false,
+    prefix: opts.mountPrefix ?? ""
+  });
+  const nameFlag = typeof opts.flags.name === "string" ? opts.flags.name : null;
+  const inameFlag = typeof opts.flags.iname === "string" ? opts.flags.iname : null;
+  const maxDepthRaw = typeof opts.flags.maxdepth === "string" ? opts.flags.maxdepth : null;
+  const minDepthRaw = typeof opts.flags.mindepth === "string" ? opts.flags.mindepth : null;
+  const maxDepth = maxDepthRaw !== null ? Number.parseInt(maxDepthRaw, 10) : null;
+  const minDepth = minDepthRaw !== null ? Number.parseInt(minDepthRaw, 10) : null;
+  const allPaths = await walk(accessor, p0, opts.index, maxDepth, 0);
+  const searchKey = p0.stripPrefix.replace(/^\/+|\/+$/g, "");
+  const baseDepth = searchKey === "" ? -1 : searchKey.split("/").length - 1;
+  const results = [];
+  for (const p of [...allPaths].sort()) {
+    const stripped = p.startsWith(p0.prefix) ? p.slice(p0.prefix.length) : p;
+    const trimmed = stripped.replace(/^\/+|\/+$/g, "");
+    const depth = trimmed === "" ? -1 : trimmed.split("/").length - (baseDepth + 2);
+    if (minDepth !== null && depth < minDepth) continue;
+    const entryName = p.split("/").pop() ?? p;
+    if (nameFlag !== null && !fnmatch2(entryName, nameFlag)) continue;
+    if (inameFlag !== null && !fnmatch2(entryName.toLowerCase(), inameFlag.toLowerCase())) continue;
+    results.push(p);
+  }
+  const out = ENC5.encode(results.join("\n"));
+  return [out, new IOResult4()];
+}
+var EMAIL_FIND = command4({
+  name: "find",
+  resource: ResourceName4.EMAIL,
+  spec: specOf4("find"),
+  fn: findCommand,
+  provision: metadataProvision
+});
+
+// src/commands/builtin/email/email_forward.ts
+import {
+  CommandSpec,
+  IOResult as IOResult5,
+  OperandKind,
+  Option,
+  ResourceName as ResourceName5,
+  command as command5
+} from "@struktoai/mirage-core";
+
+// src/core/email/send.ts
+import { loadOptionalPeer as loadOptionalPeer3 } from "@struktoai/mirage-core";
+var transporterCache = /* @__PURE__ */ new WeakMap();
+async function getTransporter(config) {
+  const existing = transporterCache.get(config);
+  if (existing !== void 0) return existing;
+  const mod = await loadOptionalPeer3(
+    () => import("nodemailer"),
+    { feature: "email send/reply/forward", packageName: "nodemailer" }
+  );
+  const transporter = mod.createTransport({
+    host: config.smtpHost,
+    port: config.smtpPort,
+    secure: config.smtpPort === 465,
+    auth: { user: config.username, pass: config.password }
+  });
+  transporterCache.set(config, transporter);
+  return transporter;
+}
+async function sendMessage(config, to, subject, body) {
+  const t = await getTransporter(config);
+  await t.sendMail({ from: config.username, to, subject, text: body });
+  return { status: "sent", to, subject };
+}
+async function replyMessage(config, original, body) {
+  const t = await getTransporter(config);
+  const refs = [...original.references];
+  if (original.message_id !== "") refs.push(original.message_id);
+  const subject = `Re: ${original.subject}`;
+  await t.sendMail({
+    from: config.username,
+    to: original.from.email,
+    subject,
+    text: body,
+    inReplyTo: original.message_id,
+    references: refs
+  });
+  return { status: "sent", to: original.from.email, subject };
+}
+async function replyAllMessage(config, original, body) {
+  const t = await getTransporter(config);
+  const all = /* @__PURE__ */ new Set();
+  if (original.from.email !== "") all.add(original.from.email);
+  for (const r of original.to) if (r.email !== "") all.add(r.email);
+  for (const r of original.cc) if (r.email !== "") all.add(r.email);
+  all.delete(config.username);
+  const recipients = [...all].sort();
+  const refs = [...original.references];
+  if (original.message_id !== "") refs.push(original.message_id);
+  const subject = `Re: ${original.subject}`;
+  await t.sendMail({
+    from: config.username,
+    to: recipients,
+    subject,
+    text: body,
+    inReplyTo: original.message_id,
+    references: refs
+  });
+  return { status: "sent", to: recipients, subject };
+}
+async function forwardMessage(config, original, to) {
+  const t = await getTransporter(config);
+  const subject = `Fwd: ${original.subject}`;
+  const fwdBody = `---------- Forwarded message ----------
+From: ${original.from.name} <${original.from.email}>
+Date: ${original.date}
+Subject: ${original.subject}
+
+` + original.body_text;
+  await t.sendMail({ from: config.username, to, subject, text: fwdBody });
+  return { status: "sent", to, subject };
+}
+
+// src/commands/builtin/email/email_forward.ts
+var ENC6 = new TextEncoder();
+var SPEC = new CommandSpec({
+  options: [
+    new Option({ long: "--uid", valueKind: OperandKind.TEXT }),
+    new Option({ long: "--folder", valueKind: OperandKind.TEXT }),
+    new Option({ long: "--to", valueKind: OperandKind.TEXT })
+  ]
+});
+async function emailForwardCommand(accessor, _paths, _texts, opts) {
+  const uid = typeof opts.flags.uid === "string" ? opts.flags.uid : "";
+  const folder = typeof opts.flags.folder === "string" ? opts.flags.folder : "";
+  const to = typeof opts.flags.to === "string" ? opts.flags.to : "";
+  if (uid === "") {
+    return [null, new IOResult5({ exitCode: 2, stderr: ENC6.encode("--uid is required\n") })];
+  }
+  if (folder === "") {
+    return [null, new IOResult5({ exitCode: 2, stderr: ENC6.encode("--folder is required\n") })];
+  }
+  if (to === "") {
+    return [null, new IOResult5({ exitCode: 2, stderr: ENC6.encode("--to is required\n") })];
+  }
+  const original = await fetchMessage(accessor, folder, uid);
+  const result = await forwardMessage(accessor.config, original, to);
+  const out = ENC6.encode(JSON.stringify(result));
+  return [out, new IOResult5()];
+}
+var EMAIL_FORWARD = command5({
+  name: "email-forward",
+  resource: ResourceName5.EMAIL,
+  spec: SPEC,
+  fn: emailForwardCommand,
+  write: true
+});
+
+// src/commands/builtin/email/grep.ts
+import {
+  IOResult as IOResult6,
+  PathSpec as PathSpec2,
+  ResourceName as ResourceName6,
+  command as command6,
+  compilePattern,
+  exitOnEmpty,
+  grepFilesOnly,
+  grepLines,
+  grepStream,
+  prefixAggregate,
+  quietMatch,
+  resolveSource as resolveSource2,
+  specOf as specOf5,
+  yieldBytes
+} from "@struktoai/mirage-core";
+
+// src/core/email/stat.ts
+import { FileStat, FileType } from "@struktoai/mirage-core";
+function guessType(name) {
+  const lower = name.toLowerCase();
+  if (lower.endsWith(".json") || lower.endsWith(".email.json")) return FileType.JSON;
+  if (lower.endsWith(".csv")) return FileType.CSV;
+  if (lower.endsWith(".png")) return FileType.IMAGE_PNG;
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return FileType.IMAGE_JPEG;
+  if (lower.endsWith(".gif")) return FileType.IMAGE_GIF;
+  if (lower.endsWith(".zip")) return FileType.ZIP;
+  if (lower.endsWith(".gz") || lower.endsWith(".gzip")) return FileType.GZIP;
+  if (lower.endsWith(".pdf")) return FileType.PDF;
+  if (lower.endsWith(".txt") || lower.endsWith(".md") || lower.endsWith(".log")) {
+    return FileType.TEXT;
+  }
+  return FileType.BINARY;
+}
+function enoent3(p) {
+  const e = new Error(`ENOENT: ${p}`);
+  e.code = "ENOENT";
+  return e;
+}
+async function stat(accessor, path, index) {
+  const prefix = path.prefix;
+  let p = path.original;
+  if (prefix !== "" && p.startsWith(prefix)) p = p.slice(prefix.length) || "/";
+  const key = p.replace(/^\/+|\/+$/g, "");
+  if (key === "") return new FileStat({ name: "/", type: FileType.DIRECTORY });
+  if (index === void 0) throw enoent3(path.original);
+  const virtualKey = prefix !== "" ? `${prefix}/${key}` : `/${key}`;
+  const 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 enoent3(path.original);
+    }
+    throw enoent3(path.original);
+  }
+  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/scope.ts
+function detectScope(path) {
+  const key = path.stripPrefix.replace(/^\/+|\/+$/g, "");
+  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
+var TITLE_MAX2 = 80;
+var UNSAFE2 = /[^\w\s\-.]/g;
+var MULTI_UNDERSCORE2 = /_+/g;
+function sanitize2(text) {
+  if (text.trim() === "") return "No_Subject";
+  let cleaned = text.replace(UNSAFE2, "_").replace(/ /g, "_");
+  cleaned = cleaned.replace(MULTI_UNDERSCORE2, "_").replace(/^_+|_+$/g, "");
+  if (cleaned.length > TITLE_MAX2) cleaned = `${cleaned.slice(0, TITLE_MAX2 - 3)}...`;
+  return cleaned;
+}
+function dateFromHeader2(dateStr) {
+  if (dateStr === "") return "1970-01-01";
+  const d = new Date(dateStr);
+  if (Number.isNaN(d.getTime())) return "1970-01-01";
+  const yyyy = d.getUTCFullYear().toString().padStart(4, "0");
+  const mm = (d.getUTCMonth() + 1).toString().padStart(2, "0");
+  const dd = d.getUTCDate().toString().padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}`;
+}
+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 = dateFromHeader2(msg.date);
+  const subject = sanitize2(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 = JSON.stringify(msg);
+    const vfsPath = buildVfsPath(prefix, folder, msg);
+    pairs.push([vfsPath, msgText]);
+  }
+  return pairs;
+}
+
+// src/commands/builtin/email/grep.ts
+var ENC7 = new TextEncoder();
+var DEC = new TextDecoder("utf-8", { fatal: false });
+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]");
+}
+function splitLinesNoTrailing(text) {
+  const stripped = text.endsWith("\n") ? text.slice(0, -1) : text;
+  return stripped === "" ? [] : stripped.split("\n");
+}
+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 IOResult6({ exitCode: 2, stderr: ENC7.encode(`${msg}
+`) })];
+  }
+  const f = parseFlags(opts.flags);
+  const recursive = opts.flags.r === true || opts.flags.R === true;
+  if (paths.length > 0) {
+    const first = paths[0];
+    if (first !== void 0) {
+      const scope = detectScope(first);
+      if (scope.useNative) {
+        const filePrefix2 = first.prefix !== "" ? first.prefix : "";
+        const pairs = await searchAndFormat(accessor, scope, pattern, filePrefix2, 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 IOResult6({ exitCode: 1 })];
+        const out = ENC7.encode(lines.join("\n") + "\n");
+        return [out, new IOResult6()];
+      }
+    }
+    const resolved = await resolveGlob(accessor, paths, opts.index ?? void 0);
+    if (resolved.length === 0) return [new Uint8Array(0), new IOResult6({ exitCode: 1 })];
+    const filePrefix = resolved[0]?.prefix ?? "";
+    const readdirFn = async (path) => {
+      const spec = new PathSpec2({
+        original: path,
+        directory: path,
+        resolved: false,
+        prefix: filePrefix
+      });
+      return readdir(accessor, spec, opts.index ?? void 0);
+    };
+    const statFn = async (path) => {
+      const spec = new PathSpec2({
+        original: path,
+        directory: path,
+        resolved: false,
+        prefix: filePrefix
+      });
+      return stat(accessor, spec, opts.index ?? void 0);
+    };
+    const readBytesFn = async (path) => {
+      const spec = new PathSpec2({
+        original: path,
+        directory: path,
+        resolved: true,
+        prefix: filePrefix
+      });
+      return read(accessor, spec, opts.index ?? void 0);
+    };
+    if (f.filesOnly) {
+      const warnings = [];
+      const firstResolved2 = resolved[0];
+      if (firstResolved2 === void 0) return [new Uint8Array(0), new IOResult6({ exitCode: 1 })];
+      const results = await grepFilesOnly(
+        readdirFn,
+        statFn,
+        readBytesFn,
+        firstResolved2.original,
+        pattern,
+        {
+          recursive,
+          ignoreCase: f.ignoreCase,
+          invert: f.invert,
+          lineNumbers: f.lineNumbers,
+          countOnly: f.countOnly,
+          fixedString: f.fixedString,
+          onlyMatching: f.onlyMatching,
+          maxCount: f.maxCount,
+          wholeWord: f.wholeWord
+        },
+        warnings
+      );
+      const stderr = warnings.length > 0 ? ENC7.encode(warnings.join("\n")) : null;
+      if (results.length === 0) return [new Uint8Array(0), new IOResult6({ exitCode: 1, stderr })];
+      const out = ENC7.encode(results.join("\n"));
+      return [out, new IOResult6({ stderr })];
+    }
+    const pat2 = compilePattern(pattern, f.ignoreCase, f.fixedString, f.wholeWord);
+    if (resolved.length > 1) {
+      const allResults = [];
+      for (const p of resolved) {
+        const data2 = splitLinesNoTrailing(
+          DEC.decode(await read(accessor, p, opts.index ?? void 0))
+        );
+        const hits = grepLines(p.original, data2, pat2, f);
+        if (f.countOnly) {
+          if (hits.length > 0) allResults.push(`${p.original}:${hits[0] ?? ""}`);
+        } else {
+          for (const h of hits) allResults.push(`${p.original}:${h}`);
+        }
+      }
+      if (allResults.length === 0) return [new Uint8Array(0), new IOResult6({ exitCode: 1 })];
+      const out = ENC7.encode(allResults.join("\n"));
+      return [out, new IOResult6()];
+    }
+    const firstResolved = resolved[0];
+    if (firstResolved === void 0) return [null, new IOResult6()];
+    const data = await read(accessor, firstResolved, opts.index ?? void 0);
+    const source2 = yieldBytes(data);
+    const stream2 = grepStream(source2, pat2, f);
+    if (f.quiet) {
+      const io3 = new IOResult6({ exitCode: 1 });
+      return [quietMatch(stream2, io3), io3];
+    }
+    const io2 = new IOResult6();
+    return [exitOnEmpty(stream2, io2), io2];
+  }
+  let source;
+  try {
+    source = resolveSource2(opts.stdin, "grep: usage: grep [flags] pattern [path]");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [null, new IOResult6({ exitCode: 2, stderr: ENC7.encode(`${msg}
+`) })];
+  }
+  const pat = compilePattern(pattern, f.ignoreCase, f.fixedString, f.wholeWord);
+  const stream = grepStream(source, pat, f);
+  if (f.quiet) {
+    const io2 = new IOResult6({ exitCode: 1 });
+    return [quietMatch(stream, io2), io2];
+  }
+  const io = new IOResult6();
+  return [exitOnEmpty(stream, io), io];
+}
+var EMAIL_GREP = command6({
+  name: "grep",
+  resource: ResourceName6.EMAIL,
+  spec: specOf5("grep"),
+  fn: grepCommand,
+  aggregate: prefixAggregate,
+  provision: fileReadProvision
+});
+
+// src/commands/builtin/email/head.ts
+import {
+  IOResult as IOResult7,
+  ResourceName as ResourceName7,
+  command as command7,
+  readStdinAsync,
+  specOf as specOf6
+} from "@struktoai/mirage-core";
+var ENC8 = new TextEncoder();
+function headBytes(data, lines, bytesMode) {
+  if (bytesMode !== null) return data.slice(0, bytesMode);
+  let count = 0;
+  let end = 0;
+  for (let i = 0; i < data.byteLength && count < lines; i++) {
+    if (data[i] === 10) {
+      count += 1;
+      end = i + 1;
+    }
+  }
+  if (count < lines) return data;
+  return data.slice(0, end - 1);
+}
+async function headCommand(accessor, paths, _texts, opts) {
+  const lines = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : 10;
+  const bytesMode = typeof opts.flags.c === "string" ? Number.parseInt(opts.flags.c, 10) : null;
+  if (paths.length > 0) {
+    const resolved = await resolveGlob(accessor, paths, opts.index ?? void 0);
+    const first = resolved[0];
+    if (first === void 0) return [null, new IOResult7()];
+    const data = await read(accessor, first, opts.index ?? void 0);
+    const out2 = headBytes(data, lines, bytesMode);
+    return [out2, new IOResult7()];
+  }
+  const raw = await readStdinAsync(opts.stdin);
+  if (raw === null) {
+    return [null, new IOResult7({ exitCode: 1, stderr: ENC8.encode("head: missing operand\n") })];
+  }
+  const out = headBytes(raw, lines, bytesMode);
+  return [out, new IOResult7()];
+}
+var EMAIL_HEAD = command7({
+  name: "head",
+  resource: ResourceName7.EMAIL,
+  spec: specOf6("head"),
+  fn: headCommand,
+  provision: fileReadProvision
+});
+
+// src/commands/builtin/email/jq.ts
+import {
+  IOResult as IOResult8,
+  ResourceName as ResourceName8,
+  command as command8,
+  jqEval,
+  parseJsonAuto,
+  parseJsonPath,
+  readStdinAsync as readStdinAsync2,
+  specOf as specOf7
+} from "@struktoai/mirage-core";
+var ENC9 = new TextEncoder();
+function formatResult(result, raw, compact) {
+  if (raw && typeof result === "string") return ENC9.encode(result + "\n");
+  const json = compact ? JSON.stringify(result) : JSON.stringify(result, null, 2);
+  return ENC9.encode(json + "\n");
+}
+function formatResults(results, raw, compact, spread) {
+  if (spread && Array.isArray(results)) {
+    const parts = [];
+    for (const item of results) parts.push(formatResult(item, raw, compact));
+    let total = 0;
+    for (const p of parts) total += p.byteLength;
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const p of parts) {
+      out.set(p, offset);
+      offset += p.byteLength;
+    }
+    return out;
+  }
+  return formatResult(results, raw, compact);
+}
+async function jqCommand(accessor, paths, texts, opts) {
+  if (texts.length === 0 || texts[0] === void 0) {
+    return [
+      null,
+      new IOResult8({ exitCode: 2, stderr: ENC9.encode("jq: usage: jq EXPRESSION [path]\n") })
+    ];
+  }
+  const expression = texts[0];
+  const r = opts.flags.r === true;
+  const c = opts.flags.c === true;
+  const s = opts.flags.s === true;
+  const spread = expression.includes("[]");
+  if (paths.length > 0) {
+    const resolved = await resolveGlob(accessor, paths, opts.index ?? void 0);
+    const parts = [];
+    for (const p of resolved) {
+      const raw2 = await read(accessor, p, opts.index ?? void 0);
+      let data2 = parseJsonPath(raw2, p.original);
+      if (s) data2 = Array.isArray(data2) ? data2 : [data2];
+      const result3 = await jqEval(data2, expression.trim());
+      parts.push(formatResults(result3, r, c, spread));
+    }
+    let total = 0;
+    for (const part of parts) total += part.byteLength;
+    const out2 = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+      out2.set(part, offset);
+      offset += part.byteLength;
+    }
+    const result2 = out2;
+    return [result2, new IOResult8()];
+  }
+  const raw = await readStdinAsync2(opts.stdin);
+  if (raw === null) {
+    return [null, new IOResult8({ exitCode: 2, stderr: ENC9.encode("jq: missing input\n") })];
+  }
+  let data = parseJsonAuto(raw);
+  if (s && !Array.isArray(data)) data = [data];
+  const result = await jqEval(data, expression.trim());
+  const out = formatResults(result, r, c, spread);
+  return [out, new IOResult8()];
+}
+var EMAIL_JQ = command8({
+  name: "jq",
+  resource: ResourceName8.EMAIL,
+  spec: specOf7("jq"),
+  fn: jqCommand
+});
+
+// src/commands/builtin/email/ls.ts
+import {
+  FileType as FileType2,
+  IOResult as IOResult9,
+  PathSpec as PathSpec3,
+  ResourceName as ResourceName9,
+  command as command9,
+  humanSize,
+  specOf as specOf8
+} from "@struktoai/mirage-core";
+var ENC10 = new TextEncoder();
+async function lsEntries(accessor, path, allFiles, sortBy, reverse, recursive, listDir, warnings, indexCache) {
+  if (listDir) {
+    const s = await stat(accessor, path, indexCache ?? void 0);
+    return [s];
+  }
+  let entries;
+  try {
+    entries = await readdir(accessor, path, indexCache ?? void 0);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    warnings.push(`ls: cannot access '${path.original}': ${msg}`);
+    return [];
+  }
+  const stats = [];
+  for (const entry of entries) {
+    try {
+      const eSpec = new PathSpec3({
+        original: entry,
+        directory: entry,
+        resolved: false,
+        prefix: path.prefix
+      });
+      const s = await stat(accessor, eSpec, indexCache ?? void 0);
+      if (!allFiles && s.name.startsWith(".")) continue;
+      stats.push(s);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      warnings.push(`ls: cannot access '${entry}': ${msg}`);
+    }
+  }
+  if (sortBy === "size") {
+    stats.sort((a, b) => (a.size ?? 0) - (b.size ?? 0));
+    if (!reverse) stats.reverse();
+  } else {
+    stats.sort((a, b) => a.name.localeCompare(b.name));
+    if (reverse) stats.reverse();
+  }
+  if (recursive) {
+    const subEntries = [];
+    for (const s of stats) {
+      subEntries.push(s);
+      if (s.type === FileType2.DIRECTORY) {
+        const childPath = path.child(s.name);
+        const childSpec = new PathSpec3({
+          original: childPath,
+          directory: childPath,
+          resolved: false,
+          prefix: path.prefix
+        });
+        const sub = await lsEntries(
+          accessor,
+          childSpec,
+          allFiles,
+          sortBy,
+          reverse,
+          recursive,
+          false,
+          warnings,
+          indexCache
+        );
+        subEntries.push(...sub);
+      }
+    }
+    return subEntries;
+  }
+  return stats;
+}
+async function lsCommand(accessor, paths, _texts, opts) {
+  const resolved = await resolveGlob(accessor, paths, opts.index ?? void 0);
+  const targets = resolved.length > 0 ? resolved : [
+    new PathSpec3({
+      original: opts.cwd,
+      directory: opts.cwd,
+      resolved: false,
+      prefix: opts.mountPrefix ?? ""
+    })
+  ];
+  const long = opts.flags.args_l === true;
+  const allFiles = opts.flags.a === true || opts.flags.A === true;
+  const human = opts.flags.h === true;
+  const reverse = opts.flags.r === true;
+  const recursive = opts.flags.R === true;
+  const listDir = opts.flags.d === true;
+  const classify = opts.flags.F === true;
+  const sortBy = opts.flags.S === true ? "size" : "name";
+  const warnings = [];
+  const results = [];
+  for (const p of targets) {
+    let entries;
+    try {
+      entries = await lsEntries(
+        accessor,
+        p,
+        allFiles,
+        sortBy,
+        reverse,
+        recursive,
+        listDir,
+        warnings,
+        opts.index
+      );
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      warnings.push(`ls: cannot access '${p.original}': ${msg}`);
+      continue;
+    }
+    if (long) {
+      for (const e of entries) {
+        const sizeStr = human ? humanSize(e.size ?? 0) : String(e.size ?? 0);
+        results.push(`${e.type ?? "-"}	${sizeStr}	${e.modified ?? ""}	${e.name}`);
+      }
+    } else {
+      for (const e of entries) {
+        const isDir = classify && e.type === FileType2.DIRECTORY;
+        const name = isDir ? e.name + "/" : e.name;
+        results.push(name);
+      }
+    }
+  }
+  const stderr = warnings.length > 0 ? ENC10.encode(warnings.join("\n")) : null;
+  const exitCode = warnings.length > 0 && results.length === 0 ? 1 : 0;
+  const out = ENC10.encode(results.join("\n"));
+  return [out, new IOResult9({ stderr, exitCode })];
+}
+var EMAIL_LS = command9({
+  name: "ls",
+  resource: ResourceName9.EMAIL,
+  spec: specOf8("ls"),
+  fn: lsCommand,
+  provision: metadataProvision
+});
+
+// src/commands/builtin/email/nl.ts
+import {
+  IOResult as IOResult10,
+  ResourceName as ResourceName10,
+  command as command10,
+  readStdinAsync as readStdinAsync3,
+  specOf as specOf9
+} from "@struktoai/mirage-core";
+var ENC11 = new TextEncoder();
+var DEC2 = new TextDecoder("utf-8", { fatal: false });
+function shouldNumber(line, mode, pattern) {
+  if (mode === "n") return false;
+  if (mode === "a") return true;
+  if (mode === "p" && pattern !== null) return pattern.test(line);
+  return line.trim() !== "";
+}
+function pad(n, width) {
+  const s = String(n);
+  return s.length >= width ? s : " ".repeat(width - s.length) + s;
+}
+async function nlCommand(accessor, paths, _texts, opts) {
+  const bRaw = typeof opts.flags.b === "string" ? opts.flags.b : "t";
+  let mode = bRaw;
+  let pattern = null;
+  if (bRaw.startsWith("p")) {
+    mode = "p";
+    pattern = new RegExp(bRaw.slice(1));
+  }
+  const start = typeof opts.flags.v === "string" ? Number.parseInt(opts.flags.v, 10) : 1;
+  const increment = typeof opts.flags.i === "string" ? Number.parseInt(opts.flags.i, 10) : 1;
+  const width = typeof opts.flags.w === "string" ? Number.parseInt(opts.flags.w, 10) : 6;
+  const separator = typeof opts.flags.s === "string" ? opts.flags.s : "	";
+  let raw = null;
+  if (paths.length > 0) {
+    const resolved = await resolveGlob(accessor, paths, opts.index ?? void 0);
+    const first = resolved[0];
+    if (first === void 0) return [null, new IOResult10()];
+    raw = await read(accessor, first, opts.index ?? void 0);
+  } else {
+    raw = await readStdinAsync3(opts.stdin);
+    if (raw === null) {
+      return [null, new IOResult10({ exitCode: 1, stderr: ENC11.encode("nl: missing operand\n") })];
+    }
+  }
+  let num = start;
+  const outLines = [];
+  for (const line of DEC2.decode(raw).split("\n")) {
+    if (shouldNumber(line, mode, pattern)) {
+      outLines.push(`${pad(num, width)}${separator}${line}`);
+      num += increment;
+    } else {
+      outLines.push(`${" ".repeat(width)}${separator}${line}`);
+    }
+  }
+  const out = ENC11.encode(outLines.join("\n") + "\n");
+  return [out, new IOResult10()];
+}
+var EMAIL_NL = command10({
+  name: "nl",
+  resource: ResourceName10.EMAIL,
+  spec: specOf9("nl"),
+  fn: nlCommand
+});
+
+// src/commands/builtin/email/email_read.ts
+import {
+  CommandSpec as CommandSpec2,
+  IOResult as IOResult11,
+  OperandKind as OperandKind2,
+  Option as Option2,
+  ResourceName as ResourceName11,
+  command as command11
+} from "@struktoai/mirage-core";
+var ENC12 = new TextEncoder();
+var SPEC2 = new CommandSpec2({
+  options: [
+    new Option2({ long: "--uid", valueKind: OperandKind2.TEXT }),
+    new Option2({ long: "--folder", valueKind: OperandKind2.TEXT })
+  ]
+});
+async function emailReadCommand(accessor, _paths, _texts, opts) {
+  const uid = typeof opts.flags.uid === "string" ? opts.flags.uid : "";
+  const folder = typeof opts.flags.folder === "string" ? opts.flags.folder : "";
+  if (uid === "") {
+    return [null, new IOResult11({ exitCode: 2, stderr: ENC12.encode("--uid is required\n") })];
+  }
+  if (folder === "") {
+    return [null, new IOResult11({ exitCode: 2, stderr: ENC12.encode("--folder is required\n") })];
+  }
+  const processed = await fetchMessage(accessor, folder, uid);
+  const out = ENC12.encode(JSON.stringify(processed));
+  return [out, new IOResult11()];
+}
+var EMAIL_READ = command11({
+  name: "email-read",
+  resource: ResourceName11.EMAIL,
+  spec: SPEC2,
+  fn: emailReadCommand
+});
+
+// src/commands/builtin/email/realpath.ts
+import {
+  IOResult as IOResult12,
+  PathSpec as PathSpec4,
+  ResourceName as ResourceName12,
+  command as command12,
+  specOf as specOf10
+} from "@struktoai/mirage-core";
+var ENC13 = new TextEncoder();
+function normalize(p) {
+  const isAbs = p.startsWith("/");
+  const segments = p.split("/").filter((s) => s !== "" && s !== ".");
+  const out = [];
+  for (const s of segments) {
+    if (s === "..") {
+      if (out.length > 0) out.pop();
+      else if (!isAbs) out.push("..");
+    } else {
+      out.push(s);
+    }
+  }
+  const joined = out.join("/");
+  return isAbs ? "/" + joined : joined === "" ? "." : joined;
+}
+async function exists(accessor, path, index, prefix) {
+  try {
+    const spec = new PathSpec4({ original: path, directory: path, prefix });
+    await stat(accessor, spec, index ?? void 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function realpathCommand(accessor, paths, _texts, opts) {
+  const prefix = opts.mountPrefix ?? "";
+  const e = opts.flags.e === true;
+  const lines = [];
+  for (const p of paths) {
+    const full = prefix !== "" ? prefix + p.original : p.original;
+    const resolved = normalize(full);
+    if (e && !await exists(accessor, resolved, opts.index, prefix)) {
+      const msg = `realpath: '${p.original}': No such file or directory
+`;
+      return [null, new IOResult12({ exitCode: 1, stderr: ENC13.encode(msg) })];
+    }
+    lines.push(resolved);
+  }
+  const out = ENC13.encode(lines.join("\n") + "\n");
+  return [out, new IOResult12()];
+}
+var EMAIL_REALPATH = command12({
+  name: "realpath",
+  resource: ResourceName12.EMAIL,
+  spec: specOf10("realpath"),
+  fn: realpathCommand
+});
+
+// src/commands/builtin/email/email_reply.ts
+import {
+  CommandSpec as CommandSpec3,
+  IOResult as IOResult13,
+  OperandKind as OperandKind3,
+  Option as Option3,
+  ResourceName as ResourceName13,
+  command as command13
+} from "@struktoai/mirage-core";
+var ENC14 = new TextEncoder();
+var SPEC3 = new CommandSpec3({
+  options: [
+    new Option3({ long: "--uid", valueKind: OperandKind3.TEXT }),
+    new Option3({ long: "--folder", valueKind: OperandKind3.TEXT }),
+    new Option3({ long: "--body", valueKind: OperandKind3.TEXT })
+  ]
+});
+async function emailReplyCommand(accessor, _paths, _texts, opts) {
+  const uid = typeof opts.flags.uid === "string" ? opts.flags.uid : "";
+  const folder = typeof opts.flags.folder === "string" ? opts.flags.folder : "";
+  const body = typeof opts.flags.body === "string" ? opts.flags.body : "";
+  if (uid === "") {
+    return [null, new IOResult13({ exitCode: 2, stderr: ENC14.encode("--uid is required\n") })];
+  }
+  if (folder === "") {
+    return [null, new IOResult13({ exitCode: 2, stderr: ENC14.encode("--folder is required\n") })];
+  }
+  if (body === "") {
+    return [null, new IOResult13({ exitCode: 2, stderr: ENC14.encode("--body is required\n") })];
+  }
+  const original = await fetchMessage(accessor, folder, uid);
+  const result = await replyMessage(accessor.config, original, body);
+  const out = ENC14.encode(JSON.stringify(result));
+  return [out, new IOResult13()];
+}
+var EMAIL_REPLY = command13({
+  name: "email-reply",
+  resource: ResourceName13.EMAIL,
+  spec: SPEC3,
+  fn: emailReplyCommand,
+  write: true
+});
+
+// src/commands/builtin/email/email_reply_all.ts
+import {
+  CommandSpec as CommandSpec4,
+  IOResult as IOResult14,
+  OperandKind as OperandKind4,
+  Option as Option4,
+  ResourceName as ResourceName14,
+  command as command14
+} from "@struktoai/mirage-core";
+var ENC15 = new TextEncoder();
+var SPEC4 = new CommandSpec4({
+  options: [
+    new Option4({ long: "--uid", valueKind: OperandKind4.TEXT }),
+    new Option4({ long: "--folder", valueKind: OperandKind4.TEXT }),
+    new Option4({ long: "--body", valueKind: OperandKind4.TEXT })
+  ]
+});
+async function emailReplyAllCommand(accessor, _paths, _texts, opts) {
+  const uid = typeof opts.flags.uid === "string" ? opts.flags.uid : "";
+  const folder = typeof opts.flags.folder === "string" ? opts.flags.folder : "";
+  const body = typeof opts.flags.body === "string" ? opts.flags.body : "";
+  if (uid === "") {
+    return [null, new IOResult14({ exitCode: 2, stderr: ENC15.encode("--uid is required\n") })];
+  }
+  if (folder === "") {
+    return [null, new IOResult14({ exitCode: 2, stderr: ENC15.encode("--folder is required\n") })];
+  }
+  if (body === "") {
+    return [null, new IOResult14({ exitCode: 2, stderr: ENC15.encode("--body is required\n") })];
+  }
+  const original = await fetchMessage(accessor, folder, uid);
+  const result = await replyAllMessage(accessor.config, original, body);
+  const out = ENC15.encode(JSON.stringify(result));
+  return [out, new IOResult14()];
+}
+var EMAIL_REPLY_ALL = command14({
+  name: "email-reply-all",
+  resource: ResourceName14.EMAIL,
+  spec: SPEC4,
+  fn: emailReplyAllCommand,
+  write: true
+});
+
+// src/commands/builtin/email/rg.ts
+import {
+  IOResult as IOResult15,
+  PathSpec as PathSpec5,
+  ResourceName as ResourceName15,
+  command as command15,
+  compilePattern as compilePattern2,
+  grepLines as grepLines2,
+  readStdinAsync as readStdinAsync4,
+  specOf as specOf11
+} from "@struktoai/mirage-core";
+var ENC16 = new TextEncoder();
+var DEC3 = new TextDecoder("utf-8", { fatal: false });
+async function collectFiles(accessor, path, index) {
+  if (path.original.endsWith(".json") || path.original.endsWith(".jsonl")) {
+    return [path.original];
+  }
+  let children;
+  try {
+    children = await readdir(accessor, path, index ?? void 0);
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const child of children) {
+    if (child.endsWith(".email.json")) {
+      files.push(child);
+    } else {
+      const childSpec = new PathSpec5({
+        original: child,
+        directory: child,
+        resolved: false,
+        prefix: path.prefix
+      });
+      files.push(...await collectFiles(accessor, childSpec, index));
+    }
+  }
+  return files;
+}
+async function rgCommand(accessor, paths, texts, opts) {
+  if (texts.length === 0 || texts[0] === void 0) {
+    return [
+      null,
+      new IOResult15({ exitCode: 2, stderr: ENC16.encode("rg: usage: rg [flags] pattern [path]\n") })
+    ];
+  }
+  const pattern = texts[0];
+  const ignoreCase = opts.flags.i === true;
+  const invert = opts.flags.v === true;
+  const lineNumbers = opts.flags.n === true;
+  const countOnly = opts.flags.c === true;
+  const filesOnly = opts.flags.args_l === true || opts.flags.l === true;
+  const wholeWord = opts.flags.w === true;
+  const fixedString = opts.flags.F === true;
+  const onlyMatching = opts.flags.o === true;
+  const maxCount = typeof opts.flags.m === "string" ? Number.parseInt(opts.flags.m, 10) : null;
+  const hidden = opts.flags.hidden === true;
+  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) {
+        const filePrefix2 = first.prefix !== "" ? first.prefix : "";
+        const pairs = await searchAndFormat(accessor, scope, pattern, filePrefix2, maxCount ?? 50);
+        const lines2 = [];
+        for (const [vfsPath, msgText] of pairs) {
+          const matched2 = grepLines2(vfsPath, [msgText], pat, lineOpts);
+          for (const line of matched2) lines2.push(`${vfsPath}:${line}`);
+        }
+        if (lines2.length === 0) return [new Uint8Array(0), new IOResult15({ exitCode: 1 })];
+        const out3 = ENC16.encode(lines2.join("\n") + "\n");
+        return [out3, new IOResult15()];
+      }
+    }
+    const resolved = await resolveGlob(accessor, paths, opts.index ?? void 0);
+    const filePrefix = resolved[0]?.prefix ?? "";
+    const blobPaths = [];
+    for (const p of resolved) blobPaths.push(...await collectFiles(accessor, p, opts.index));
+    const sortedUnique = [...new Set(blobPaths)].sort();
+    const allResults = [];
+    let anyMatch = false;
+    for (const bp of sortedUnique) {
+      if (!hidden && bp.split("/").some((part) => part.startsWith("."))) continue;
+      let data;
+      try {
+        const spec = new PathSpec5({
+          original: bp,
+          directory: bp,
+          resolved: true,
+          prefix: filePrefix
+        });
+        data = await read(accessor, spec, opts.index ?? void 0);
+      } catch {
+        continue;
+      }
+      const text = DEC3.decode(data);
+      if (text === "") continue;
+      const lines2 = text.split("\n");
+      if (lines2.length > 0 && lines2[lines2.length - 1] === "") lines2.pop();
+      const matched2 = grepLines2(bp, lines2, pat, lineOpts);
+      if (matched2.length === 0) continue;
+      anyMatch = true;
+      if (filesOnly) {
+        allResults.push(bp);
+        continue;
+      }
+      if (countOnly) {
+        allResults.push(`${bp}:${String(matched2.length)}`);
+        continue;
+      }
+      for (const line of matched2) allResults.push(`${bp}:${line}`);
+    }
+    if (!anyMatch) return [new Uint8Array(0), new IOResult15({ exitCode: 1 })];
+    const out2 = ENC16.encode(allResults.join("\n"));
+    return [out2, new IOResult15()];
+  }
+  const raw = await readStdinAsync4(opts.stdin);
+  if (raw === null) {
+    return [
+      null,
+      new IOResult15({ exitCode: 2, stderr: ENC16.encode("rg: usage: rg [flags] pattern path\n") })
+    ];
+  }
+  const lines = DEC3.decode(raw).split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  const matched = grepLines2("<stdin>", lines, pat, lineOpts);
+  if (matched.length === 0) return [new Uint8Array(0), new IOResult15({ exitCode: 1 })];
+  if (countOnly) return [ENC16.encode(String(matched.length)), new IOResult15()];
+  const out = ENC16.encode(matched.join("\n"));
+  return [out, new IOResult15()];
+}
+var EMAIL_RG = command15({
+  name: "rg",
+  resource: ResourceName15.EMAIL,
+  spec: specOf11("rg"),
+  fn: rgCommand
+});
+
+// src/commands/builtin/email/email_send.ts
+import {
+  CommandSpec as CommandSpec5,
+  IOResult as IOResult16,
+  OperandKind as OperandKind5,
+  Option as Option5,
+  ResourceName as ResourceName16,
+  command as command16
+} from "@struktoai/mirage-core";
+var ENC17 = new TextEncoder();
+var SPEC5 = new CommandSpec5({
+  options: [
+    new Option5({ long: "--to", valueKind: OperandKind5.TEXT }),
+    new Option5({ long: "--subject", valueKind: OperandKind5.TEXT }),
+    new Option5({ long: "--body", valueKind: OperandKind5.TEXT })
+  ]
+});
+async function emailSendCommand(accessor, _paths, _texts, opts) {
+  const to = typeof opts.flags.to === "string" ? opts.flags.to : "";
+  const subject = typeof opts.flags.subject === "string" ? opts.flags.subject : "";
+  const body = typeof opts.flags.body === "string" ? opts.flags.body : "";
+  if (to === "") {
+    return [null, new IOResult16({ exitCode: 2, stderr: ENC17.encode("--to is required\n") })];
+  }
+  if (subject === "") {
+    return [null, new IOResult16({ exitCode: 2, stderr: ENC17.encode("--subject is required\n") })];
+  }
+  if (body === "") {
+    return [null, new IOResult16({ exitCode: 2, stderr: ENC17.encode("--body is required\n") })];
+  }
+  const result = await sendMessage(accessor.config, to, subject, body);
+  const out = ENC17.encode(JSON.stringify(result));
+  return [out, new IOResult16()];
+}
+var EMAIL_SEND = command16({
+  name: "email-send",
+  resource: ResourceName16.EMAIL,
+  spec: SPEC5,
+  fn: emailSendCommand,
+  write: true
+});
+
+// src/commands/builtin/email/stat.ts
+import {
+  FileType as FileType3,
+  IOResult as IOResult17,
+  ResourceName as ResourceName17,
+  command as command17,
+  specOf as specOf12
+} from "@struktoai/mirage-core";
+var ENC18 = new TextEncoder();
+var TYPE_LABELS = {
+  [FileType3.DIRECTORY]: "directory",
+  [FileType3.TEXT]: "regular file",
+  [FileType3.BINARY]: "regular file",
+  [FileType3.JSON]: "regular file",
+  [FileType3.CSV]: "regular file"
+};
+function formatStat(fmt, s) {
+  return fmt.replace(/%(.)/g, (_, spec) => {
+    if (spec === "n") return s.name;
+    if (spec === "s") return String(s.size ?? 0);
+    if (spec === "F")
+      return s.type !== null ? TYPE_LABELS[s.type] ?? "regular file" : "regular file";
+    if (spec === "y") return s.modified ?? "";
+    return "?";
+  });
+}
+async function statCommand(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult17({ exitCode: 1, stderr: ENC18.encode("stat: missing operand\n") })];
+  }
+  const resolved = await resolveGlob(accessor, paths, opts.index ?? void 0);
+  const fmt = typeof opts.flags.c === "string" ? opts.flags.c : typeof opts.flags.f === "string" ? opts.flags.f : null;
+  const lines = [];
+  for (const p of resolved) {
+    const s = await stat(accessor, p, opts.index ?? void 0);
+    if (fmt !== null) {
+      lines.push(formatStat(fmt, s));
+    } else {
+      const sizeStr = s.size === null ? "None" : String(s.size);
+      const modStr = s.modified ?? "None";
+      const typeStr = s.type ?? "None";
+      lines.push(`name=${s.name} size=${sizeStr} modified=${modStr} type=${typeStr}`);
+    }
+  }
+  const out = ENC18.encode(lines.join("\n"));
+  return [out, new IOResult17()];
+}
+var EMAIL_STAT = command17({
+  name: "stat",
+  resource: ResourceName17.EMAIL,
+  spec: specOf12("stat"),
+  fn: statCommand,
+  provision: metadataProvision
+});
+
+// src/commands/builtin/email/tail.ts
+import {
+  IOResult as IOResult18,
+  ResourceName as ResourceName18,
+  command as command18,
+  parseN,
+  readStdinAsync as readStdinAsync5,
+  specOf as specOf13,
+  tailBytes
+} from "@struktoai/mirage-core";
+var ENC19 = new TextEncoder();
+async function tailCommand(accessor, paths, _texts, opts) {
+  const [lines, plusMode] = parseN(typeof opts.flags.n === "string" ? opts.flags.n : null);
+  const bytesMode = typeof opts.flags.c === "string" ? Number.parseInt(opts.flags.c, 10) : null;
+  if (paths.length > 0) {
+    const resolved = await resolveGlob(accessor, paths, opts.index ?? void 0);
+    const first = resolved[0];
+    if (first === void 0) return [null, new IOResult18()];
+    const raw2 = await read(accessor, first, opts.index ?? void 0);
+    const out2 = tailBytes(raw2, lines, bytesMode, plusMode);
+    return [out2, new IOResult18()];
+  }
+  const raw = await readStdinAsync5(opts.stdin);
+  if (raw === null) {
+    return [null, new IOResult18({ exitCode: 1, stderr: ENC19.encode("tail: missing operand\n") })];
+  }
+  const out = tailBytes(raw, lines, bytesMode, plusMode);
+  return [out, new IOResult18()];
+}
+var EMAIL_TAIL = command18({
+  name: "tail",
+  resource: ResourceName18.EMAIL,
+  spec: specOf13("tail"),
+  fn: tailCommand,
+  provision: fileReadProvision
+});
+
+// src/commands/builtin/email/tree.ts
+import {
+  FileType as FileType4,
+  IOResult as IOResult19,
+  PathSpec as PathSpec6,
+  ResourceName as ResourceName19,
+  command as command19,
+  specOf as specOf14
+} from "@struktoai/mirage-core";
+var ENC20 = new TextEncoder();
+function fnmatch3(name, pattern) {
+  const re = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\?/g, ".").replace(/\*/g, ".*");
+  return new RegExp(`^${re}$`).test(name);
+}
+async function treeRecurse(accessor, path, prefix, depth, treeOpts, warnings, indexCache) {
+  const lines = [];
+  let entries;
+  try {
+    entries = await readdir(accessor, path, indexCache ?? void 0);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    warnings.push(`tree: '${path.original}': ${msg}`);
+    return lines;
+  }
+  const filtered = [];
+  for (const entry of entries) {
+    try {
+      const entrySpec = new PathSpec6({
+        original: entry,
+        directory: entry,
+        resolved: false,
+        prefix: path.prefix
+      });
+      const s = await stat(accessor, entrySpec, indexCache ?? void 0);
+      if (!treeOpts.showHidden && s.name.startsWith(".")) continue;
+      if (treeOpts.ignorePattern !== null && fnmatch3(s.name, treeOpts.ignorePattern)) continue;
+      if (treeOpts.dirsOnly && s.type !== FileType4.DIRECTORY) continue;
+      const notDir = s.type !== FileType4.DIRECTORY;
+      if (treeOpts.matchPattern !== null && notDir && !fnmatch3(s.name, treeOpts.matchPattern))
+        continue;
+      filtered.push([entrySpec, s]);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      warnings.push(`tree: '${entry}': ${msg}`);
+    }
+  }
+  for (let i = 0; i < filtered.length; i++) {
+    const pair = filtered[i];
+    if (pair === void 0) continue;
+    const [entrySpec, s] = pair;
+    const isLast = i === filtered.length - 1;
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    lines.push(prefix + connector + s.name);
+    if (s.type === FileType4.DIRECTORY) {
+      if (treeOpts.maxDepth !== null && depth >= treeOpts.maxDepth) continue;
+      const extension = isLast ? "    " : "\u2502   ";
+      const sub = await treeRecurse(
+        accessor,
+        entrySpec,
+        prefix + extension,
+        depth + 1,
+        treeOpts,
+        warnings,
+        indexCache
+      );
+      lines.push(...sub);
+    }
+  }
+  return lines;
+}
+async function treeCommand(accessor, paths, _texts, opts) {
+  const resolved = await resolveGlob(accessor, paths, opts.index ?? void 0);
+  const p0 = resolved[0] ?? new PathSpec6({
+    original: opts.cwd,
+    directory: opts.cwd,
+    resolved: false,
+    prefix: opts.mountPrefix ?? ""
+  });
+  const maxDepth = typeof opts.flags.L === "string" ? Number.parseInt(opts.flags.L, 10) : null;
+  const treeOpts = {
+    maxDepth,
+    showHidden: opts.flags.a === true,
+    ignorePattern: typeof opts.flags.args_I === "string" ? opts.flags.args_I : null,
+    dirsOnly: opts.flags.d === true,
+    matchPattern: typeof opts.flags.P === "string" ? opts.flags.P : null
+  };
+  const warnings = [];
+  const results = await treeRecurse(accessor, p0, "", 0, treeOpts, warnings, opts.index);
+  const out = ENC20.encode(results.join("\n"));
+  const stderr = warnings.length > 0 ? ENC20.encode(warnings.join("\n")) : null;
+  return [out, new IOResult19({ stderr })];
+}
+var EMAIL_TREE = command19({
+  name: "tree",
+  resource: ResourceName19.EMAIL,
+  spec: specOf14("tree"),
+  fn: treeCommand
+});
+
+// src/commands/builtin/email/email_triage.ts
+import {
+  CommandSpec as CommandSpec6,
+  IOResult as IOResult20,
+  OperandKind as OperandKind6,
+  Option as Option6,
+  ResourceName as ResourceName20,
+  command as command20
+} from "@struktoai/mirage-core";
+var ENC21 = new TextEncoder();
+var SPEC6 = new CommandSpec6({
+  options: [
+    new Option6({ long: "--folder", valueKind: OperandKind6.TEXT }),
+    new Option6({ long: "--max", valueKind: OperandKind6.TEXT }),
+    new Option6({ long: "--unseen" }),
+    new Option6({ long: "--subject", valueKind: OperandKind6.TEXT }),
+    new Option6({ long: "--from", valueKind: OperandKind6.TEXT }),
+    new Option6({ long: "--to", valueKind: OperandKind6.TEXT }),
+    new Option6({ long: "--body", valueKind: OperandKind6.TEXT }),
+    new Option6({ long: "--since", valueKind: OperandKind6.TEXT }),
+    new Option6({ long: "--before", valueKind: OperandKind6.TEXT })
+  ]
+});
+async function emailTriageCommand(accessor, _paths, _texts, opts) {
+  const folder = typeof opts.flags.folder === "string" ? opts.flags.folder : "INBOX";
+  const maxResults = typeof opts.flags.max === "string" ? Number.parseInt(opts.flags.max, 10) : 20;
+  const uids = await searchMessages(
+    accessor,
+    folder,
+    {
+      text: typeof opts.flags.body === "string" ? opts.flags.body : null,
+      subject: typeof opts.flags.subject === "string" ? opts.flags.subject : null,
+      fromAddr: typeof opts.flags.from === "string" ? opts.flags.from : null,
+      toAddr: typeof opts.flags.to === "string" ? opts.flags.to : null,
+      since: typeof opts.flags.since === "string" ? opts.flags.since : null,
+      before: typeof opts.flags.before === "string" ? opts.flags.before : null,
+      unseen: opts.flags.unseen === true
+    },
+    maxResults
+  );
+  if (uids.length === 0) {
+    const out2 = ENC21.encode("[]");
+    return [out2, new IOResult20()];
+  }
+  const headers = await fetchHeaders(accessor, folder, uids);
+  const out = ENC21.encode(JSON.stringify(headers));
+  return [out, new IOResult20()];
+}
+var EMAIL_TRIAGE = command20({
+  name: "email-triage",
+  resource: ResourceName20.EMAIL,
+  spec: SPEC6,
+  fn: emailTriageCommand
+});
+
+// src/commands/builtin/email/wc.ts
+import {
+  IOResult as IOResult21,
+  ResourceName as ResourceName21,
+  command as command21,
+  readStdinAsync as readStdinAsync6,
+  specOf as specOf15
+} from "@struktoai/mirage-core";
+var ENC22 = new TextEncoder();
+var DEC4 = new TextDecoder("utf-8", { fatal: false });
+function countLines(text) {
+  let n = 0;
+  for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) n += 1;
+  return n;
+}
+function countWords(text) {
+  const trimmed = text.trim();
+  if (trimmed === "") return 0;
+  return trimmed.split(/\s+/).length;
+}
+function maxLineLen(text) {
+  let max = 0;
+  for (const line of text.split("\n")) if (line.length > max) max = line.length;
+  return max;
+}
+async function wcCommand(accessor, paths, _texts, opts) {
+  let data = null;
+  if (paths.length > 0) {
+    const resolved = await resolveGlob(accessor, paths, opts.index ?? void 0);
+    const first = resolved[0];
+    if (first === void 0) return [null, new IOResult21()];
+    data = await read(accessor, first, opts.index ?? void 0);
+  } else {
+    data = await readStdinAsync6(opts.stdin);
+    if (data === null) {
+      return [null, new IOResult21({ exitCode: 1, stderr: ENC22.encode("wc: missing operand\n") })];
+    }
+  }
+  const text = DEC4.decode(data);
+  const lineCount = countLines(text);
+  const wordCount = countWords(text);
+  const byteCount = data.byteLength;
+  if (opts.flags.L === true) {
+    const out2 = ENC22.encode(String(maxLineLen(text)));
+    return [out2, new IOResult21()];
+  }
+  if (opts.flags.args_l === true) return [ENC22.encode(String(lineCount)), new IOResult21()];
+  if (opts.flags.w === true) return [ENC22.encode(String(wordCount)), new IOResult21()];
+  if (opts.flags.m === true) return [ENC22.encode(String(text.length)), new IOResult21()];
+  if (opts.flags.c === true) return [ENC22.encode(String(byteCount)), new IOResult21()];
+  const out = ENC22.encode(
+    `${String(lineCount)}	${String(wordCount)}	${String(byteCount)}`
+  );
+  return [out, new IOResult21()];
+}
+var EMAIL_WC = command21({
+  name: "wc",
+  resource: ResourceName21.EMAIL,
+  spec: specOf15("wc"),
+  fn: wcCommand,
+  provision: fileReadProvision
+});
+
+// src/commands/builtin/email/index.ts
+var EMAIL_COMMANDS = [
+  ...EMAIL_BASENAME,
+  ...EMAIL_CAT,
+  ...EMAIL_DIRNAME,
+  ...EMAIL_FIND,
+  ...EMAIL_GREP,
+  ...EMAIL_HEAD,
+  ...EMAIL_JQ,
+  ...EMAIL_LS,
+  ...EMAIL_NL,
+  ...EMAIL_REALPATH,
+  ...EMAIL_RG,
+  ...EMAIL_STAT,
+  ...EMAIL_TAIL,
+  ...EMAIL_TREE,
+  ...EMAIL_WC,
+  ...EMAIL_SEND,
+  ...EMAIL_REPLY,
+  ...EMAIL_REPLY_ALL,
+  ...EMAIL_FORWARD,
+  ...EMAIL_TRIAGE,
+  ...EMAIL_READ
+];
+
+// src/ops/email/read.ts
+import { ResourceName as ResourceName22 } from "@struktoai/mirage-core";
+var readOp = {
+  name: "read",
+  resource: ResourceName22.EMAIL,
+  filetype: null,
+  write: false,
+  fn: (accessor, path, _args, kwargs) => {
+    return read(accessor, path, kwargs.index);
+  }
+};
+
+// src/ops/email/readdir.ts
+import { ResourceName as ResourceName23 } from "@struktoai/mirage-core";
+var readdirOp = {
+  name: "readdir",
+  resource: ResourceName23.EMAIL,
+  filetype: null,
+  write: false,
+  fn: (accessor, path, _args, kwargs) => {
+    return readdir(accessor, path, kwargs.index);
+  }
+};
+
+// src/ops/email/stat.ts
+import { ResourceName as ResourceName24 } from "@struktoai/mirage-core";
+var statOp = {
+  name: "stat",
+  resource: ResourceName24.EMAIL,
+  filetype: null,
+  write: false,
+  fn: (accessor, path, _args, kwargs) => {
+    return stat(accessor, path, kwargs.index);
+  }
+};
+
+// src/ops/email/index.ts
+var EMAIL_OPS = [readdirOp, readOp, statOp];
+
+// 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.`;
+var EMAIL_WRITE_PROMPT = `  Write commands:
+    email-send "to@email.com" "subject" "body"
+    email-reply <email-path> "reply body"
+    email-forward <email-path> "to@email.com"`;
+
+// src/resource/email/email.ts
+var EmailResource = class {
+  kind = ResourceName25.EMAIL;
+  isRemote = true;
+  indexTtl = 86400;
+  prompt = EMAIL_PROMPT;
+  config;
+  accessor;
+  index;
+  constructor(config) {
+    this.config = config;
+    this.accessor = new EmailAccessor(config);
+    this.index = new RAMIndexCacheStore({ ttl: 86400 });
+  }
+  open() {
+    return Promise.resolve();
+  }
+  async close() {
+    await this.accessor.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);
+  }
+  async fingerprint(p) {
+    const lookup = await this.index.get(p.original);
+    return lookup.entry?.remoteTime ?? null;
+  }
+  glob(paths, prefix = "") {
+    const effective = prefix !== "" ? paths.map(
+      (p) => p.prefix !== "" ? p : new PathSpec7({
+        original: p.original,
+        directory: p.directory,
+        ...p.pattern !== null ? { pattern: p.pattern } : {},
+        resolved: p.resolved,
+        prefix
+      })
+    ) : paths;
+    return resolveGlob(this.accessor, effective, this.index);
+  }
+  getState() {
+    return Promise.resolve({
+      type: this.kind,
+      needsOverride: true,
+      redactedFields: ["password"],
+      config: redactEmailConfig(this.config)
+    });
+  }
+  loadState(_state) {
+    return Promise.resolve();
+  }
+};
+
+export {
+  EmailAccessor,
+  EMAIL_COMMANDS,
+  EMAIL_OPS,
+  EMAIL_PROMPT,
+  EMAIL_WRITE_PROMPT,
+  EmailResource
+};
+//# sourceMappingURL=chunk-OYJXYJTE.js.map