aamp-wechat-bridge 0.1.0

package/dist/index.js

@@ -0,0 +1,3541 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import readline2 from "node:readline/promises";
+import { stdin as input2, stdout as output2, argv, exit } from "node:process";
+import qrcodeTerminal from "qrcode-terminal";
+
+// src/config.ts
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { stdin as input, stdout as output } from "node:process";
+
+// ../sdk/dist/jmap-push.js
+import WebSocket from "ws";
+
+// ../sdk/dist/types.js
+var AAMP_PROTOCOL_VERSION = "1.1";
+var AAMP_HEADER = {
+  VERSION: "X-AAMP-Version",
+  INTENT: "X-AAMP-Intent",
+  TASK_ID: "X-AAMP-TaskId",
+  SESSION_KEY: "X-AAMP-Session-Key",
+  CONTEXT_LINKS: "X-AAMP-ContextLinks",
+  DISPATCH_CONTEXT: "X-AAMP-Dispatch-Context",
+  PRIORITY: "X-AAMP-Priority",
+  EXPIRES_AT: "X-AAMP-Expires-At",
+  STATUS: "X-AAMP-Status",
+  OUTPUT: "X-AAMP-Output",
+  ERROR_MSG: "X-AAMP-ErrorMsg",
+  STRUCTURED_RESULT: "X-AAMP-StructuredResult",
+  QUESTION: "X-AAMP-Question",
+  BLOCKED_REASON: "X-AAMP-BlockedReason",
+  SUGGESTED_OPTIONS: "X-AAMP-SuggestedOptions",
+  STREAM_ID: "X-AAMP-Stream-Id",
+  PARENT_TASK_ID: "X-AAMP-ParentTaskId",
+  CARD_SUMMARY: "X-AAMP-Card-Summary"
+};
+
+// ../sdk/dist/parser.js
+function normalizeBodyText(value) {
+  return value?.replace(/\r\n/g, "\n").trim() ?? "";
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractBodySection(bodyText, label, nextLabels) {
+  if (!bodyText)
+    return "";
+  const nextPattern = nextLabels.length ? `(?=\\n(?:${nextLabels.map(escapeRegex).join("|")}):|$)` : "$";
+  const pattern = new RegExp(`(?:^|\\n)${escapeRegex(label)}:\\s*([\\s\\S]*?)${nextPattern}`, "i");
+  const match = pattern.exec(bodyText);
+  return match?.[1]?.trim() ?? "";
+}
+function parseSuggestedOptionsBlock(block) {
+  if (!block.trim())
+    return [];
+  return block.split("\n").map((line) => line.replace(/^\s*(?:[-*]|\d+\.)\s*/, "").trim()).filter(Boolean);
+}
+function parseTaskResultBody(bodyText) {
+  const normalized = normalizeBodyText(bodyText);
+  if (!normalized)
+    return { output: "" };
+  const output3 = extractBodySection(normalized, "Output", ["Error"]);
+  const errorMsg = extractBodySection(normalized, "Error", []);
+  if (output3 || errorMsg) {
+    return { output: output3, ...errorMsg ? { errorMsg } : {} };
+  }
+  return { output: normalized };
+}
+function parseTaskHelpBody(bodyText) {
+  const normalized = normalizeBodyText(bodyText);
+  if (!normalized) {
+    return { question: "", blockedReason: "", suggestedOptions: [] };
+  }
+  const question = extractBodySection(normalized, "Question", ["Blocked reason", "Suggested options"]);
+  const blockedReason = extractBodySection(normalized, "Blocked reason", ["Suggested options"]);
+  const suggestedOptions = parseSuggestedOptionsBlock(extractBodySection(normalized, "Suggested options", []));
+  if (question || blockedReason || suggestedOptions.length) {
+    return { question, blockedReason, suggestedOptions };
+  }
+  return { question: normalized, blockedReason: "", suggestedOptions: [] };
+}
+function decodeMimeEncodedWordSegment(segment) {
+  const match = /^=\?([^?]+)\?([bBqQ])\?([^?]*)\?=$/.exec(segment);
+  if (!match)
+    return segment;
+  const [, charsetRaw, encodingRaw, body] = match;
+  const charset = charsetRaw.toLowerCase();
+  const encoding = encodingRaw.toUpperCase();
+  try {
+    if (encoding === "B") {
+      const buf = Buffer.from(body, "base64");
+      return buf.toString(charset === "utf-8" || charset === "utf8" ? "utf8" : "utf8");
+    }
+    const normalized = body.replace(/_/g, " ").replace(/=([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+    const bytes = Buffer.from(normalized, "binary");
+    return bytes.toString(charset === "utf-8" || charset === "utf8" ? "utf8" : "utf8");
+  } catch {
+    return segment;
+  }
+}
+function decodeMimeEncodedWords(value) {
+  if (!value || !value.includes("=?"))
+    return value ?? "";
+  const collapsed = value.replace(/\r?\n[ \t]+/g, " ");
+  const decoded = collapsed.replace(/=\?[^?]+\?[bBqQ]\?[^?]*\?=/g, (segment) => decodeMimeEncodedWordSegment(segment));
+  return decoded.replace(/\s{2,}/g, " ").trim();
+}
+function normalizeHeaders(headers) {
+  return Object.fromEntries(Object.entries(headers).map(([k, v]) => [
+    k.toLowerCase(),
+    Array.isArray(v) ? v[0] : v
+  ]));
+}
+function getAampHeader(headers, headerName) {
+  return headers[headerName.toLowerCase()];
+}
+var DISPATCH_CONTEXT_KEY_RE = /^[a-z0-9_-]+$/;
+function parseDispatchContextHeader(value) {
+  if (!value)
+    return void 0;
+  const context = {};
+  for (const part of value.split(";")) {
+    const segment = part.trim();
+    if (!segment)
+      continue;
+    const eqIdx = segment.indexOf("=");
+    if (eqIdx <= 0)
+      continue;
+    const rawKey = segment.slice(0, eqIdx).trim();
+    const rawValue = segment.slice(eqIdx + 1).trim();
+    if (!DISPATCH_CONTEXT_KEY_RE.test(rawKey))
+      continue;
+    try {
+      context[rawKey] = decodeURIComponent(rawValue);
+    } catch {
+      context[rawKey] = rawValue;
+    }
+  }
+  return Object.keys(context).length ? context : void 0;
+}
+function serializeDispatchContextHeader(context) {
+  if (!context)
+    return void 0;
+  const parts = Object.entries(context).flatMap(([key, value]) => {
+    const normalizedKey = key.trim().toLowerCase();
+    if (!DISPATCH_CONTEXT_KEY_RE.test(normalizedKey))
+      return [];
+    const normalizedValue = String(value ?? "").trim();
+    if (!normalizedValue)
+      return [];
+    return `${normalizedKey}=${encodeURIComponent(normalizedValue)}`;
+  });
+  return parts.length ? parts.join("; ") : void 0;
+}
+function decodeStructuredResult(value) {
+  if (!value)
+    return void 0;
+  try {
+    const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+    const padding = normalized.length % 4 === 0 ? "" : "=".repeat(4 - normalized.length % 4);
+    const decoded = Buffer.from(normalized + padding, "base64").toString("utf-8");
+    return JSON.parse(decoded);
+  } catch {
+    return void 0;
+  }
+}
+function encodeStructuredResult(value) {
+  if (!value)
+    return void 0;
+  const json = JSON.stringify(value);
+  return Buffer.from(json, "utf-8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function parseAampHeaders(meta) {
+  const headers = normalizeHeaders(meta.headers);
+  const intent = getAampHeader(headers, AAMP_HEADER.INTENT);
+  const taskId = getAampHeader(headers, AAMP_HEADER.TASK_ID);
+  const protocolVersion = getAampHeader(headers, AAMP_HEADER.VERSION) ?? AAMP_PROTOCOL_VERSION;
+  if (!intent || !taskId)
+    return null;
+  const from = meta.from.replace(/^<|>$/g, "");
+  const to = meta.to.replace(/^<|>$/g, "");
+  const decodedSubject = decodeMimeEncodedWords(meta.subject);
+  if (intent === "task.dispatch") {
+    const contextLinksStr = getAampHeader(headers, AAMP_HEADER.CONTEXT_LINKS) ?? "";
+    const dispatchContext = parseDispatchContextHeader(getAampHeader(headers, AAMP_HEADER.DISPATCH_CONTEXT));
+    const sessionKey = getAampHeader(headers, AAMP_HEADER.SESSION_KEY);
+    const parentTaskId = getAampHeader(headers, AAMP_HEADER.PARENT_TASK_ID);
+    const priority = getAampHeader(headers, AAMP_HEADER.PRIORITY) ?? "normal";
+    const expiresAt = getAampHeader(headers, AAMP_HEADER.EXPIRES_AT);
+    const dispatch = {
+      protocolVersion,
+      intent: "task.dispatch",
+      taskId,
+      ...sessionKey ? { sessionKey } : {},
+      title: decodedSubject.replace(/^\[AAMP Task\]\s*/, "").trim() || "Untitled Task",
+      priority: priority === "urgent" || priority === "high" ? priority : "normal",
+      ...expiresAt ? { expiresAt } : {},
+      contextLinks: contextLinksStr ? contextLinksStr.split(",").map((s) => s.trim()).filter(Boolean) : [],
+      ...dispatchContext ? { dispatchContext } : {},
+      ...parentTaskId ? { parentTaskId } : {},
+      from,
+      to,
+      messageId: meta.messageId,
+      subject: meta.subject,
+      bodyText: ""
+      // filled in by jmap-push.ts after parsing
+    };
+    return dispatch;
+  }
+  if (intent === "task.cancel") {
+    const cancel = {
+      protocolVersion,
+      intent: "task.cancel",
+      taskId,
+      from,
+      to,
+      messageId: meta.messageId,
+      subject: meta.subject,
+      bodyText: ""
+    };
+    return cancel;
+  }
+  if (intent === "task.result") {
+    const parsedBody = parseTaskResultBody(meta.bodyText);
+    const status = getAampHeader(headers, AAMP_HEADER.STATUS) ?? "completed";
+    const output3 = getAampHeader(headers, AAMP_HEADER.OUTPUT) ?? parsedBody.output;
+    const errorMsg = getAampHeader(headers, AAMP_HEADER.ERROR_MSG) ?? parsedBody.errorMsg;
+    const structuredResult = decodeStructuredResult(getAampHeader(headers, AAMP_HEADER.STRUCTURED_RESULT));
+    const result = {
+      protocolVersion,
+      intent: "task.result",
+      taskId,
+      status,
+      output: decodeMimeEncodedWords(output3),
+      errorMsg: errorMsg ? decodeMimeEncodedWords(errorMsg) : errorMsg,
+      structuredResult,
+      from,
+      to,
+      messageId: meta.messageId
+    };
+    return result;
+  }
+  if (intent === "task.help_needed") {
+    const parsedBody = parseTaskHelpBody(meta.bodyText);
+    const question = getAampHeader(headers, AAMP_HEADER.QUESTION) ?? parsedBody.question;
+    const blockedReason = getAampHeader(headers, AAMP_HEADER.BLOCKED_REASON) ?? parsedBody.blockedReason;
+    const suggestedOptionsStr = getAampHeader(headers, AAMP_HEADER.SUGGESTED_OPTIONS) ?? "";
+    const help = {
+      protocolVersion,
+      intent: "task.help_needed",
+      taskId,
+      question: decodeMimeEncodedWords(question),
+      blockedReason: decodeMimeEncodedWords(blockedReason),
+      suggestedOptions: suggestedOptionsStr ? suggestedOptionsStr.split("|").map((s) => decodeMimeEncodedWords(s.trim())).filter(Boolean) : parsedBody.suggestedOptions,
+      from,
+      to,
+      messageId: meta.messageId
+    };
+    return help;
+  }
+  if (intent === "task.ack") {
+    const ack = {
+      protocolVersion,
+      intent: "task.ack",
+      taskId,
+      from,
+      to,
+      messageId: meta.messageId
+    };
+    return ack;
+  }
+  if (intent === "task.stream.opened") {
+    const streamId = getAampHeader(headers, AAMP_HEADER.STREAM_ID) ?? "";
+    if (!streamId)
+      return null;
+    const streamOpened = {
+      protocolVersion,
+      intent: "task.stream.opened",
+      taskId,
+      streamId,
+      from,
+      to,
+      messageId: meta.messageId
+    };
+    return streamOpened;
+  }
+  if (intent === "card.query") {
+    const cardQuery = {
+      protocolVersion,
+      intent: "card.query",
+      taskId,
+      from,
+      to,
+      messageId: meta.messageId,
+      subject: meta.subject,
+      bodyText: ""
+    };
+    return cardQuery;
+  }
+  if (intent === "card.response") {
+    const summary = getAampHeader(headers, AAMP_HEADER.CARD_SUMMARY) ?? "";
+    const cardResponse = {
+      protocolVersion,
+      intent: "card.response",
+      taskId,
+      summary: decodeMimeEncodedWords(summary) || decodedSubject.replace(/^\[AAMP Card\]\s*/i, "").trim(),
+      from,
+      to,
+      messageId: meta.messageId,
+      subject: meta.subject,
+      bodyText: ""
+    };
+    return cardResponse;
+  }
+  return null;
+}
+function buildDispatchHeaders(params) {
+  const headers = {
+    [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
+    [AAMP_HEADER.INTENT]: "task.dispatch",
+    [AAMP_HEADER.TASK_ID]: params.taskId,
+    [AAMP_HEADER.PRIORITY]: params.priority ?? "normal"
+  };
+  if (params.expiresAt) {
+    headers[AAMP_HEADER.EXPIRES_AT] = params.expiresAt;
+  }
+  if (params.sessionKey?.trim()) {
+    headers[AAMP_HEADER.SESSION_KEY] = params.sessionKey.trim();
+  }
+  if (params.contextLinks.length > 0) {
+    headers[AAMP_HEADER.CONTEXT_LINKS] = params.contextLinks.join(",");
+  }
+  const dispatchContext = serializeDispatchContextHeader(params.dispatchContext);
+  if (dispatchContext) {
+    headers[AAMP_HEADER.DISPATCH_CONTEXT] = dispatchContext;
+  }
+  if (params.parentTaskId) {
+    headers[AAMP_HEADER.PARENT_TASK_ID] = params.parentTaskId;
+  }
+  return headers;
+}
+function buildCancelHeaders(params) {
+  return {
+    [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
+    [AAMP_HEADER.INTENT]: "task.cancel",
+    [AAMP_HEADER.TASK_ID]: params.taskId
+  };
+}
+function buildAckHeaders(opts) {
+  return {
+    [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
+    [AAMP_HEADER.INTENT]: "task.ack",
+    [AAMP_HEADER.TASK_ID]: opts.taskId
+  };
+}
+function buildStreamOpenedHeaders(opts) {
+  return {
+    [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
+    [AAMP_HEADER.INTENT]: "task.stream.opened",
+    [AAMP_HEADER.TASK_ID]: opts.taskId,
+    [AAMP_HEADER.STREAM_ID]: opts.streamId
+  };
+}
+function buildResultHeaders(params) {
+  const headers = {
+    [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
+    [AAMP_HEADER.INTENT]: "task.result",
+    [AAMP_HEADER.TASK_ID]: params.taskId,
+    [AAMP_HEADER.STATUS]: params.status
+  };
+  const structuredResult = encodeStructuredResult(params.structuredResult);
+  if (structuredResult) {
+    headers[AAMP_HEADER.STRUCTURED_RESULT] = structuredResult;
+  }
+  return headers;
+}
+function buildHelpHeaders(params) {
+  return {
+    [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
+    [AAMP_HEADER.INTENT]: "task.help_needed",
+    [AAMP_HEADER.TASK_ID]: params.taskId,
+    [AAMP_HEADER.SUGGESTED_OPTIONS]: params.suggestedOptions.join("|")
+  };
+}
+function buildCardQueryHeaders(params) {
+  return {
+    [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
+    [AAMP_HEADER.INTENT]: "card.query",
+    [AAMP_HEADER.TASK_ID]: params.taskId
+  };
+}
+function buildCardResponseHeaders(params) {
+  return {
+    [AAMP_HEADER.VERSION]: AAMP_PROTOCOL_VERSION,
+    [AAMP_HEADER.INTENT]: "card.response",
+    [AAMP_HEADER.TASK_ID]: params.taskId,
+    [AAMP_HEADER.CARD_SUMMARY]: params.summary
+  };
+}
+
+// ../sdk/dist/tiny-emitter.js
+var TinyEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  onceWrappers = /* @__PURE__ */ new WeakMap();
+  on(event, listener) {
+    const bucket = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    bucket.add(listener);
+    this.listeners.set(event, bucket);
+    return this;
+  }
+  once(event, listener) {
+    const wrapped = (...args) => {
+      this.off(event, listener);
+      listener(...args);
+    };
+    this.onceWrappers.set(listener, wrapped);
+    return this.on(event, wrapped);
+  }
+  off(event, listener) {
+    const bucket = this.listeners.get(event);
+    if (!bucket)
+      return this;
+    const original = listener;
+    const wrapped = this.onceWrappers.get(original);
+    bucket.delete(wrapped ?? original);
+    if (wrapped)
+      this.onceWrappers.delete(original);
+    if (bucket.size === 0)
+      this.listeners.delete(event);
+    return this;
+  }
+  emit(event, ...args) {
+    const bucket = this.listeners.get(event);
+    if (!bucket || bucket.size === 0)
+      return false;
+    for (const listener of [...bucket]) {
+      listener(...args);
+    }
+    return true;
+  }
+  async emitAsync(event, ...args) {
+    const bucket = this.listeners.get(event);
+    if (!bucket || bucket.size === 0)
+      return false;
+    const settled = await Promise.allSettled([...bucket].map((listener) => Promise.resolve(listener(...args))));
+    const rejected = settled.find((result) => result.status === "rejected");
+    if (rejected) {
+      throw rejected.reason;
+    }
+    return true;
+  }
+};
+
+// ../sdk/dist/jmap-push.js
+function describeError(err) {
+  if (!(err instanceof Error))
+    return String(err);
+  const parts = [err.message];
+  const details = err;
+  if (details.code)
+    parts.push(`code=${details.code}`);
+  if (details.errno !== void 0)
+    parts.push(`errno=${details.errno}`);
+  if (details.syscall)
+    parts.push(`syscall=${details.syscall}`);
+  if (details.address)
+    parts.push(`address=${details.address}`);
+  if (details.port !== void 0)
+    parts.push(`port=${details.port}`);
+  if (details.cause instanceof Error) {
+    parts.push(`cause=${describeError(details.cause)}`);
+  } else if (details.cause !== void 0) {
+    parts.push(`cause=${String(details.cause)}`);
+  }
+  return parts.join(" | ");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shouldRetrySessionFetch(status) {
+  return status === 429 || status >= 500;
+}
+function shouldRetryBlobDownload(status) {
+  return status === 404 || status === 429 || status === 503;
+}
+function rewriteUrlToConfiguredOrigin(rawUrl, configuredBaseUrl) {
+  const parsed = new URL(rawUrl);
+  const configured = new URL(configuredBaseUrl);
+  parsed.protocol = configured.protocol;
+  parsed.username = configured.username;
+  parsed.password = configured.password;
+  parsed.hostname = configured.hostname;
+  parsed.port = configured.port;
+  return parsed.toString();
+}
+var SESSION_FETCH_MAX_ATTEMPTS = 3;
+var SESSION_FETCH_RETRY_BASE_DELAY_MS = 250;
+var JmapPushClient = class extends TinyEmitter {
+  ws = null;
+  session = null;
+  reconnectTimer = null;
+  pollTimer = null;
+  pingTimer = null;
+  safetySyncTimer = null;
+  seenMessageIds = /* @__PURE__ */ new Set();
+  connected = false;
+  pollingActive = false;
+  running = false;
+  connecting = false;
+  /** JMAP Email state — tracks processed position; null = not yet initialized */
+  emailState = null;
+  startedAtMs = Date.now();
+  email;
+  password;
+  jmapUrl;
+  reconnectInterval;
+  rejectUnauthorized;
+  pingIntervalMs = 5e3;
+  safetySyncIntervalMs = 5e3;
+  constructor(opts) {
+    super();
+    this.email = opts.email;
+    this.password = opts.password;
+    this.jmapUrl = opts.jmapUrl.replace(/\/$/, "");
+    this.reconnectInterval = opts.reconnectInterval ?? 5e3;
+    this.rejectUnauthorized = opts.rejectUnauthorized ?? true;
+  }
+  /**
+   * Start the JMAP Push listener
+   */
+  async start() {
+    this.running = true;
+    this.startSafetySync();
+    await this.connect();
+  }
+  /**
+   * Stop the JMAP Push listener
+   */
+  stop() {
+    this.running = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    if (this.safetySyncTimer) {
+      clearInterval(this.safetySyncTimer);
+      this.safetySyncTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+    this.pollingActive = false;
+    this.connecting = false;
+  }
+  getAuthHeader() {
+    const creds = `${this.email}:${this.password}`;
+    return `Basic ${Buffer.from(creds).toString("base64")}`;
+  }
+  /**
+   * Fetch the JMAP session object
+   */
+  async fetchSession() {
+    const url = `${this.jmapUrl}/.well-known/jmap`;
+    let lastError = null;
+    for (let attempt = 1; attempt <= SESSION_FETCH_MAX_ATTEMPTS; attempt += 1) {
+      let res;
+      try {
+        res = await fetch(url, {
+          headers: { Authorization: this.getAuthHeader() }
+        });
+      } catch (err) {
+        lastError = new Error(`fetchSession ${url} failed: ${describeError(err)}`);
+        if (attempt >= SESSION_FETCH_MAX_ATTEMPTS)
+          throw lastError;
+        await sleep(SESSION_FETCH_RETRY_BASE_DELAY_MS * attempt);
+        continue;
+      }
+      if (res.ok) {
+        return res.json();
+      }
+      lastError = new Error(attempt >= SESSION_FETCH_MAX_ATTEMPTS || !shouldRetrySessionFetch(res.status) ? `Failed to fetch JMAP session: ${res.status} ${res.statusText}` : `Failed to fetch JMAP session after ${attempt} attempt(s): ${res.status} ${res.statusText}`);
+      if (attempt >= SESSION_FETCH_MAX_ATTEMPTS || !shouldRetrySessionFetch(res.status)) {
+        throw lastError;
+      }
+      await sleep(SESSION_FETCH_RETRY_BASE_DELAY_MS * attempt);
+    }
+    throw lastError ?? new Error("Failed to fetch JMAP session");
+  }
+  /**
+   * Perform a JMAP API call
+   */
+  async jmapCall(methods) {
+    if (!this.session)
+      throw new Error("No JMAP session");
+    const apiUrl = `${this.jmapUrl}/jmap/`;
+    let res;
+    try {
+      res = await fetch(apiUrl, {
+        method: "POST",
+        headers: {
+          Authorization: this.getAuthHeader(),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          using: [
+            "urn:ietf:params:jmap:core",
+            "urn:ietf:params:jmap:mail"
+          ],
+          methodCalls: methods
+        })
+      });
+    } catch (err) {
+      throw new Error(`jmapCall ${apiUrl} failed: ${describeError(err)}`);
+    }
+    if (!res.ok) {
+      throw new Error(`JMAP API call failed: ${res.status}`);
+    }
+    return res.json();
+  }
+  /**
+   * Initialize emailState by fetching the current state without loading any emails.
+   * Called on first connect so we only process emails that arrive AFTER this point.
+   */
+  async initEmailState(accountId) {
+    const response = await this.jmapCall([
+      ["Email/get", { accountId, ids: [] }, "g0"]
+    ]);
+    const getResp = response.methodResponses.find(([name]) => name === "Email/get");
+    if (getResp) {
+      this.emailState = getResp[1].state ?? null;
+    }
+  }
+  /**
+   * Fetch only emails created since `sinceState` using Email/changes.
+   * Updates `this.emailState` to the new state after fetching.
+   * Returns [] and resets state if the server cannot calculate changes (state too old).
+   */
+  async fetchEmailsSince(accountId, sinceState) {
+    const changesResp = await this.jmapCall([
+      ["Email/changes", { accountId, sinceState, maxChanges: 50 }, "c1"]
+    ]);
+    const changesResult = changesResp.methodResponses.find(([name]) => name === "Email/changes");
+    if (!changesResult || changesResult[0] === "error") {
+      await this.initEmailState(accountId);
+      return [];
+    }
+    const changes = changesResult[1];
+    if (changes.newState) {
+      this.emailState = changes.newState;
+    }
+    const newIds = changes.created ?? [];
+    if (newIds.length === 0)
+      return [];
+    const emailResp = await this.jmapCall([
+      [
+        "Email/get",
+        {
+          accountId,
+          ids: newIds,
+          properties: ["id", "subject", "from", "to", "headers", "messageId", "receivedAt", "textBody", "bodyValues", "attachments"],
+          fetchTextBodyValues: true,
+          maxBodyValueBytes: 262144
+        },
+        "g1"
+      ]
+    ]);
+    const getResult = emailResp.methodResponses.find(([name]) => name === "Email/get");
+    if (!getResult)
+      return [];
+    const data = getResult[1];
+    return data.list ?? [];
+  }
+  /**
+   * Process a received email.
+   *
+   * Priority:
+     * 1. If X-AAMP-Intent is present → emit typed AAMP event (task.dispatch / task.cancel / task.result / task.help_needed)
+   * 2. If In-Reply-To is present → emit 'reply' event so the application layer can
+   *    resolve the thread (inReplyTo → taskId via Redis/DB) and handle human replies.
+   * 3. Otherwise → ignore (not an AAMP-related email)
+   */
+  processEmail(email) {
+    const headerMap = {};
+    for (const h of email.headers ?? []) {
+      headerMap[h.name.toLowerCase()] = h.value.trim();
+    }
+    const fromAddr = email.from?.[0]?.email ?? "";
+    const toAddr = email.to?.[0]?.email ?? "";
+    const messageId = email.messageId?.[0] ?? email.id;
+    if (this.seenMessageIds.has(messageId))
+      return;
+    this.seenMessageIds.add(messageId);
+    const aampTextPartId = email.textBody?.[0]?.partId;
+    const aampBodyText = aampTextPartId ? (email.bodyValues?.[aampTextPartId]?.value ?? "").trim() : "";
+    const msg = parseAampHeaders({
+      from: fromAddr,
+      to: toAddr,
+      messageId,
+      subject: email.subject ?? "",
+      headers: headerMap,
+      bodyText: aampBodyText
+    });
+    if (msg && "intent" in msg) {
+      ;
+      msg.bodyText = aampBodyText;
+      const receivedAttachments = (email.attachments ?? []).map((a) => ({
+        filename: a.name ?? "attachment",
+        contentType: a.type,
+        size: a.size,
+        blobId: a.blobId
+      }));
+      if (receivedAttachments.length > 0) {
+        ;
+        msg.attachments = receivedAttachments;
+      }
+      if (msg.intent === "task.dispatch") {
+        this.emit("_autoAck", { to: fromAddr, taskId: msg.taskId, messageId });
+      }
+      const aampMsg = msg;
+      switch (aampMsg.intent) {
+        case "task.dispatch":
+          this.emit("task.dispatch", aampMsg);
+          break;
+        case "task.cancel":
+          this.emit("task.cancel", aampMsg);
+          break;
+        case "task.result":
+          this.emit("task.result", aampMsg);
+          break;
+        case "task.help_needed":
+          this.emit("task.help_needed", aampMsg);
+          break;
+        case "task.ack":
+          this.emit("task.ack", aampMsg);
+          break;
+        case "task.stream.opened":
+          this.emit("task.stream.opened", aampMsg);
+          break;
+        case "card.query":
+          this.emit("card.query", aampMsg);
+          break;
+        case "card.response":
+          this.emit("card.response", aampMsg);
+          break;
+      }
+      return;
+    }
+    const rawInReplyTo = headerMap["in-reply-to"] ?? "";
+    if (!rawInReplyTo)
+      return;
+    const rawReferences = headerMap["references"] ?? "";
+    const referencesIds = rawReferences.split(/\s+/).map((s) => s.replace(/[<>]/g, "").trim()).filter(Boolean);
+    const inReplyTo = rawInReplyTo.replace(/[<>]/g, "").trim();
+    const textPartId = email.textBody?.[0]?.partId;
+    const bodyText = textPartId ? (email.bodyValues?.[textPartId]?.value ?? "").trim() : "";
+    const reply = {
+      inReplyTo,
+      messageId,
+      from: fromAddr,
+      to: toAddr,
+      subject: email.subject ?? "",
+      bodyText
+    };
+    if (referencesIds.length > 0) {
+      Object.assign(reply, { references: referencesIds });
+    }
+    this.emit("reply", reply);
+  }
+  async fetchRecentEmails(accountId) {
+    const queryResp = await this.jmapCall([
+      [
+        "Email/query",
+        {
+          accountId,
+          sort: [{ property: "receivedAt", isAscending: false }],
+          limit: 20
+        },
+        "q1"
+      ]
+    ]);
+    const queryResult = queryResp.methodResponses.find(([name]) => name === "Email/query");
+    if (!queryResult)
+      return [];
+    const ids = (queryResult[1].ids ?? []).slice(0, 20);
+    if (ids.length === 0)
+      return [];
+    const emailResp = await this.jmapCall([
+      [
+        "Email/get",
+        {
+          accountId,
+          ids,
+          properties: ["id", "subject", "from", "to", "headers", "messageId", "receivedAt", "textBody", "bodyValues", "attachments"],
+          fetchTextBodyValues: true,
+          maxBodyValueBytes: 262144
+        },
+        "gRecent"
+      ]
+    ]);
+    const getResult = emailResp.methodResponses.find(([name]) => name === "Email/get");
+    if (!getResult)
+      return [];
+    return getResult[1].list ?? [];
+  }
+  shouldProcessBootstrapEmail(email) {
+    const receivedAtMs = new Date(email.receivedAt).getTime();
+    return Number.isFinite(receivedAtMs) && receivedAtMs >= this.startedAtMs - 15e3;
+  }
+  /**
+   * Connect to JMAP WebSocket
+   */
+  async connect() {
+    if (this.connecting || !this.running)
+      return;
+    this.connecting = true;
+    try {
+      this.session = await this.fetchSession();
+    } catch (err) {
+      this.connecting = false;
+      this.emit("error", new Error(`Failed to get JMAP session: ${err.message}`));
+      this.startPolling("session fetch failed");
+      this.scheduleReconnect();
+      return;
+    }
+    const stalwartWsUrl = `${this.jmapUrl}/jmap/ws`.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
+    this.ws = new WebSocket(stalwartWsUrl, "jmap", {
+      headers: {
+        Authorization: this.getAuthHeader()
+      },
+      perMessageDeflate: false,
+      rejectUnauthorized: this.rejectUnauthorized
+    });
+    this.ws.on("unexpected-response", (_req, res) => {
+      this.connecting = false;
+      const headerSummary = Object.entries(res.headers).map(([key, value]) => `${key}: ${Array.isArray(value) ? value.join(", ") : value ?? ""}`).join("; ");
+      this.startPolling(`websocket handshake failed: ${res.statusCode ?? "unknown"}`);
+      this.emit("error", new Error(`JMAP WebSocket handshake failed: ${res.statusCode ?? "unknown"} ${res.statusMessage ?? ""}${headerSummary ? ` | headers: ${headerSummary}` : ""}`));
+      this.scheduleReconnect();
+    });
+    this.ws.on("open", async () => {
+      this.connecting = false;
+      this.connected = true;
+      this.stopPolling();
+      this.startPingHeartbeat();
+      const accountId = this.session?.primaryAccounts["urn:ietf:params:jmap:mail"];
+      if (accountId && this.emailState === null) {
+        await this.initEmailState(accountId);
+      }
+      this.ws.send(JSON.stringify({
+        "@type": "WebSocketPushEnable",
+        dataTypes: ["Email"],
+        pushState: null
+      }));
+      this.emit("connected");
+    });
+    this.ws.on("pong", () => {
+    });
+    this.ws.on("message", async (rawData) => {
+      try {
+        const msg = JSON.parse(rawData.toString());
+        if (msg["@type"] === "StateChange") {
+          await this.handleStateChange(msg);
+        }
+      } catch (err) {
+        this.emit("error", new Error(`Failed to process JMAP push message: ${err.message}`));
+      }
+    });
+    this.ws.on("close", (code, reason) => {
+      this.connecting = false;
+      this.connected = false;
+      this.stopPingHeartbeat();
+      const reasonStr = reason?.toString() ?? "connection closed";
+      this.startPolling(reasonStr);
+      this.emit("disconnected", reasonStr);
+      if (this.running) {
+        this.scheduleReconnect();
+      }
+    });
+    this.ws.on("error", (err) => {
+      this.connecting = false;
+      this.stopPingHeartbeat();
+      this.startPolling(err.message);
+      this.emit("error", err);
+    });
+  }
+  startPingHeartbeat() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    this.pingTimer = setInterval(() => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+        return;
+      try {
+        this.ws.ping();
+      } catch (err) {
+        this.emit("error", new Error(`Failed to send WebSocket ping: ${err.message}`));
+      }
+    }, this.pingIntervalMs);
+  }
+  stopPingHeartbeat() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+  startSafetySync() {
+    if (this.safetySyncTimer)
+      return;
+    this.safetySyncTimer = setInterval(() => {
+      if (!this.running)
+        return;
+      void this.reconcileRecentEmails(20).catch((err) => {
+        this.emit("error", new Error(`Safety reconcile failed: ${err.message}`));
+      });
+    }, this.safetySyncIntervalMs);
+  }
+  async handleStateChange(stateChange) {
+    if (!this.session)
+      return;
+    const accountId = this.session.primaryAccounts["urn:ietf:params:jmap:mail"];
+    if (!accountId)
+      return;
+    const changedAccount = stateChange.changed[accountId];
+    if (!changedAccount?.Email)
+      return;
+    try {
+      if (this.emailState === null) {
+        await this.initEmailState(accountId);
+        return;
+      }
+      const emails = await this.fetchEmailsSince(accountId, this.emailState);
+      for (const email of emails) {
+        this.processEmail(email);
+      }
+    } catch (err) {
+      this.emit("error", new Error(`Failed to fetch emails: ${err.message}`));
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer)
+      return;
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      if (this.running) {
+        await this.connect();
+      }
+    }, this.reconnectInterval);
+  }
+  isConnected() {
+    return this.connected || this.pollingActive;
+  }
+  isUsingPollingFallback() {
+    return this.pollingActive && !this.connected;
+  }
+  stopPolling() {
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.pollingActive = false;
+  }
+  startPolling(reason) {
+    if (!this.running || this.pollingActive)
+      return;
+    this.pollingActive = true;
+    this.emit("error", new Error(`JMAP WebSocket unavailable, falling back to polling: ${reason}`));
+    this.emit("connected");
+    const poll = async () => {
+      if (!this.running || this.connected) {
+        this.stopPolling();
+        return;
+      }
+      try {
+        if (!this.session) {
+          this.session = await this.fetchSession();
+        }
+        const accountId = this.session.primaryAccounts["urn:ietf:params:jmap:mail"] ?? Object.keys(this.session.accounts)[0];
+        if (!accountId) {
+          throw new Error("No mail account available in JMAP session");
+        }
+        if (this.emailState === null) {
+          const recentEmails = await this.fetchRecentEmails(accountId);
+          for (const email of recentEmails.sort((a, b) => {
+            const aTs = new Date(a.receivedAt).getTime();
+            const bTs = new Date(b.receivedAt).getTime();
+            return aTs - bTs;
+          })) {
+            if (!this.shouldProcessBootstrapEmail(email))
+              continue;
+            this.processEmail(email);
+          }
+          await this.initEmailState(accountId);
+        } else {
+          const emails = await this.fetchEmailsSince(accountId, this.emailState);
+          for (const email of emails) {
+            this.processEmail(email);
+          }
+        }
+      } catch (err) {
+        this.emit("error", new Error(`Polling fallback failed: ${err.message}`));
+      } finally {
+        if (this.running && !this.connected) {
+          this.pollTimer = setTimeout(poll, this.reconnectInterval);
+        }
+      }
+    };
+    this.pollTimer = setTimeout(poll, 0);
+  }
+  /**
+   * Download a blob (attachment) by its JMAP blobId.
+   * Returns the raw binary content as a Buffer.
+   */
+  async downloadBlob(blobId, filename) {
+    if (!this.session) {
+      this.session = await this.fetchSession();
+    }
+    const accountId = this.session.primaryAccounts["urn:ietf:params:jmap:mail"] ?? Object.keys(this.session.accounts)[0];
+    let downloadUrl = this.session.downloadUrl ?? `${this.jmapUrl}/jmap/download/{accountId}/{blobId}/{name}`;
+    try {
+      downloadUrl = rewriteUrlToConfiguredOrigin(downloadUrl, this.jmapUrl);
+    } catch {
+    }
+    const safeFilename = filename ?? "attachment";
+    downloadUrl = downloadUrl.replace(/\{accountId\}|%7BaccountId%7D/gi, encodeURIComponent(accountId)).replace(/\{blobId\}|%7BblobId%7D/gi, encodeURIComponent(blobId)).replace(/\{name\}|%7Bname%7D/gi, encodeURIComponent(safeFilename)).replace(/\{type\}|%7Btype%7D/gi, "application/octet-stream");
+    const maxAttempts = 8;
+    let lastStatus = null;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      let res;
+      try {
+        res = await fetch(downloadUrl, {
+          headers: { Authorization: this.getAuthHeader() }
+        });
+      } catch (err) {
+        lastError = new Error(`Blob download fetch failed: attempt=${attempt}/${maxAttempts} blobId=${blobId} filename=${filename ?? "attachment"} url=${downloadUrl} error=${describeError(err)}`);
+        if (attempt < maxAttempts) {
+          console.warn(`[AAMP-SDK] blob download retry fetch-error attempt=${attempt}/${maxAttempts} url=${downloadUrl} error=${describeError(err)}`);
+          const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 15e3);
+          await new Promise((r) => setTimeout(r, delay));
+          continue;
+        }
+        console.error(`[AAMP-SDK] blob download fetch-error attempt=${attempt}/${maxAttempts} url=${downloadUrl} error=${describeError(err)}`);
+        throw lastError;
+      }
+      lastStatus = res.status;
+      if (res.ok) {
+        const arrayBuffer = await res.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+      }
+      if (attempt < maxAttempts && shouldRetryBlobDownload(res.status)) {
+        console.warn(`[AAMP-SDK] blob download retry status=${res.status} attempt=${attempt}/${maxAttempts} url=${downloadUrl}`);
+        const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 15e3);
+        await new Promise((r) => setTimeout(r, delay));
+        continue;
+      }
+      console.error(`[AAMP-SDK] blob download failed status=${res.status} attempt=${attempt}/${maxAttempts} url=${downloadUrl}`);
+      throw new Error(`Blob download failed: status=${res.status} attempt=${attempt}/${maxAttempts} blobId=${blobId} filename=${filename ?? "attachment"} url=${downloadUrl}`);
+    }
+    if (lastError)
+      throw lastError;
+    throw new Error(`Blob download failed after retries: status=${lastStatus ?? "unknown"} attempt=${maxAttempts}/${maxAttempts} blobId=${blobId} filename=${filename ?? "attachment"} url=${downloadUrl}`);
+  }
+  /**
+   * Actively reconcile recent mailbox contents via JMAP HTTP.
+   * Useful as a safety net when the WebSocket stays "connected"
+   * but a notification is missed by an intermediate layer.
+   */
+  async reconcileRecentEmails(limit = 20, opts) {
+    if (!this.session) {
+      this.session = await this.fetchSession();
+    }
+    const accountId = this.session.primaryAccounts["urn:ietf:params:jmap:mail"] ?? Object.keys(this.session.accounts)[0];
+    if (!accountId) {
+      throw new Error("No mail account available in JMAP session");
+    }
+    const queryResp = await this.jmapCall([
+      [
+        "Email/query",
+        {
+          accountId,
+          sort: [{ property: "receivedAt", isAscending: false }],
+          limit
+        },
+        "qReconcile"
+      ]
+    ]);
+    const queryResult = queryResp.methodResponses.find(([name]) => name === "Email/query");
+    if (!queryResult)
+      return 0;
+    const ids = (queryResult[1].ids ?? []).slice(0, limit);
+    if (ids.length === 0)
+      return 0;
+    const emailResp = await this.jmapCall([
+      [
+        "Email/get",
+        {
+          accountId,
+          ids,
+          properties: ["id", "subject", "from", "to", "headers", "messageId", "receivedAt", "textBody", "bodyValues", "attachments"],
+          fetchTextBodyValues: true,
+          maxBodyValueBytes: 262144
+        },
+        "gReconcile"
+      ]
+    ]);
+    const getResult = emailResp.methodResponses.find(([name]) => name === "Email/get");
+    if (!getResult)
+      return 0;
+    const emails = getResult[1].list ?? [];
+    for (const email of emails.sort((a, b) => {
+      const aTs = new Date(a.receivedAt).getTime();
+      const bTs = new Date(b.receivedAt).getTime();
+      return aTs - bTs;
+    })) {
+      if (!opts?.includeHistorical && !this.shouldProcessBootstrapEmail(email))
+        continue;
+      this.processEmail(email);
+    }
+    return emails.length;
+  }
+};
+
+// ../sdk/dist/smtp-sender.js
+import { createTransport } from "nodemailer";
+import { randomUUID } from "crypto";
+var sanitize = (s) => s.replace(/[\r\n]/g, " ").trim();
+function deriveMailboxServiceDefaults(email, baseUrl) {
+  const domain = email.split("@")[1]?.trim();
+  const resolvedBaseUrl = baseUrl?.trim() || (domain ? `https://${domain}` : void 0);
+  const smtpHost = domain || (resolvedBaseUrl ? new URL(resolvedBaseUrl).hostname : "localhost");
+  return {
+    smtpHost,
+    httpBaseUrl: resolvedBaseUrl
+  };
+}
+var SmtpSender = class _SmtpSender {
+  config;
+  transport;
+  discoveredApiUrlPromise = null;
+  jmapSessionPromise = null;
+  sentMailboxIdPromise = null;
+  static fromMailboxIdentity(config) {
+    const derived = deriveMailboxServiceDefaults(config.email, config.baseUrl);
+    return new _SmtpSender({
+      host: derived.smtpHost,
+      port: config.smtpPort ?? 587,
+      user: config.email,
+      password: config.password,
+      httpBaseUrl: derived.httpBaseUrl,
+      authToken: Buffer.from(`${config.email}:${config.password}`).toString("base64"),
+      secure: config.secure,
+      rejectUnauthorized: config.rejectUnauthorized
+    });
+  }
+  constructor(config) {
+    this.config = config;
+    this.transport = createTransport({
+      host: config.host,
+      port: config.port,
+      secure: config.secure ?? false,
+      auth: {
+        user: config.user,
+        pass: config.password
+      },
+      tls: {
+        rejectUnauthorized: config.rejectUnauthorized ?? true
+      }
+    });
+  }
+  senderDomain() {
+    return this.config.user.split("@")[1]?.toLowerCase() ?? "";
+  }
+  recipientDomain(email) {
+    return email.split("@")[1]?.toLowerCase() ?? "";
+  }
+  shouldUseHttpFallback(to) {
+    return Boolean(this.config.httpBaseUrl && this.config.authToken && this.senderDomain() && this.senderDomain() === this.recipientDomain(to));
+  }
+  async resolveAampApiUrl() {
+    const base = this.config.httpBaseUrl?.replace(/\/$/, "");
+    if (!base) {
+      throw new Error("HTTP send fallback is not configured");
+    }
+    if (!this.discoveredApiUrlPromise) {
+      this.discoveredApiUrlPromise = (async () => {
+        const discoveryRes = await fetch(`${base}/.well-known/aamp`);
+        if (!discoveryRes.ok) {
+          throw new Error(`AAMP discovery failed: ${discoveryRes.status}`);
+        }
+        const discovery = await discoveryRes.json();
+        if (!discovery.api?.url) {
+          throw new Error("AAMP discovery did not return api.url");
+        }
+        return new URL(discovery.api.url, `${base}/`).toString();
+      })();
+    }
+    try {
+      return await this.discoveredApiUrlPromise;
+    } catch (err) {
+      this.discoveredApiUrlPromise = null;
+      throw err;
+    }
+  }
+  async sendViaHttp(opts) {
+    if (!this.config.authToken) {
+      throw new Error("HTTP send fallback is not configured");
+    }
+    const apiUrl = new URL(await this.resolveAampApiUrl());
+    apiUrl.searchParams.set("action", "aamp.mailbox.send");
+    const res = await fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Basic ${this.config.authToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        to: opts.to,
+        subject: opts.subject,
+        text: opts.text,
+        aampHeaders: opts.aampHeaders,
+        attachments: opts.attachments?.map((a) => ({
+          filename: a.filename,
+          contentType: a.contentType,
+          content: typeof a.content === "string" ? a.content : a.content.toString("base64")
+        }))
+      })
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(data.details || `HTTP send failed: ${res.status}`);
+    }
+    return { messageId: data.messageId };
+  }
+  canPersistSentCopy() {
+    return Boolean(this.config.httpBaseUrl && this.config.authToken);
+  }
+  getJmapAuthHeader() {
+    if (!this.config.authToken) {
+      throw new Error("JMAP auth token is not configured");
+    }
+    return `Basic ${this.config.authToken}`;
+  }
+  async resolveJmapSession() {
+    const base = this.config.httpBaseUrl?.replace(/\/$/, "");
+    if (!base) {
+      throw new Error("JMAP base URL is not configured");
+    }
+    if (!this.jmapSessionPromise) {
+      this.jmapSessionPromise = (async () => {
+        const res = await fetch(`${base}/.well-known/jmap`, {
+          headers: { Authorization: this.getJmapAuthHeader() }
+        });
+        if (!res.ok) {
+          throw new Error(`JMAP session failed: ${res.status} ${res.statusText}`);
+        }
+        const session = await res.json();
+        const accountId = session.primaryAccounts?.["urn:ietf:params:jmap:mail"] ?? Object.keys(session.accounts ?? {})[0];
+        if (!accountId) {
+          throw new Error("No JMAP mail account available");
+        }
+        return {
+          accountId,
+          apiUrl: `${base}/jmap/`
+        };
+      })();
+    }
+    try {
+      return await this.jmapSessionPromise;
+    } catch (err) {
+      this.jmapSessionPromise = null;
+      throw err;
+    }
+  }
+  async jmapCall(methodCalls) {
+    const session = await this.resolveJmapSession();
+    const res = await fetch(session.apiUrl, {
+      method: "POST",
+      headers: {
+        Authorization: this.getJmapAuthHeader(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        using: [
+          "urn:ietf:params:jmap:core",
+          "urn:ietf:params:jmap:mail"
+        ],
+        methodCalls: methodCalls.map(([name, args, tag]) => [
+          name,
+          { accountId: session.accountId, ...args },
+          tag
+        ])
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`JMAP API call failed: ${res.status}`);
+    }
+    const data = await res.json();
+    return data.methodResponses ?? [];
+  }
+  async getSentMailboxId() {
+    if (!this.sentMailboxIdPromise) {
+      this.sentMailboxIdPromise = (async () => {
+        const responses = await this.jmapCall([
+          ["Mailbox/get", { ids: null }, "mb1"]
+        ]);
+        const result = responses.find(([name]) => name === "Mailbox/get")?.[1];
+        const mailboxes = result?.list ?? [];
+        return mailboxes.find((mailbox) => mailbox.role === "sent")?.id ?? mailboxes[0]?.id ?? null;
+      })();
+    }
+    try {
+      return await this.sentMailboxIdPromise;
+    } catch (err) {
+      this.sentMailboxIdPromise = null;
+      throw err;
+    }
+  }
+  async saveToSent(params) {
+    if (!this.canPersistSentCopy())
+      return;
+    const sentMailboxId = await this.getSentMailboxId();
+    if (!sentMailboxId)
+      return;
+    const emailCreate = {
+      mailboxIds: { [sentMailboxId]: true },
+      from: [{ email: params.from }],
+      to: [{ email: params.to }],
+      subject: params.subject,
+      bodyValues: {
+        body: {
+          value: params.text,
+          charset: "utf-8"
+        }
+      },
+      textBody: [{ partId: "body", type: "text/plain" }],
+      keywords: { "$seen": true }
+    };
+    if (params.inReplyTo) {
+      emailCreate["header:In-Reply-To:asText"] = ` ${sanitize(params.inReplyTo)}`;
+    }
+    if (params.messageId) {
+      emailCreate["header:Message-ID:asText"] = ` ${sanitize(params.messageId)}`;
+    }
+    if (params.references) {
+      emailCreate["header:References:asText"] = ` ${sanitize(params.references)}`;
+    }
+    for (const [name, value] of Object.entries(params.aampHeaders)) {
+      emailCreate[`header:${name}:asText`] = ` ${value}`;
+    }
+    await this.jmapCall([
+      ["Email/set", { create: { sent1: emailCreate } }, "sent1"]
+    ]);
+  }
+  async saveToSentBestEffort(params) {
+    if (!this.canPersistSentCopy())
+      return;
+    try {
+      await this.saveToSent(params);
+    } catch {
+    }
+  }
+  /**
+   * Send a task.dispatch email.
+   * Returns both the generated taskId and the SMTP Message-ID so callers can
+   * store a reverse-index (messageId → taskId) for In-Reply-To thread routing.
+   */
+  async sendTask(opts) {
+    const taskId = opts.taskId ?? randomUUID();
+    const aampHeaders = buildDispatchHeaders({
+      taskId,
+      priority: opts.priority,
+      expiresAt: opts.expiresAt,
+      contextLinks: opts.contextLinks ?? [],
+      dispatchContext: opts.dispatchContext,
+      parentTaskId: opts.parentTaskId
+    });
+    const sendMailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Task] ${sanitize(opts.title)}`,
+      text: opts.rawBodyText ?? [
+        `Task: ${opts.title}`,
+        `Task ID: ${taskId}`,
+        `Priority: ${opts.priority ?? "normal"}`,
+        opts.expiresAt ? `Expires At: ${opts.expiresAt}` : `Expires At: none`,
+        opts.contextLinks?.length ? `Context:
+${opts.contextLinks.map((l) => `  ${l}`).join("\n")}` : "",
+        opts.bodyText ?? "",
+        ``,
+        `--- This email was sent by AAMP. Reply directly to submit your result. ---`
+      ].filter(Boolean).join("\n"),
+      headers: aampHeaders
+    };
+    if (opts.attachments?.length) {
+      sendMailOpts.attachments = opts.attachments.map((a) => ({
+        filename: a.filename,
+        content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content,
+        contentType: a.contentType
+      }));
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      const info2 = await this.sendViaHttp({
+        to: opts.to,
+        subject: sendMailOpts.subject,
+        text: sendMailOpts.text,
+        aampHeaders,
+        attachments: opts.attachments?.map((a) => ({
+          filename: a.filename,
+          contentType: a.contentType,
+          content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content
+        }))
+      });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: sendMailOpts.subject,
+        text: sendMailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId
+      });
+      return { taskId, messageId: info2.messageId ?? "" };
+    }
+    const info = await this.transport.sendMail(sendMailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: sendMailOpts.subject,
+      text: sendMailOpts.text,
+      aampHeaders,
+      messageId: info.messageId
+    });
+    return { taskId, messageId: info.messageId ?? "" };
+  }
+  /**
+   * Send a task.result email back to the dispatcher
+   */
+  async sendResult(opts) {
+    const aampHeaders = buildResultHeaders({
+      taskId: opts.taskId,
+      status: opts.status,
+      output: opts.output,
+      errorMsg: opts.errorMsg,
+      structuredResult: opts.structuredResult
+    });
+    const mailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Result] Task ${opts.taskId} \u2014 ${opts.status}`,
+      text: opts.rawBodyText ?? [
+        `AAMP Task Result`,
+        ``,
+        `Task ID: ${opts.taskId}`,
+        `Status: ${opts.status}`,
+        ``,
+        `Output:`,
+        opts.output,
+        opts.errorMsg ? `
+Error: ${opts.errorMsg}` : ""
+      ].filter((s) => s !== "").join("\n"),
+      headers: aampHeaders
+    };
+    if (opts.inReplyTo) {
+      mailOpts.inReplyTo = opts.inReplyTo;
+      mailOpts.references = opts.inReplyTo;
+    }
+    if (opts.attachments?.length) {
+      mailOpts.attachments = opts.attachments.map((a) => ({
+        filename: a.filename,
+        content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content,
+        contentType: a.contentType
+      }));
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      const info2 = await this.sendViaHttp({
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        attachments: opts.attachments?.map((a) => ({
+          filename: a.filename,
+          contentType: a.contentType,
+          content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content
+        }))
+      });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
+      return;
+    }
+    const info = await this.transport.sendMail(mailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: mailOpts.subject,
+      text: mailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
+  }
+  /**
+   * Send a task.help_needed email when the agent is blocked
+   */
+  async sendHelp(opts) {
+    const aampHeaders = buildHelpHeaders({
+      taskId: opts.taskId,
+      question: opts.question,
+      blockedReason: opts.blockedReason,
+      suggestedOptions: opts.suggestedOptions
+    });
+    const helpMailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Help] Task ${opts.taskId} needs assistance`,
+      text: opts.rawBodyText ?? [
+        `AAMP Task Help Request`,
+        ``,
+        `Task ID: ${opts.taskId}`,
+        ``,
+        `Question: ${opts.question}`,
+        ``,
+        `Blocked reason: ${opts.blockedReason}`,
+        ``,
+        opts.suggestedOptions.length ? `Suggested options:
+${opts.suggestedOptions.map((o, i) => `  ${i + 1}. ${o}`).join("\n")}` : ""
+      ].filter(Boolean).join("\n"),
+      headers: aampHeaders
+    };
+    if (opts.inReplyTo) {
+      helpMailOpts.inReplyTo = opts.inReplyTo;
+      helpMailOpts.references = opts.inReplyTo;
+    }
+    if (opts.attachments?.length) {
+      helpMailOpts.attachments = opts.attachments.map((a) => ({
+        filename: a.filename,
+        content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content,
+        contentType: a.contentType
+      }));
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      const info2 = await this.sendViaHttp({
+        to: opts.to,
+        subject: helpMailOpts.subject,
+        text: helpMailOpts.text,
+        aampHeaders,
+        attachments: opts.attachments?.map((a) => ({
+          filename: a.filename,
+          contentType: a.contentType,
+          content: typeof a.content === "string" ? Buffer.from(a.content, "base64") : a.content
+        }))
+      });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: helpMailOpts.subject,
+        text: helpMailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
+      return;
+    }
+    const info = await this.transport.sendMail(helpMailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: helpMailOpts.subject,
+      text: helpMailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
+  }
+  /**
+   * Send a task.cancel email to stop a previously dispatched task.
+   */
+  async sendCancel(opts) {
+    const aampHeaders = buildCancelHeaders({
+      taskId: opts.taskId
+    });
+    const mailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Cancel] Task ${opts.taskId}`,
+      text: opts.bodyText ?? "The dispatcher cancelled this task.",
+      headers: aampHeaders
+    };
+    if (opts.inReplyTo) {
+      mailOpts.inReplyTo = opts.inReplyTo;
+      mailOpts.references = opts.inReplyTo;
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      const info2 = await this.sendViaHttp({
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders
+      });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
+      return;
+    }
+    const info = await this.transport.sendMail(mailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: mailOpts.subject,
+      text: mailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
+  }
+  /**
+   * Send a task.ack email to confirm receipt of a dispatch
+   */
+  async sendAck(opts) {
+    const aampHeaders = buildAckHeaders({ taskId: opts.taskId });
+    const mailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP ACK] Task ${opts.taskId}`,
+      text: "",
+      headers: aampHeaders
+    };
+    if (opts.inReplyTo) {
+      mailOpts.inReplyTo = opts.inReplyTo;
+      mailOpts.references = opts.inReplyTo;
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      const info2 = await this.sendViaHttp({
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders
+      });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
+      return;
+    }
+    const info = await this.transport.sendMail(mailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: mailOpts.subject,
+      text: mailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
+  }
+  async sendStreamOpened(opts) {
+    const aampHeaders = buildStreamOpenedHeaders({
+      taskId: opts.taskId,
+      streamId: opts.streamId
+    });
+    const mailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Stream] Task ${opts.taskId}`,
+      text: `AAMP task stream is ready.
+
+Task ID: ${opts.taskId}
+Stream ID: ${opts.streamId}`,
+      headers: aampHeaders
+    };
+    if (opts.inReplyTo) {
+      mailOpts.inReplyTo = opts.inReplyTo;
+      mailOpts.references = opts.inReplyTo;
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      const info2 = await this.sendViaHttp({
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders
+      });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
+      return;
+    }
+    const info = await this.transport.sendMail(mailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: mailOpts.subject,
+      text: mailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
+  }
+  async sendCardQuery(opts) {
+    const taskId = opts.taskId ?? randomUUID();
+    const aampHeaders = buildCardQueryHeaders({ taskId });
+    const mailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Card Query] ${taskId}`,
+      text: opts.bodyText?.trim() || "Please share your agent card and capability details.",
+      headers: aampHeaders
+    };
+    if (opts.inReplyTo) {
+      mailOpts.inReplyTo = opts.inReplyTo;
+      mailOpts.references = opts.inReplyTo;
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      const info2 = await this.sendViaHttp({
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders
+      });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
+      return { taskId, messageId: info2.messageId ?? "" };
+    }
+    const info = await this.transport.sendMail(mailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: mailOpts.subject,
+      text: mailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
+    return { taskId, messageId: info.messageId ?? "" };
+  }
+  async sendCardResponse(opts) {
+    const aampHeaders = buildCardResponseHeaders({
+      taskId: opts.taskId,
+      summary: opts.summary
+    });
+    const mailOpts = {
+      from: this.config.user,
+      to: opts.to,
+      subject: `[AAMP Card] ${sanitize(opts.summary)}`,
+      text: opts.bodyText,
+      headers: aampHeaders
+    };
+    if (opts.inReplyTo) {
+      mailOpts.inReplyTo = opts.inReplyTo;
+      mailOpts.references = opts.inReplyTo;
+    }
+    if (this.shouldUseHttpFallback(opts.to)) {
+      const info2 = await this.sendViaHttp({
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders
+      });
+      await this.saveToSentBestEffort({
+        from: this.config.user,
+        to: opts.to,
+        subject: mailOpts.subject,
+        text: mailOpts.text,
+        aampHeaders,
+        messageId: info2.messageId,
+        inReplyTo: opts.inReplyTo,
+        references: opts.inReplyTo
+      });
+      return;
+    }
+    const info = await this.transport.sendMail(mailOpts);
+    await this.saveToSentBestEffort({
+      from: this.config.user,
+      to: opts.to,
+      subject: mailOpts.subject,
+      text: mailOpts.text,
+      aampHeaders,
+      messageId: info.messageId,
+      inReplyTo: opts.inReplyTo,
+      references: opts.inReplyTo
+    });
+  }
+  /**
+   * Verify SMTP connection
+   */
+  async verify() {
+    try {
+      await this.transport.verify();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  close() {
+    this.transport.close();
+  }
+};
+
+// ../sdk/dist/thread.js
+function singleLine(value, maxLength = 220) {
+  const normalized = (value ?? "").replace(/\s+/g, " ").trim();
+  if (!normalized)
+    return "";
+  if (normalized.length <= maxLength)
+    return normalized;
+  return `${normalized.slice(0, maxLength - 1)}\u2026`;
+}
+function formatTimestamp(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime()))
+    return value;
+  return date.toISOString().slice(0, 16).replace("T", " ");
+}
+function renderEventLine(event) {
+  const from = event.from.split("@")[0] || event.from;
+  const timestamp = formatTimestamp(event.createdAt);
+  if (event.intent === "task.dispatch") {
+    const summary = singleLine(event.bodyText) || singleLine(event.title) || "Task dispatched";
+    return `[${timestamp}] ${from} dispatched: ${summary}`;
+  }
+  if (event.intent === "task.help_needed") {
+    const question = singleLine(event.question) || "Asked for help";
+    const reason = singleLine(event.blockedReason);
+    return `[${timestamp}] ${from} asked for help: ${question}${reason ? ` (reason: ${reason})` : ""}`;
+  }
+  if (event.intent === "task.result") {
+    const output3 = singleLine(event.output) || singleLine(event.bodyText) || "Sent a result";
+    return `[${timestamp}] ${from} replied: ${output3}`;
+  }
+  if (event.intent === "task.cancel") {
+    const body = singleLine(event.bodyText) || "Cancelled the task";
+    return `[${timestamp}] ${from} cancelled the task: ${body}`;
+  }
+  if (event.intent === "task.ack") {
+    return `[${timestamp}] ${from} acknowledged the task`;
+  }
+  return `[${timestamp}] ${from}: ${singleLine(event.bodyText) || event.intent}`;
+}
+function renderThreadHistoryForAgent(events, options = {}) {
+  const filtered = events.filter((event) => event.intent !== "task.stream.opened");
+  if (filtered.length === 0)
+    return "";
+  const maxEvents = Math.max(1, options.maxEvents ?? 8);
+  const visible = filtered.slice(-maxEvents);
+  const omitted = filtered.length - visible.length;
+  return [
+    "Prior thread context:",
+    ...omitted > 0 ? [`(${omitted} earlier event(s) omitted)`] : [],
+    ...visible.map((event) => `- ${renderEventLine(event)}`)
+  ].join("\n");
+}
+
+// ../sdk/dist/client.js
+function buildRegisteredCommandDispatchPayload(opts) {
+  const command = opts.command.trim();
+  if (!command) {
+    throw new Error("Registered command name cannot be empty.");
+  }
+  if (opts.args != null && (typeof opts.args !== "object" || Array.isArray(opts.args))) {
+    throw new Error("Registered command args must be an object when provided.");
+  }
+  if (opts.inputs) {
+    for (const input3 of opts.inputs) {
+      if (!input3.slot?.trim() || !input3.attachmentName?.trim()) {
+        throw new Error("Each registered command input must include slot and attachmentName.");
+      }
+    }
+  }
+  return {
+    kind: "registered-command/v1",
+    command,
+    ...opts.args && Object.keys(opts.args).length > 0 ? { args: opts.args } : {},
+    ...opts.inputs?.length ? { inputs: opts.inputs } : {},
+    stream: { mode: opts.streamMode ?? "full" }
+  };
+}
+var DEFAULT_TASK_DISPATCH_CONCURRENCY = 10;
+function normalizeTaskDispatchConcurrency(value) {
+  if (value == null)
+    return DEFAULT_TASK_DISPATCH_CONCURRENCY;
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 1) {
+    throw new Error("taskDispatchConcurrency must be a positive integer");
+  }
+  return value;
+}
+var AampClient = class _AampClient extends TinyEmitter {
+  jmapClient;
+  smtpSender;
+  config;
+  taskDispatchConcurrency;
+  pendingTaskDispatches = [];
+  activeTaskDispatchCount = 0;
+  streamAppendQueues = /* @__PURE__ */ new Map();
+  constructor(config) {
+    super();
+    this.config = config;
+    this.taskDispatchConcurrency = normalizeTaskDispatchConcurrency(config.taskDispatchConcurrency);
+    const mailboxToken = config.mailboxToken;
+    const resolvedBaseUrl = config.baseUrl;
+    const derived = deriveMailboxServiceDefaults(config.email, resolvedBaseUrl);
+    const smtpHost = config.smtpHost ?? derived.smtpHost;
+    let password;
+    try {
+      const decoded = Buffer.from(mailboxToken, "base64").toString("utf-8");
+      const colonIdx = decoded.indexOf(":");
+      if (colonIdx < 0)
+        throw new Error("Invalid mailboxToken format: expected base64(email:password)");
+      password = decoded.slice(colonIdx + 1);
+      if (!password)
+        throw new Error("Invalid mailboxToken: empty password");
+    } catch (err) {
+      if (err instanceof Error && err.message.startsWith("Invalid mailboxToken"))
+        throw err;
+      throw new Error(`Failed to decode mailboxToken: ${err.message}`);
+    }
+    this.jmapClient = new JmapPushClient({
+      email: config.email,
+      password: password ?? config.smtpPassword,
+      jmapUrl: resolvedBaseUrl,
+      reconnectInterval: config.reconnectInterval ?? 5e3,
+      rejectUnauthorized: config.rejectUnauthorized
+    });
+    this.smtpSender = new SmtpSender({
+      host: smtpHost,
+      port: config.smtpPort ?? 587,
+      user: config.email,
+      password: config.smtpPassword,
+      httpBaseUrl: config.httpSendBaseUrl ?? resolvedBaseUrl,
+      authToken: mailboxToken,
+      rejectUnauthorized: config.rejectUnauthorized
+    });
+    this.jmapClient.on("task.dispatch", (task) => {
+      this.enqueueTaskDispatch(task);
+    });
+    this.jmapClient.on("task.cancel", (task) => {
+      this.emit("task.cancel", task);
+    });
+    this.jmapClient.on("task.result", (result) => {
+      this.emit("task.result", result);
+    });
+    this.jmapClient.on("task.help_needed", (help) => {
+      this.emit("task.help_needed", help);
+    });
+    this.jmapClient.on("task.ack", (ack) => {
+      this.emit("task.ack", ack);
+    });
+    this.jmapClient.on("task.stream.opened", (stream) => {
+      this.emit("task.stream.opened", stream);
+    });
+    this.jmapClient.on("card.query", (query) => {
+      this.emit("card.query", query);
+    });
+    this.jmapClient.on("card.response", (response) => {
+      this.emit("card.response", response);
+    });
+    this.jmapClient.on("_autoAck", async ({ to, taskId, messageId }) => {
+      try {
+        await this.smtpSender.sendAck({ to, taskId, inReplyTo: messageId });
+      } catch (err) {
+        console.warn(`[AAMP] Failed to send ACK for task ${taskId}: ${err.message}`);
+      }
+    });
+    this.jmapClient.on("reply", (reply) => {
+      this.emit("reply", reply);
+    });
+    this.jmapClient.on("connected", () => {
+      this.emit("connected");
+    });
+    this.jmapClient.on("disconnected", (reason) => {
+      this.emit("disconnected", reason);
+    });
+    this.jmapClient.on("error", (err) => {
+      this.emit("error", err);
+    });
+  }
+  static fromMailboxIdentity(config) {
+    const derived = deriveMailboxServiceDefaults(config.email, config.baseUrl);
+    return new _AampClient({
+      email: config.email,
+      mailboxToken: Buffer.from(`${config.email}:${config.smtpPassword}`).toString("base64"),
+      baseUrl: derived.httpBaseUrl ?? `https://${config.email.split("@")[1] ?? "localhost"}`,
+      smtpHost: derived.smtpHost,
+      smtpPort: config.smtpPort ?? 587,
+      smtpPassword: config.smtpPassword,
+      reconnectInterval: config.reconnectInterval,
+      taskDispatchConcurrency: config.taskDispatchConcurrency,
+      rejectUnauthorized: config.rejectUnauthorized
+    });
+  }
+  static async discoverAampService(aampHost) {
+    const base = aampHost.replace(/\/$/, "");
+    const res = await fetch(`${base}/.well-known/aamp`);
+    if (!res.ok) {
+      throw new Error(`AAMP discovery failed: ${res.status} ${res.statusText}`);
+    }
+    const discovery = await res.json();
+    if (!discovery.api?.url) {
+      throw new Error("AAMP discovery did not return api.url");
+    }
+    return discovery;
+  }
+  static async callDiscoveredApi(base, opts) {
+    const discovery = await _AampClient.discoverAampService(base);
+    const apiUrl = new URL(discovery.api.url, `${base}/`);
+    apiUrl.searchParams.set("action", opts.action);
+    for (const [key, value] of Object.entries(opts.query ?? {})) {
+      if (value == null)
+        continue;
+      apiUrl.searchParams.set(key, String(value));
+    }
+    return fetch(apiUrl, {
+      method: opts.method ?? "GET",
+      headers: {
+        ...opts.authToken ? { Authorization: `Basic ${opts.authToken}` } : {},
+        ...opts.body ? { "Content-Type": "application/json" } : {}
+      },
+      ...opts.body ? { body: JSON.stringify(opts.body) } : {}
+    });
+  }
+  static async registerMailbox(opts) {
+    const base = opts.aampHost.replace(/\/$/, "");
+    const registerRes = await _AampClient.callDiscoveredApi(base, {
+      action: "aamp.mailbox.register",
+      method: "POST",
+      body: {
+        slug: opts.slug,
+        description: opts.description
+      }
+    });
+    if (!registerRes.ok) {
+      const body = await registerRes.text().catch(() => "");
+      throw new Error(`Mailbox registration failed: ${registerRes.status} ${body || registerRes.statusText}`);
+    }
+    const registerData = await registerRes.json();
+    if (!registerData.registrationCode) {
+      throw new Error("Mailbox registration succeeded but no registrationCode was returned");
+    }
+    const credsRes = await _AampClient.callDiscoveredApi(base, {
+      action: "aamp.mailbox.credentials",
+      query: { code: registerData.registrationCode }
+    });
+    if (!credsRes.ok) {
+      const body = await credsRes.text().catch(() => "");
+      throw new Error(`Mailbox credential exchange failed: ${credsRes.status} ${body || credsRes.statusText}`);
+    }
+    const creds = await credsRes.json();
+    if (!creds.email || !creds.mailbox?.token || !creds.smtp?.password) {
+      throw new Error("Mailbox credential exchange returned an incomplete identity payload");
+    }
+    return {
+      email: creds.email,
+      mailboxToken: creds.mailbox.token,
+      smtpPassword: creds.smtp.password,
+      baseUrl: base
+    };
+  }
+  static async checkMailbox(opts) {
+    const base = opts.aampHost.replace(/\/$/, "");
+    const res = await _AampClient.callDiscoveredApi(base, {
+      action: "aamp.mailbox.check",
+      query: { email: opts.email }
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Mailbox check failed: ${res.status} ${body || res.statusText}`);
+    }
+    const payload = await res.json();
+    return {
+      aamp: Boolean(payload.aamp),
+      ...payload.domain ? { domain: payload.domain } : {}
+    };
+  }
+  // =====================================================
+  // Lifecycle
+  // =====================================================
+  /**
+   * Connect to JMAP and start listening for tasks
+   */
+  async connect() {
+    await this.jmapClient.start();
+  }
+  /**
+   * Disconnect and clean up
+   */
+  disconnect() {
+    this.jmapClient.stop();
+    this.smtpSender.close();
+  }
+  /**
+   * Returns true if the JMAP connection is active
+   */
+  isConnected() {
+    return this.jmapClient.isConnected();
+  }
+  isUsingPollingFallback() {
+    return this.jmapClient.isUsingPollingFallback();
+  }
+  // =====================================================
+  // Sending
+  // =====================================================
+  /**
+   * Send a task.dispatch email to an agent.
+   * Returns the generated taskId and the SMTP Message-ID.
+   * Store messageId → taskId in Redis/DB to support In-Reply-To thread routing
+   * for human replies that arrive without X-AAMP headers.
+   */
+  async sendTask(opts) {
+    return this.smtpSender.sendTask(opts);
+  }
+  async sendRegisteredCommand(opts) {
+    const payload = buildRegisteredCommandDispatchPayload(opts);
+    return this.smtpSender.sendTask({
+      to: opts.to,
+      taskId: opts.taskId,
+      title: opts.title?.trim() || `Registered command: ${payload.command}`,
+      rawBodyText: JSON.stringify(payload, null, 2),
+      priority: opts.priority,
+      expiresAt: opts.expiresAt,
+      sessionKey: opts.sessionKey,
+      contextLinks: opts.contextLinks,
+      dispatchContext: opts.dispatchContext,
+      parentTaskId: opts.parentTaskId,
+      attachments: opts.attachments
+    });
+  }
+  async sendCancel(opts) {
+    return this.smtpSender.sendCancel(opts);
+  }
+  /**
+   * Send a task.result email (agent → system/dispatcher)
+   */
+  async sendResult(opts) {
+    return this.smtpSender.sendResult(opts);
+  }
+  /**
+   * Send a task.help_needed email when the agent needs human assistance
+   */
+  async sendHelp(opts) {
+    return this.smtpSender.sendHelp(opts);
+  }
+  async sendStreamOpened(opts) {
+    return this.smtpSender.sendStreamOpened(opts);
+  }
+  async sendCardQuery(opts) {
+    return this.smtpSender.sendCardQuery(opts);
+  }
+  async sendCardResponse(opts) {
+    return this.smtpSender.sendCardResponse(opts);
+  }
+  async updateDirectoryProfile(opts) {
+    const base = this.config.baseUrl;
+    const mailboxToken = this.config.mailboxToken;
+    const res = await _AampClient.callDiscoveredApi(base, {
+      action: "aamp.directory.upsert",
+      method: "POST",
+      authToken: mailboxToken,
+      body: opts
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Directory profile update failed: ${res.status} ${body || res.statusText}`);
+    }
+    const data = await res.json();
+    return data.profile;
+  }
+  async listDirectory(opts = {}) {
+    const base = this.config.baseUrl;
+    const mailboxToken = this.config.mailboxToken;
+    const res = await _AampClient.callDiscoveredApi(base, {
+      action: "aamp.directory.list",
+      authToken: mailboxToken,
+      query: {
+        scope: opts.scope,
+        includeSelf: opts.includeSelf,
+        limit: opts.limit
+      }
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Directory list failed: ${res.status} ${body || res.statusText}`);
+    }
+    const data = await res.json();
+    return data.agents;
+  }
+  async searchDirectory(opts) {
+    const base = this.config.baseUrl;
+    const mailboxToken = this.config.mailboxToken;
+    const res = await _AampClient.callDiscoveredApi(base, {
+      action: "aamp.directory.search",
+      authToken: mailboxToken,
+      query: {
+        q: opts.query,
+        scope: opts.scope,
+        includeSelf: opts.includeSelf,
+        limit: opts.limit
+      }
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Directory search failed: ${res.status} ${body || res.statusText}`);
+    }
+    const data = await res.json();
+    return data.agents;
+  }
+  async getThreadHistory(taskId, opts = {}) {
+    const base = this.config.baseUrl;
+    const mailboxToken = this.config.mailboxToken;
+    const res = await _AampClient.callDiscoveredApi(base, {
+      action: "aamp.mailbox.thread",
+      authToken: mailboxToken,
+      query: {
+        taskId,
+        includeStreamOpened: opts.includeStreamOpened
+      }
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Thread history fetch failed: ${res.status} ${body || res.statusText}`);
+    }
+    const data = await res.json();
+    return {
+      taskId: data.taskId,
+      events: Array.isArray(data.events) ? data.events : []
+    };
+  }
+  async hydrateTaskDispatch(task) {
+    const history = await this.getThreadHistory(task.taskId);
+    const priorEvents = history.events.filter((event) => event.messageId !== task.messageId);
+    return {
+      ...task,
+      threadHistory: priorEvents,
+      threadContextText: renderThreadHistoryForAgent(priorEvents)
+    };
+  }
+  async resolveStreamCapability() {
+    const discovery = await _AampClient.discoverAampService(this.config.baseUrl);
+    const stream = discovery.capabilities?.stream;
+    if (!stream?.transport) {
+      throw new Error("AAMP stream capability is not available on this service");
+    }
+    return stream;
+  }
+  async createStream(opts) {
+    const stream = await this.resolveStreamCapability();
+    const res = await _AampClient.callDiscoveredApi(this.config.baseUrl, {
+      action: stream.createAction ?? "aamp.stream.create",
+      method: "POST",
+      authToken: this.config.mailboxToken,
+      body: opts
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`AAMP stream create failed: ${res.status} ${body || res.statusText}`);
+    }
+    return res.json();
+  }
+  enqueueTaskDispatch(task) {
+    this.pendingTaskDispatches.push(task);
+    this.drainTaskDispatchQueue();
+  }
+  drainTaskDispatchQueue() {
+    while (this.activeTaskDispatchCount < this.taskDispatchConcurrency && this.pendingTaskDispatches.length > 0) {
+      const nextTask = this.pendingTaskDispatches.shift();
+      if (!nextTask)
+        return;
+      this.activeTaskDispatchCount += 1;
+      void this.runTaskDispatch(nextTask);
+    }
+  }
+  async runTaskDispatch(task) {
+    try {
+      await this.emitAsync("task.dispatch", task);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.emit("error", error);
+    } finally {
+      this.activeTaskDispatchCount = Math.max(0, this.activeTaskDispatchCount - 1);
+      this.drainTaskDispatchQueue();
+    }
+  }
+  getStreamAppendQueue(streamId) {
+    let queue = this.streamAppendQueues.get(streamId);
+    if (!queue) {
+      queue = { running: false, operations: [] };
+      this.streamAppendQueues.set(streamId, queue);
+    }
+    return queue;
+  }
+  async dispatchStreamAppend(opts) {
+    const stream = await this.resolveStreamCapability();
+    const res = await _AampClient.callDiscoveredApi(this.config.baseUrl, {
+      action: stream.appendAction ?? "aamp.stream.append",
+      method: "POST",
+      authToken: this.config.mailboxToken,
+      body: opts
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`AAMP stream append failed: ${res.status} ${body || res.statusText}`);
+    }
+    return res.json();
+  }
+  enqueueStreamAppend(streamId, operation) {
+    const queue = this.getStreamAppendQueue(streamId);
+    queue.operations.push(operation);
+    void this.drainStreamAppendQueue(streamId);
+  }
+  async drainStreamAppendQueue(streamId) {
+    const queue = this.streamAppendQueues.get(streamId);
+    if (!queue || queue.running)
+      return;
+    queue.running = true;
+    try {
+      while (queue.operations.length) {
+        const operation = queue.operations.shift();
+        if (!operation)
+          continue;
+        if (operation.kind === "text-delta-batch") {
+          try {
+            const event = await this.dispatchStreamAppend({
+              streamId,
+              type: "text.delta",
+              payload: {
+                ...operation.payload,
+                text: operation.text
+              }
+            });
+            for (const resolve of operation.resolvers)
+              resolve(event);
+          } catch (error) {
+            for (const reject of operation.rejecters)
+              reject(error);
+          }
+          continue;
+        }
+        try {
+          const event = await this.dispatchStreamAppend(operation.opts);
+          operation.resolve(event);
+        } catch (error) {
+          operation.reject(error);
+        }
+      }
+    } finally {
+      queue.running = false;
+      if (queue.operations.length === 0) {
+        this.streamAppendQueues.delete(streamId);
+      }
+    }
+  }
+  async flushStreamAppendQueue(streamId) {
+    while (true) {
+      const queue = this.streamAppendQueues.get(streamId);
+      if (!queue)
+        return;
+      if (!queue.running && queue.operations.length === 0) {
+        this.streamAppendQueues.delete(streamId);
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  }
+  async appendStreamEvent(opts) {
+    if (opts.type === "text.delta" && typeof opts.payload.text === "string") {
+      return await new Promise((resolve, reject) => {
+        const queue = this.getStreamAppendQueue(opts.streamId);
+        const lastOperation = queue.operations.at(-1);
+        if (lastOperation?.kind === "text-delta-batch") {
+          lastOperation.text += String(opts.payload.text ?? "");
+          lastOperation.resolvers.push(resolve);
+          lastOperation.rejecters.push(reject);
+          return;
+        }
+        this.enqueueStreamAppend(opts.streamId, {
+          kind: "text-delta-batch",
+          text: String(opts.payload.text ?? ""),
+          payload: {
+            ...opts.payload
+          },
+          resolvers: [resolve],
+          rejecters: [reject]
+        });
+      });
+    }
+    return await new Promise((resolve, reject) => {
+      this.enqueueStreamAppend(opts.streamId, {
+        kind: "single-event",
+        opts,
+        resolve,
+        reject
+      });
+    });
+  }
+  async closeStream(opts) {
+    await this.flushStreamAppendQueue(opts.streamId);
+    const stream = await this.resolveStreamCapability();
+    const res = await _AampClient.callDiscoveredApi(this.config.baseUrl, {
+      action: stream.closeAction ?? "aamp.stream.close",
+      method: "POST",
+      authToken: this.config.mailboxToken,
+      body: opts
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`AAMP stream close failed: ${res.status} ${body || res.statusText}`);
+    }
+    return res.json();
+  }
+  async getTaskStream(opts) {
+    const stream = await this.resolveStreamCapability();
+    const res = await _AampClient.callDiscoveredApi(this.config.baseUrl, {
+      action: stream.getAction ?? "aamp.stream.get",
+      authToken: this.config.mailboxToken,
+      query: {
+        ...opts.taskId ? { taskId: opts.taskId } : {},
+        ...opts.streamId ? { streamId: opts.streamId } : {}
+      }
+    });
+    if (res.status === 404)
+      return null;
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`AAMP stream get failed: ${res.status} ${body || res.statusText}`);
+    }
+    return res.json();
+  }
+  async subscribeStream(streamId, handlers, opts = {}) {
+    const stream = await this.resolveStreamCapability();
+    const template = stream.subscribeUrlTemplate;
+    if (!template)
+      throw new Error("AAMP stream subscribeUrlTemplate is missing");
+    const url = new URL(template.replace("{streamId}", encodeURIComponent(streamId)), this.config.baseUrl);
+    if (opts.lastEventId) {
+      url.searchParams.set("lastEventId", opts.lastEventId);
+    }
+    const controller = new AbortController();
+    if (opts.signal) {
+      opts.signal.addEventListener("abort", () => controller.abort(), { once: true });
+    }
+    const res = await fetch(url, {
+      headers: {
+        Authorization: `Basic ${this.config.mailboxToken}`,
+        Accept: "text/event-stream"
+      },
+      signal: controller.signal
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`AAMP stream subscribe failed: ${res.status} ${res.statusText}`);
+    }
+    handlers.onOpen?.();
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentEvent = "message";
+    let currentId = "";
+    let currentData = [];
+    const flush = () => {
+      if (!currentData.length)
+        return;
+      try {
+        const parsed = JSON.parse(currentData.join("\n"));
+        handlers.onEvent({
+          ...parsed,
+          ...currentId ? { id: currentId } : {},
+          type: parsed.type ?? currentEvent
+        });
+      } catch (err) {
+        handlers.onError?.(err);
+      } finally {
+        currentEvent = "message";
+        currentId = "";
+        currentData = [];
+      }
+    };
+    void (async () => {
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done)
+            break;
+          buffer += decoder.decode(value, { stream: true });
+          let index = buffer.indexOf("\n\n");
+          while (index >= 0) {
+            const frame = buffer.slice(0, index);
+            buffer = buffer.slice(index + 2);
+            for (const rawLine of frame.split("\n")) {
+              const line = rawLine.replace(/\r$/, "");
+              if (!line || line.startsWith(":"))
+                continue;
+              if (line.startsWith("event:")) {
+                currentEvent = line.slice(6).trim();
+              } else if (line.startsWith("id:")) {
+                currentId = line.slice(3).trim();
+              } else if (line.startsWith("data:")) {
+                currentData.push(line.slice(5).trimStart());
+              }
+            }
+            flush();
+            index = buffer.indexOf("\n\n");
+          }
+        }
+      } catch (err) {
+        if (!controller.signal.aborted) {
+          handlers.onError?.(err);
+        }
+      } finally {
+        buffer += decoder.decode();
+        controller.abort();
+      }
+    })();
+    return {
+      close() {
+        controller.abort();
+      }
+    };
+  }
+  /**
+   * Download a blob (attachment) by its JMAP blobId.
+   * Use this to retrieve attachment content from received TaskDispatch or TaskResult messages.
+   * Returns the raw binary content as a Buffer.
+   */
+  async downloadBlob(blobId, filename) {
+    return this.jmapClient.downloadBlob(blobId, filename);
+  }
+  /**
+   * Reconcile recent mailbox contents via JMAP HTTP to catch messages missed by
+   * a flaky WebSocket path. Safe to call periodically; duplicate processing is
+   * suppressed by the JMAP push client.
+   */
+  async reconcileRecentEmails(limit, opts) {
+    return this.jmapClient.reconcileRecentEmails(limit, opts);
+  }
+  /**
+   * Verify SMTP connectivity
+   */
+  async verifySmtp() {
+    return this.smtpSender.verify();
+  }
+  get email() {
+    return this.config.email;
+  }
+};
+
+// src/config.ts
+var CONFIG_FILENAME = "config.json";
+var STATE_FILENAME = "state.json";
+function getBridgeHomeDir(customDir) {
+  return customDir ? path.resolve(customDir) : path.join(os.homedir(), ".aamp", "wechat-bridge");
+}
+function getConfigPath(customDir) {
+  return path.join(getBridgeHomeDir(customDir), CONFIG_FILENAME);
+}
+function getStatePath(customDir) {
+  return path.join(getBridgeHomeDir(customDir), STATE_FILENAME);
+}
+async function ensureBridgeHomeDir(customDir) {
+  const dir = getBridgeHomeDir(customDir);
+  await mkdir(dir, { recursive: true });
+  return dir;
+}
+async function writeJsonAtomic(filePath, value) {
+  const parentDir = path.dirname(filePath);
+  await mkdir(parentDir, { recursive: true });
+  const tempPath = path.join(parentDir, `.${path.basename(filePath)}.${randomUUID2()}.tmp`);
+  await writeFile(tempPath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+  await rename(tempPath, filePath);
+}
+function createDefaultBridgeState() {
+  return {
+    version: 1,
+    processedMessageIds: [],
+    contextTokens: {},
+    conversations: {},
+    tasks: {}
+  };
+}
+async function loadBridgeConfig(customDir) {
+  const filePath = getConfigPath(customDir);
+  if (!existsSync(filePath))
+    return null;
+  const raw = await readFile(filePath, "utf8");
+  return JSON.parse(raw);
+}
+async function saveBridgeConfig(config, customDir) {
+  await writeJsonAtomic(getConfigPath(customDir), config);
+}
+async function loadBridgeState(customDir) {
+  const filePath = getStatePath(customDir);
+  if (!existsSync(filePath))
+    return createDefaultBridgeState();
+  const raw = await readFile(filePath, "utf8");
+  const parsed = JSON.parse(raw);
+  return {
+    ...createDefaultBridgeState(),
+    ...parsed,
+    processedMessageIds: Array.isArray(parsed.processedMessageIds) ? parsed.processedMessageIds : [],
+    contextTokens: parsed.contextTokens ?? {},
+    conversations: parsed.conversations ?? {},
+    tasks: parsed.tasks ?? {}
+  };
+}
+async function saveBridgeState(state, customDir) {
+  await writeJsonAtomic(getStatePath(customDir), state);
+}
+function normalizeBaseUrl(url) {
+  if (url.startsWith("http://") || url.startsWith("https://"))
+    return url.replace(/\/$/, "");
+  return `https://${url.replace(/\/$/, "")}`;
+}
+function normalizeSlug(rawValue) {
+  return rawValue.toLowerCase().replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 32) || "wechat-bridge";
+}
+async function prompt(question, defaultValue = "") {
+  const rl = readline.createInterface({ input, output });
+  try {
+    const suffix = defaultValue ? ` (${defaultValue})` : "";
+    const answer = await rl.question(`${question}${suffix}: `);
+    return answer.trim() || defaultValue;
+  } finally {
+    rl.close();
+  }
+}
+function toMailboxIdentity(mailbox) {
+  return {
+    email: mailbox.email,
+    mailboxToken: mailbox.mailboxToken,
+    smtpPassword: mailbox.smtpPassword,
+    baseUrl: mailbox.baseUrl
+  };
+}
+async function initializeBridgeConfig(options) {
+  const existing = await loadBridgeConfig(options.configDir);
+  const aampHost = (options.aampHost ?? existing?.aampHost ?? await prompt("AAMP host", "https://meshmail.ai")).trim();
+  const targetAgentEmail = (options.targetAgentEmail ?? existing?.targetAgentEmail ?? await prompt("Target AAMP agent email")).trim();
+  const slug = normalizeSlug(options.slug ?? existing?.slug ?? await prompt("Bridge mailbox slug", "wechat-bridge"));
+  const summary = (options.summary ?? existing?.summary ?? "").trim() || void 0;
+  const botAgent = (options.botAgent ?? existing?.wechat.botAgent ?? await prompt("WeChat bot agent", "AAMP-WeChat-Bridge/0.1.0")).trim();
+  const dispatchTimeoutMs = Math.max(1e3, Math.trunc(options.dispatchTimeoutMs ?? existing?.behavior.dispatchTimeoutMs ?? 18e4));
+  const pollTimeoutMs = Math.max(5e3, Math.trunc(options.pollTimeoutMs ?? existing?.behavior.pollTimeoutMs ?? 35e3));
+  if (!aampHost)
+    throw new Error("AAMP host is required.");
+  if (!targetAgentEmail)
+    throw new Error("Target AAMP agent email is required.");
+  const mailbox = existing?.mailbox ?? toMailboxIdentity(await AampClient.registerMailbox({
+    aampHost,
+    slug,
+    description: `WeChat bridge for ${targetAgentEmail}`
+  }));
+  const config = {
+    version: 1,
+    aampHost: normalizeBaseUrl(aampHost),
+    targetAgentEmail,
+    slug,
+    ...summary ? { summary } : {},
+    mailbox: toMailboxIdentity(mailbox),
+    wechat: {
+      apiBaseUrl: existing?.wechat.apiBaseUrl ?? "https://ilinkai.weixin.qq.com",
+      botType: existing?.wechat.botType ?? "3",
+      botAgent: botAgent || "AAMP-WeChat-Bridge/0.1.0"
+    },
+    behavior: {
+      dispatchTimeoutMs,
+      pollTimeoutMs
+    }
+  };
+  await ensureBridgeHomeDir(options.configDir);
+  await saveBridgeConfig(config, options.configDir);
+  return config;
+}
+
+// src/wechat-api.ts
+import crypto from "node:crypto";
+var DEFAULT_APP_ID = "bot";
+var DEFAULT_CHANNEL_VERSION = "0.1.0";
+function normalizeWechatApiBaseUrl(url) {
+  if (url.startsWith("http://") || url.startsWith("https://"))
+    return url.replace(/\/$/, "");
+  return `https://${url.replace(/\/$/, "")}`;
+}
+function buildClientVersion(version) {
+  const parts = version.split(".").map((part) => Number.parseInt(part, 10));
+  const major = parts[0] ?? 0;
+  const minor = parts[1] ?? 0;
+  const patch = parts[2] ?? 0;
+  return (major & 255) << 16 | (minor & 255) << 8 | patch & 255;
+}
+function sanitizeBotAgent(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return "AAMP-WeChat-Bridge/0.1.0";
+  return trimmed.slice(0, 256);
+}
+function buildBaseInfo(botAgent) {
+  return {
+    channel_version: DEFAULT_CHANNEL_VERSION,
+    bot_agent: sanitizeBotAgent(botAgent)
+  };
+}
+function buildHeaders(token) {
+  const headers = {
+    "Content-Type": "application/json",
+    AuthorizationType: "ilink_bot_token",
+    "X-WECHAT-UIN": Buffer.from(String(crypto.randomBytes(4).readUInt32BE(0)), "utf8").toString("base64"),
+    "iLink-App-Id": DEFAULT_APP_ID,
+    "iLink-App-ClientVersion": String(buildClientVersion(DEFAULT_CHANNEL_VERSION))
+  };
+  if (token?.trim()) {
+    headers.Authorization = `Bearer ${token.trim()}`;
+  }
+  return headers;
+}
+async function postJson(endpoint, body, opts) {
+  const controller = opts.timeoutMs ? new AbortController() : void 0;
+  const timeout = opts.timeoutMs ? setTimeout(() => controller?.abort(), opts.timeoutMs) : void 0;
+  try {
+    const response = await fetch(`${normalizeWechatApiBaseUrl(opts.apiBaseUrl)}/${endpoint}`, {
+      method: "POST",
+      headers: buildHeaders(opts.token),
+      body: JSON.stringify(body),
+      ...controller ? { signal: controller.signal } : {}
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(`${endpoint} ${response.status}: ${text || response.statusText}`);
+    }
+    return JSON.parse(text);
+  } finally {
+    if (timeout)
+      clearTimeout(timeout);
+  }
+}
+async function getJson(endpoint, opts) {
+  const controller = opts.timeoutMs ? new AbortController() : void 0;
+  const timeout = opts.timeoutMs ? setTimeout(() => controller?.abort(), opts.timeoutMs) : void 0;
+  try {
+    const response = await fetch(`${normalizeWechatApiBaseUrl(opts.apiBaseUrl)}/${endpoint}`, {
+      method: "GET",
+      headers: buildHeaders(opts.token),
+      ...controller ? { signal: controller.signal } : {}
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(`${endpoint} ${response.status}: ${text || response.statusText}`);
+    }
+    return JSON.parse(text);
+  } finally {
+    if (timeout)
+      clearTimeout(timeout);
+  }
+}
+async function startQrLogin(opts) {
+  const response = await postJson(
+    `ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(opts.botType)}`,
+    {
+      local_token_list: [],
+      base_info: buildBaseInfo(opts.botAgent)
+    },
+    { apiBaseUrl: opts.apiBaseUrl, botAgent: opts.botAgent, timeoutMs: 15e3 }
+  );
+  if (!response.qrcode || !response.qrcode_img_content) {
+    throw new Error("\u5FAE\u4FE1\u767B\u5F55\u4E8C\u7EF4\u7801\u83B7\u53D6\u5931\u8D25\u3002");
+  }
+  return {
+    qrCode: response.qrcode,
+    qrCodeUrl: response.qrcode_img_content
+  };
+}
+async function pollQrStatus(opts) {
+  const query = new URLSearchParams({ qrcode: opts.qrCode });
+  if (opts.verifyCode)
+    query.set("verify_code", opts.verifyCode);
+  const response = await getJson(`ilink/bot/get_qrcode_status?${query.toString()}`, {
+    apiBaseUrl: opts.apiBaseUrl,
+    botAgent: opts.botAgent,
+    timeoutMs: 35e3
+  });
+  return {
+    status: response.status ?? "wait",
+    botToken: response.bot_token,
+    ilinkUserId: response.ilink_user_id,
+    baseUrl: response.baseurl ? normalizeWechatApiBaseUrl(response.baseurl) : void 0,
+    redirectHost: response.redirect_host
+  };
+}
+async function getUpdates(opts) {
+  try {
+    return await postJson(
+      "ilink/bot/getupdates",
+      {
+        get_updates_buf: opts.syncCursor ?? "",
+        base_info: buildBaseInfo(opts.botAgent)
+      },
+      opts
+    );
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      return {
+        ret: 0,
+        msgs: [],
+        get_updates_buf: opts.syncCursor
+      };
+    }
+    throw error;
+  }
+}
+async function sendTextMessage(opts) {
+  await postJson(
+    "ilink/bot/sendmessage",
+    {
+      msg: {
+        from_user_id: "",
+        to_user_id: opts.toUserId,
+        client_id: crypto.randomUUID(),
+        message_type: 2,
+        message_state: 2,
+        item_list: opts.text ? [{ type: 1, text_item: { text: opts.text } }] : void 0,
+        context_token: opts.contextToken ?? void 0
+      },
+      base_info: buildBaseInfo(opts.botAgent)
+    },
+    opts
+  );
+}
+async function getTypingTicket(opts) {
+  const response = await postJson(
+    "ilink/bot/getconfig",
+    {
+      ilink_user_id: opts.ilinkUserId,
+      context_token: opts.contextToken ?? void 0,
+      base_info: buildBaseInfo(opts.botAgent)
+    },
+    opts
+  );
+  if (response.ret && response.ret !== 0)
+    return void 0;
+  return response.typing_ticket;
+}
+async function sendTypingStatus(opts) {
+  await postJson(
+    "ilink/bot/sendtyping",
+    {
+      ilink_user_id: opts.ilinkUserId,
+      typing_ticket: opts.typingTicket,
+      status: opts.status === "typing" ? 1 : 2,
+      base_info: buildBaseInfo(opts.botAgent)
+    },
+    opts
+  );
+}
+async function notifyStart(opts) {
+  await postJson(
+    "ilink/bot/msg/notifystart",
+    { base_info: buildBaseInfo(opts.botAgent) },
+    opts
+  );
+}
+async function notifyStop(opts) {
+  await postJson(
+    "ilink/bot/msg/notifystop",
+    { base_info: buildBaseInfo(opts.botAgent) },
+    opts
+  );
+}
+
+// src/runtime.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+var MAX_PROCESSED_MESSAGE_IDS = 200;
+var WechatBridgeRuntime = class {
+  aamp;
+  config;
+  configDir;
+  logger;
+  activeStreamSubscriptions = /* @__PURE__ */ new Map();
+  liveTaskIds = /* @__PURE__ */ new Set();
+  typingTickets = /* @__PURE__ */ new Map();
+  state = createDefaultBridgeState();
+  stopping = false;
+  pollLoopPromise;
+  constructor(config, options = {}) {
+    this.config = config;
+    this.configDir = options.configDir;
+    this.logger = options.logger ?? console;
+    this.aamp = new AampClient({
+      email: config.mailbox.email,
+      mailboxToken: config.mailbox.mailboxToken,
+      smtpPassword: config.mailbox.smtpPassword,
+      baseUrl: config.mailbox.baseUrl
+    });
+  }
+  async start() {
+    this.state = await loadBridgeState(this.configDir);
+    if (!this.state.account?.token) {
+      throw new Error("\u5C1A\u672A\u767B\u5F55\u5FAE\u4FE1\uFF0C\u8BF7\u5148\u6267\u884C `aamp-wechat-bridge login`\u3002");
+    }
+    this.state.tasks = {};
+    this.state.lastStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.state.lastError = void 0;
+    await this.persistState();
+    this.registerAampHandlers();
+    await this.aamp.connect();
+    await notifyStart({
+      apiBaseUrl: this.state.account.baseUrl,
+      token: this.state.account.token,
+      botAgent: this.config.wechat.botAgent,
+      timeoutMs: 1e4
+    }).catch(() => {
+    });
+    this.pollLoopPromise = this.pollLoop();
+    await this.pollLoopPromise;
+  }
+  async stop() {
+    if (this.stopping)
+      return;
+    this.stopping = true;
+    for (const subscription of this.activeStreamSubscriptions.values()) {
+      subscription.close();
+    }
+    this.activeStreamSubscriptions.clear();
+    this.liveTaskIds.clear();
+    if (this.state.account?.token) {
+      await notifyStop({
+        apiBaseUrl: this.state.account.baseUrl,
+        token: this.state.account.token,
+        botAgent: this.config.wechat.botAgent,
+        timeoutMs: 1e4
+      }).catch(() => {
+      });
+    }
+    this.aamp.disconnect();
+    this.state.lastStoppedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.persistState();
+  }
+  registerAampHandlers() {
+    this.aamp.on("task.ack", (task) => {
+      void this.handleTaskAck(task);
+    });
+    this.aamp.on("task.stream.opened", (task) => {
+      void this.handleTaskStreamOpened(task);
+    });
+    this.aamp.on("task.result", (task) => {
+      void this.handleTaskResult(task);
+    });
+    this.aamp.on("task.help_needed", (task) => {
+      void this.handleTaskHelp(task);
+    });
+    this.aamp.on("error", (error) => {
+      this.state.lastError = error.message;
+      this.logger.error(`[aamp] ${error.message}`);
+      void this.persistState();
+    });
+  }
+  async pollLoop() {
+    while (!this.stopping) {
+      try {
+        await this.pollOnce();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.state.lastError = message;
+        this.logger.error(`[wechat] ${message}`);
+        await this.persistState();
+        if (message.includes("session timeout") || message.includes("errcode=-14")) {
+          throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 3e3));
+      }
+    }
+  }
+  async pollOnce() {
+    if (!this.state.account?.token)
+      return;
+    const response = await getUpdates({
+      apiBaseUrl: this.state.account.baseUrl,
+      token: this.state.account.token,
+      botAgent: this.config.wechat.botAgent,
+      timeoutMs: this.config.behavior.pollTimeoutMs,
+      syncCursor: this.state.syncCursor
+    });
+    if (response.errcode === -14) {
+      throw new Error("WeChat session timeout (errcode=-14). Please run `aamp-wechat-bridge login` again.");
+    }
+    if (response.ret && response.ret !== 0) {
+      throw new Error(`WeChat getupdates failed: errcode=${response.errcode ?? response.ret} ${response.errmsg ?? ""}`.trim());
+    }
+    if (response.get_updates_buf && response.get_updates_buf !== this.state.syncCursor) {
+      this.state.syncCursor = response.get_updates_buf;
+      await this.persistState();
+    }
+    for (const message of response.msgs ?? []) {
+      await this.handleInboundWechatMessage(message);
+    }
+  }
+  async handleInboundWechatMessage(message) {
+    if (message.group_id)
+      return;
+    if (message.message_type === 2)
+      return;
+    const senderId = message.from_user_id?.trim();
+    if (!senderId)
+      return;
+    const messageKey = String(message.message_id ?? "");
+    if (messageKey && this.state.processedMessageIds.includes(messageKey)) {
+      return;
+    }
+    const text = this.extractMessageText(message.item_list ?? []);
+    const mediaNote = this.extractMediaNote(message.item_list ?? []);
+    const body = [text, mediaNote].filter(Boolean).join("\n\n").trim();
+    if (!body)
+      return;
+    const taskId = randomUUID3();
+    const sessionKey = this.buildSessionKey(senderId);
+    const contextToken = message.context_token?.trim() || void 0;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.liveTaskIds.add(taskId);
+    this.state.tasks[taskId] = {
+      taskId,
+      senderId,
+      sessionKey,
+      ...contextToken ? { contextToken } : {},
+      status: "received",
+      createdAt: now,
+      updatedAt: now
+    };
+    this.state.conversations[sessionKey] = {
+      senderId,
+      sessionKey,
+      lastTaskId: taskId,
+      ...contextToken ? { lastContextToken: contextToken } : {},
+      updatedAt: now
+    };
+    if (contextToken) {
+      this.state.contextTokens[senderId] = contextToken;
+    }
+    if (messageKey) {
+      this.rememberProcessedMessageId(messageKey);
+    }
+    await this.persistState();
+    await this.aamp.sendTask({
+      to: this.config.targetAgentEmail,
+      taskId,
+      sessionKey,
+      title: `WeChat DM from ${senderId}`,
+      bodyText: body,
+      dispatchContext: {
+        source: "wechat",
+        wechat_account_id: this.state.account?.accountId ?? "default",
+        wechat_sender_id: senderId,
+        ...contextToken ? { wechat_context_token: contextToken } : {},
+        ...message.session_id ? { wechat_session_id: message.session_id } : {},
+        ...message.message_id != null ? { wechat_message_id: String(message.message_id) } : {}
+      }
+    });
+  }
+  extractMessageText(items) {
+    const parts = [];
+    for (const item of items) {
+      const text = item.text_item?.text?.trim();
+      if (text)
+        parts.push(text);
+      const voiceText = item.voice_item?.text?.trim();
+      if (voiceText)
+        parts.push(voiceText);
+    }
+    return parts.join("\n").trim();
+  }
+  extractMediaNote(items) {
+    const labels = [];
+    for (const item of items) {
+      if (item.type === 2)
+        labels.push("image");
+      if (item.type === 3)
+        labels.push("voice");
+      if (item.type === 4)
+        labels.push(`file${item.file_item?.file_name ? ` (${item.file_item.file_name})` : ""}`);
+      if (item.type === 5)
+        labels.push("video");
+    }
+    if (labels.length === 0)
+      return "";
+    return `User also sent WeChat media: ${labels.join(", ")}. Native media relay is not implemented yet, so please answer based on the textual context only.`;
+  }
+  buildSessionKey(senderId) {
+    return `wechat:${this.state.account?.accountId ?? "default"}:${senderId}`;
+  }
+  rememberProcessedMessageId(messageId) {
+    this.state.processedMessageIds.push(messageId);
+    if (this.state.processedMessageIds.length > MAX_PROCESSED_MESSAGE_IDS) {
+      this.state.processedMessageIds.splice(0, this.state.processedMessageIds.length - MAX_PROCESSED_MESSAGE_IDS);
+    }
+  }
+  async handleTaskAck(task) {
+    const state = this.state.tasks[task.taskId];
+    if (!state || !this.liveTaskIds.has(task.taskId))
+      return;
+    state.status = "pending";
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.ensureTyping(state, "typing");
+    await this.persistState();
+  }
+  async handleTaskStreamOpened(task) {
+    const state = this.state.tasks[task.taskId];
+    if (!state || !this.liveTaskIds.has(task.taskId))
+      return;
+    state.status = "streaming";
+    state.streamId = task.streamId;
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.subscribeToTaskStream(state);
+    await this.persistState();
+  }
+  async subscribeToTaskStream(task) {
+    if (!task.streamId || this.activeStreamSubscriptions.has(task.taskId))
+      return;
+    const subscription = await this.aamp.subscribeStream(
+      task.streamId,
+      {
+        onEvent: (event) => {
+          void this.handleStreamEvent(task.taskId, event);
+        },
+        onError: (error) => {
+          this.logger.error(`[stream ${task.taskId}] ${error.message}`);
+        }
+      }
+    );
+    this.activeStreamSubscriptions.set(task.taskId, subscription);
+  }
+  async handleStreamEvent(taskId, event) {
+    const state = this.state.tasks[taskId];
+    if (!state || !this.liveTaskIds.has(taskId))
+      return;
+    if (event.type === "text.delta") {
+      state.streamText = (state.streamText ?? "") + String(event.payload.text ?? "");
+      state.status = "streaming";
+      state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.persistState();
+      return;
+    }
+    if (event.type === "error") {
+      state.resultError = String(event.payload.message ?? event.payload.error ?? "Unknown stream error");
+      state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.persistState();
+    }
+  }
+  async handleTaskResult(task) {
+    const state = this.state.tasks[task.taskId];
+    if (!state || !this.liveTaskIds.has(task.taskId))
+      return;
+    state.status = task.status === "completed" ? "completed" : "rejected";
+    state.outputText = task.output || state.streamText || state.outputText;
+    state.resultError = task.errorMsg;
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.closeActiveStream(task.taskId);
+    await this.ensureTyping(state, "cancel");
+    await this.replyToWechat(state, this.buildReplyTextFromResult(task, state));
+    this.finishTask(task.taskId);
+  }
+  async handleTaskHelp(task) {
+    const state = this.state.tasks[task.taskId];
+    if (!state || !this.liveTaskIds.has(task.taskId))
+      return;
+    state.status = "help_needed";
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.closeActiveStream(task.taskId);
+    await this.ensureTyping(state, "cancel");
+    await this.replyToWechat(state, this.buildReplyTextFromHelp(task));
+    this.finishTask(task.taskId);
+  }
+  buildReplyTextFromResult(task, state) {
+    const body = (task.output || state.streamText || "").trim();
+    const base = body || (task.status === "rejected" ? "\u5F53\u524D\u8BF7\u6C42\u88AB\u76EE\u6807 Agent \u62D2\u7EDD\u4E86\u3002" : "\u5DF2\u7ECF\u5904\u7406\u5B8C\u6210\u3002");
+    const attachmentLines = (task.attachments ?? []).map((attachment) => `- ${attachment.filename} (${attachment.size} bytes)`);
+    const senderPolicyHint = this.buildSenderPolicyHint(task.errorMsg, state);
+    return [
+      base,
+      ...attachmentLines.length ? ["", "\u8FD4\u56DE\u4E2D\u8FD8\u5305\u542B\u9644\u4EF6\uFF0C\u76EE\u524D\u5FAE\u4FE1 bridge \u5148\u53EA\u63D0\u793A\u6587\u4EF6\u540D\uFF1A", ...attachmentLines] : [],
+      ...senderPolicyHint ? ["", senderPolicyHint] : []
+    ].join("\n");
+  }
+  buildReplyTextFromHelp(task) {
+    return [
+      task.question.trim() || "\u6211\u8FD8\u9700\u8981\u4E00\u4E9B\u4FE1\u606F\u624D\u80FD\u7EE7\u7EED\u3002",
+      ...task.blockedReason?.trim() ? ["", `\u539F\u56E0\uFF1A${task.blockedReason.trim()}`] : [],
+      ...task.suggestedOptions?.length ? ["", "\u4F60\u53EF\u4EE5\u8FD9\u6837\u8865\u5145\uFF1A", ...task.suggestedOptions.map((item) => `- ${item}`)] : []
+    ].join("\n");
+  }
+  buildSenderPolicyHint(errorMsg, state) {
+    if (!errorMsg?.includes("senderPolicies"))
+      return "";
+    return [
+      "\u76EE\u6807 Agent \u5F53\u524D\u6CA1\u6709\u653E\u884C\u8FD9\u4E2A\u5FAE\u4FE1\u6865\u3002",
+      "\u8BF7\u5728 target agent \u7684 senderPolicies \u4E2D\u5141\u8BB8\u5F53\u524D bridge \u90AE\u7BB1\uFF0C\u5E76\u628A `wechat_sender_id` \u4F5C\u4E3A dispatchContext \u767D\u540D\u5355\u6761\u4EF6\u3002",
+      "",
+      "\u793A\u4F8B\uFF1A",
+      "[",
+      `  {"sender":"${this.config.mailbox.email}","dispatchContextRules":{"wechat_sender_id":["${state.senderId}"]}}`,
+      "]"
+    ].join("\n");
+  }
+  async replyToWechat(task, text) {
+    if (!this.state.account?.token)
+      return;
+    await sendTextMessage({
+      apiBaseUrl: this.state.account.baseUrl,
+      token: this.state.account.token,
+      botAgent: this.config.wechat.botAgent,
+      timeoutMs: 15e3,
+      toUserId: task.senderId,
+      text,
+      contextToken: task.contextToken ?? this.state.contextTokens[task.senderId]
+    });
+  }
+  async ensureTyping(task, status) {
+    if (!this.state.account?.token)
+      return;
+    const cachedTicket = this.typingTickets.get(task.senderId);
+    const ticket = cachedTicket || await getTypingTicket({
+      apiBaseUrl: this.state.account.baseUrl,
+      token: this.state.account.token,
+      botAgent: this.config.wechat.botAgent,
+      timeoutMs: 1e4,
+      ilinkUserId: task.senderId,
+      contextToken: task.contextToken ?? this.state.contextTokens[task.senderId]
+    }).catch(() => void 0);
+    if (!ticket)
+      return;
+    this.typingTickets.set(task.senderId, ticket);
+    await sendTypingStatus({
+      apiBaseUrl: this.state.account.baseUrl,
+      token: this.state.account.token,
+      botAgent: this.config.wechat.botAgent,
+      timeoutMs: 1e4,
+      ilinkUserId: task.senderId,
+      typingTicket: ticket,
+      status
+    }).catch(() => {
+    });
+    task.typingActive = status === "typing";
+  }
+  closeActiveStream(taskId) {
+    const subscription = this.activeStreamSubscriptions.get(taskId);
+    if (!subscription)
+      return;
+    subscription.close();
+    this.activeStreamSubscriptions.delete(taskId);
+  }
+  finishTask(taskId) {
+    this.liveTaskIds.delete(taskId);
+    delete this.state.tasks[taskId];
+    void this.persistState();
+  }
+  async persistState() {
+    await saveBridgeState(this.state, this.configDir);
+  }
+};
+
+// src/index.ts
+function printUsage() {
+  console.log([
+    "Usage: aamp-wechat-bridge <command> [options]",
+    "",
+    "Commands:",
+    "  init      Create or update local bridge config and AAMP mailbox credentials",
+    "  login     Start QR login and persist the WeChat bot token locally",
+    "  run       Start the local WeChat bridge daemon",
+    "  status    Show local config, login state, and target agent information",
+    "",
+    "Options:",
+    "  --config-dir <path>   Override bridge config directory",
+    "",
+    "Examples:",
+    "  aamp-wechat-bridge init",
+    "  aamp-wechat-bridge login",
+    "  aamp-wechat-bridge run"
+  ].join("\n"));
+}
+function parseCliArgs(rawArgs) {
+  let command = "run";
+  let commandAssigned = false;
+  let configDir;
+  const options = {};
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const token = rawArgs[index];
+    if (!commandAssigned && !token.startsWith("-")) {
+      command = token;
+      commandAssigned = true;
+      continue;
+    }
+    if (token === "--config-dir") {
+      const value = rawArgs[index + 1];
+      if (!value)
+        throw new Error("--config-dir requires a value");
+      configDir = value;
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("--")) {
+      const key = token.slice(2);
+      const next = rawArgs[index + 1];
+      if (!next || next.startsWith("--")) {
+        options[key] = true;
+        continue;
+      }
+      options[key] = next;
+      index += 1;
+      continue;
+    }
+  }
+  return { command, configDir, options };
+}
+async function requireConfig(configDir) {
+  const config = await loadBridgeConfig(configDir);
+  if (!config) {
+    throw new Error(`Bridge config not found at ${getBridgeHomeDir(configDir)}/config.json. Run \`aamp-wechat-bridge init\` first.`);
+  }
+  return config;
+}
+function printQrCode(url) {
+  qrcodeTerminal.generate(url, { small: true });
+  console.log(`\u626B\u7801\u94FE\u63A5: ${url}`);
+}
+async function promptVerifyCode() {
+  const rl = readline2.createInterface({ input: input2, output: output2 });
+  try {
+    const value = await rl.question("\u8BF7\u8F93\u5165\u5FAE\u4FE1\u8FD4\u56DE\u7684\u9A8C\u8BC1\u7801: ");
+    return value.trim();
+  } finally {
+    rl.close();
+  }
+}
+async function waitForQrLogin(config, state) {
+  const started = await startQrLogin({
+    apiBaseUrl: config.wechat.apiBaseUrl,
+    botType: config.wechat.botType,
+    botAgent: config.wechat.botAgent
+  });
+  console.log("\u8BF7\u4F7F\u7528\u5FAE\u4FE1\u626B\u7801\u767B\u5F55\u3002");
+  printQrCode(started.qrCodeUrl);
+  let currentBaseUrl = config.wechat.apiBaseUrl;
+  let pendingVerifyCode;
+  for (; ; ) {
+    const status = await pollQrStatus({
+      apiBaseUrl: currentBaseUrl,
+      qrCode: started.qrCode,
+      botAgent: config.wechat.botAgent,
+      ...pendingVerifyCode ? { verifyCode: pendingVerifyCode } : {}
+    });
+    pendingVerifyCode = void 0;
+    if (status.status === "wait") {
+      continue;
+    }
+    if (status.status === "scaned") {
+      console.log("\u4E8C\u7EF4\u7801\u5DF2\u626B\u63CF\uFF0C\u8BF7\u5728\u624B\u673A\u4E0A\u786E\u8BA4\u767B\u5F55\u3002");
+      continue;
+    }
+    if (status.status === "scaned_but_redirect") {
+      if (status.redirectHost) {
+        currentBaseUrl = `https://${status.redirectHost.replace(/^https?:\/\//, "").replace(/\/$/, "")}`;
+      }
+      continue;
+    }
+    if (status.status === "need_verifycode") {
+      pendingVerifyCode = await promptVerifyCode();
+      continue;
+    }
+    if (status.status === "verify_code_blocked") {
+      throw new Error("\u5FAE\u4FE1\u767B\u5F55\u9A8C\u8BC1\u5931\u8D25\u6B21\u6570\u8FC7\u591A\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C `aamp-wechat-bridge login`\u3002");
+    }
+    if (status.status === "expired") {
+      throw new Error("\u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C `aamp-wechat-bridge login`\u3002");
+    }
+    if (status.status === "binded_redirect") {
+      console.log("\u8BE5\u5FAE\u4FE1\u8D26\u53F7\u5DF2\u7ECF\u7ED1\u5B9A\u5230\u5F53\u524D\u672C\u5730 bridge\uFF0C\u7EE7\u7EED\u590D\u7528\u73B0\u6709\u767B\u5F55\u6001\u3002");
+      return state;
+    }
+    if (status.status === "confirmed") {
+      if (!status.botToken) {
+        throw new Error("\u5FAE\u4FE1\u767B\u5F55\u5DF2\u786E\u8BA4\uFF0C\u4F46\u6CA1\u6709\u8FD4\u56DE bot token\u3002");
+      }
+      const accountId = status.ilinkUserId?.trim() || "default";
+      state.account = {
+        accountId,
+        token: status.botToken,
+        baseUrl: status.baseUrl?.trim() || currentBaseUrl,
+        ilinkUserId: status.ilinkUserId?.trim() || void 0,
+        connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      state.lastLoginAt = (/* @__PURE__ */ new Date()).toISOString();
+      return state;
+    }
+    const exhaustive = status.status;
+    throw new Error(`Unexpected QR login state: ${exhaustive}`);
+  }
+}
+async function handleInit(configDir, options = {}) {
+  const config = await initializeBridgeConfig({
+    configDir,
+    aampHost: typeof options.aampHost === "string" ? options.aampHost : void 0,
+    targetAgentEmail: typeof options.targetAgentEmail === "string" ? options.targetAgentEmail : void 0,
+    slug: typeof options.slug === "string" ? options.slug : void 0,
+    summary: typeof options.summary === "string" ? options.summary : void 0,
+    botAgent: typeof options.botAgent === "string" ? options.botAgent : void 0,
+    dispatchTimeoutMs: typeof options.dispatchTimeoutMs === "string" ? Number(options.dispatchTimeoutMs) : void 0,
+    pollTimeoutMs: typeof options.pollTimeoutMs === "string" ? Number(options.pollTimeoutMs) : void 0
+  });
+  console.log(`Bridge config saved to ${getBridgeHomeDir(configDir)}/config.json`);
+  console.log(`Mailbox: ${config.mailbox.email}`);
+  console.log(`Target agent: ${config.targetAgentEmail}`);
+}
+async function handleLogin(configDir) {
+  const config = await requireConfig(configDir);
+  const state = await loadBridgeState(configDir);
+  const nextState = await waitForQrLogin(config, state);
+  await saveBridgeState(nextState, configDir);
+  console.log(`\u5FAE\u4FE1\u767B\u5F55\u6210\u529F\uFF0C\u8D26\u53F7\u6807\u8BC6: ${nextState.account?.accountId ?? "default"}`);
+}
+async function handleRun(configDir) {
+  const config = await requireConfig(configDir);
+  const state = await loadBridgeState(configDir);
+  if (!state.account?.token) {
+    throw new Error("\u5C1A\u672A\u767B\u5F55\u5FAE\u4FE1\uFF0C\u8BF7\u5148\u6267\u884C `aamp-wechat-bridge login`\u3002");
+  }
+  const runtime = new WechatBridgeRuntime(config, {
+    configDir,
+    logger: console
+  });
+  const shutdown = async () => {
+    await runtime.stop().catch(() => {
+    });
+    exit(0);
+  };
+  process.once("SIGINT", () => {
+    void shutdown();
+  });
+  process.once("SIGTERM", () => {
+    void shutdown();
+  });
+  console.log(`WeChat bridge is running for ${config.targetAgentEmail}`);
+  console.log(`Mailbox: ${config.mailbox.email}`);
+  await runtime.start();
+}
+async function handleStatus(configDir) {
+  const config = await requireConfig(configDir);
+  const state = await loadBridgeState(configDir);
+  console.log([
+    `Bridge home: ${getBridgeHomeDir(configDir)}`,
+    `AAMP host: ${config.aampHost}`,
+    `Target agent: ${config.targetAgentEmail}`,
+    `Mailbox: ${config.mailbox.email}`,
+    `WeChat API base: ${config.wechat.apiBaseUrl}`,
+    `Bot agent: ${config.wechat.botAgent}`,
+    `Logged in: ${state.account?.token ? "yes" : "no"}`,
+    ...state.account?.token ? [
+      `WeChat account: ${state.account.accountId}`,
+      `Login base URL: ${state.account.baseUrl}`,
+      `Last login: ${state.lastLoginAt ?? state.account.connectedAt}`
+    ] : []
+  ].join("\n"));
+}
+async function main() {
+  const parsed = parseCliArgs(argv.slice(2));
+  switch (parsed.command) {
+    case "help":
+    case "--help":
+    case "-h":
+      printUsage();
+      return;
+    case "init":
+      await handleInit(parsed.configDir, parsed.options);
+      return;
+    case "login":
+      await handleLogin(parsed.configDir);
+      return;
+    case "run":
+      await handleRun(parsed.configDir);
+      return;
+    case "status":
+      await handleStatus(parsed.configDir);
+      return;
+    default:
+      throw new Error(`Unknown command: ${parsed.command}`);
+  }
+}
+main().catch((error) => {
+  console.error(error.message);
+  exit(1);
+});
+//# sourceMappingURL=index.js.map