aamp-openclaw-plugin 0.1.42 → 0.1.44

package/dist/index.js

@@ -910,21 +910,17 @@ var JmapPushClient = class extends TinyEmitter {
       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("open", () => {
+      void this.handleWebSocketOpen().catch((err) => {
+        const reason = `websocket open initialization failed: ${err.message}`;
+        this.connecting = false;
+        this.connected = false;
+        this.stopPingHeartbeat();
+        this.startPolling(reason);
+        this.emit("error", new Error(`JMAP ${reason}`));
+        this.ws?.close();
+        this.scheduleReconnect();
+      });
     });
     this.ws.on("pong", () => {
     });
@@ -977,6 +973,22 @@ var JmapPushClient = class extends TinyEmitter {
       this.pingTimer = null;
     }
   }
+  async handleWebSocketOpen() {
+    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");
+  }
   startSafetySync() {
     if (this.safetySyncTimer)
       return;
@@ -1196,6 +1208,7 @@ var JmapPushClient = class extends TinyEmitter {
 
 // ../sdk/dist/pairing.js
 import { randomBytes } from "node:crypto";
+var DEFAULT_PAIRING_WEB_URL = "https://meshmail.ai/pair";
 function normalizeMailbox(value) {
   const mailbox = value.trim().toLowerCase();
   if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(mailbox)) {
@@ -1243,6 +1256,23 @@ function buildPairingUrl(payload) {
   }
   return url.toString();
 }
+function buildPairingWebUrl(payload, baseUrl2 = DEFAULT_PAIRING_WEB_URL) {
+  const mailbox = normalizeMailbox(payload.mailbox);
+  const pairCode = payload.pairCode.trim();
+  if (!pairCode)
+    throw new Error("pairCode cannot be empty");
+  const url = new URL(baseUrl2);
+  url.searchParams.set("mailbox", mailbox);
+  url.searchParams.set("pair_code", pairCode);
+  const rules = normalizeDispatchContextRules(payload.dispatchContextRules);
+  if (rules) {
+    url.searchParams.set("dispatch_context_rules", encodeBase64UrlJson2(rules));
+  }
+  return url.toString();
+}
+function pairingUrlToWebUrl(input, baseUrl2 = DEFAULT_PAIRING_WEB_URL) {
+  return buildPairingWebUrl(parsePairingUrl(input), baseUrl2);
+}
 function createPairingCode(options) {
   const pairCode = options.pairCode?.trim() || randomBytes(6).toString("base64url");
   const dispatchContextRules = normalizeDispatchContextRules(options.dispatchContextRules);
@@ -1265,8 +1295,10 @@ function parsePairingUrl(input) {
   } catch {
     throw new Error("Invalid pairing URL");
   }
-  if (url.protocol !== "aamp:" || url.hostname !== "connect") {
-    throw new Error("Pairing URL must start with aamp://connect");
+  const isDeepLink = url.protocol === "aamp:" && url.hostname === "connect";
+  const isWebLink = (url.protocol === "https:" || url.protocol === "http:") && url.hostname === "meshmail.ai" && url.pathname === "/pair";
+  if (!isDeepLink && !isWebLink) {
+    throw new Error("Pairing URL must start with aamp://connect or https://meshmail.ai/pair");
   }
   const mailbox = url.searchParams.get("mailbox") ?? "";
   const pairCode = url.searchParams.get("pair_code") ?? "";
@@ -1585,37 +1617,102 @@ var SmtpSender = class _SmtpSender {
     const data = await res.json();
     return data.methodResponses ?? [];
   }
-  async uploadSentAttachment(attachment) {
+  async uploadJmapBlob(params) {
     const session = await this.resolveJmapSession();
-    const content = typeof attachment.content === "string" ? Buffer.from(attachment.content, "base64") : attachment.content;
     const uploadUrl = session.uploadUrl.replace(/\{accountId\}|%7BaccountId%7D/gi, encodeURIComponent(session.accountId));
     const res = await this.fetch(uploadUrl, {
       method: "POST",
       headers: {
         Authorization: this.getJmapAuthHeader(),
-        "Content-Type": attachment.contentType
+        "Content-Type": params.contentType
       },
-      body: content
+      body: params.content
     });
     const bodyText = await res.text();
     if (!res.ok) {
-      throw new Error(`JMAP attachment upload failed: ${res.status} ${bodyText}`);
+      throw new Error(`JMAP blob upload failed: ${res.status} ${bodyText}`);
     }
     let data;
     try {
       data = JSON.parse(bodyText);
     } catch {
-      throw new Error("JMAP attachment upload returned invalid JSON");
+      throw new Error("JMAP blob upload returned invalid JSON");
     }
     if (!data.blobId) {
-      throw new Error("JMAP attachment upload did not return blobId");
+      throw new Error("JMAP blob upload did not return blobId");
     }
     return {
       blobId: data.blobId,
-      type: data.type ?? attachment.contentType,
-      size: data.size ?? content.byteLength,
-      name: attachment.filename
+      type: data.type ?? params.contentType,
+      size: data.size ?? params.content.byteLength
+    };
+  }
+  async buildRawSentMessage(params) {
+    const rawTransport = createTransport({
+      streamTransport: true,
+      buffer: true,
+      newline: "unix"
+    });
+    const mailOptions = {
+      from: params.from,
+      to: params.to,
+      subject: params.subject,
+      text: params.text,
+      headers: params.aampHeaders
     };
+    if (params.messageId)
+      mailOptions.messageId = sanitize(params.messageId);
+    if (params.inReplyTo)
+      mailOptions.inReplyTo = params.inReplyTo;
+    if (params.references)
+      mailOptions.references = params.references;
+    if (params.attachments?.length) {
+      mailOptions.attachments = params.attachments.map((attachment) => ({
+        filename: attachment.filename,
+        contentType: attachment.contentType,
+        content: typeof attachment.content === "string" ? Buffer.from(attachment.content, "base64") : attachment.content
+      }));
+    }
+    const info = await rawTransport.sendMail(mailOptions);
+    const rawMessage = info.message;
+    if (Buffer.isBuffer(rawMessage))
+      return rawMessage;
+    if (rawMessage instanceof Uint8Array)
+      return Buffer.from(rawMessage);
+    if (typeof rawMessage === "string")
+      return Buffer.from(rawMessage);
+    throw new Error("Raw message generation did not return a Buffer");
+  }
+  async importRawSentMessage(params) {
+    if (!this.canPersistSentCopy())
+      return;
+    const sentMailboxId = await this.getSentMailboxId();
+    if (!sentMailboxId)
+      return;
+    const rawMessage = await this.buildRawSentMessage(params);
+    const uploadedMessage = await this.uploadJmapBlob({
+      content: rawMessage,
+      contentType: "message/rfc822"
+    });
+    const responses = await this.jmapCall([
+      [
+        "Email/import",
+        {
+          emails: {
+            sent1: {
+              blobId: uploadedMessage.blobId,
+              mailboxIds: { [sentMailboxId]: true },
+              keywords: { "$seen": true }
+            }
+          }
+        },
+        "import1"
+      ]
+    ]);
+    const result = responses.find(([name]) => name === "Email/import")?.[1];
+    if (result?.notImported?.sent1) {
+      throw new Error(`JMAP sent message import failed: ${JSON.stringify(result.notImported.sent1)}`);
+    }
   }
   async getSentMailboxId() {
     if (!this.sentMailboxIdPromise) {
@@ -1638,10 +1735,13 @@ var SmtpSender = class _SmtpSender {
   async saveToSent(params) {
     if (!this.canPersistSentCopy())
       return;
+    if (params.attachments?.length) {
+      await this.importRawSentMessage(params);
+      return;
+    }
     const sentMailboxId = await this.getSentMailboxId();
     if (!sentMailboxId)
       return;
-    const uploadedAttachments = params.attachments?.length ? await Promise.all(params.attachments.map((attachment) => this.uploadSentAttachment(attachment))) : [];
     const emailCreate = {
       mailboxIds: { [sentMailboxId]: true },
       from: [{ email: params.from }],
@@ -1649,35 +1749,13 @@ var SmtpSender = class _SmtpSender {
       subject: params.subject,
       keywords: { "$seen": true }
     };
-    if (uploadedAttachments.length) {
-      emailCreate.bodyStructure = {
-        type: "multipart/mixed",
-        subParts: [
-          { partId: "body", type: "text/plain" },
-          ...uploadedAttachments.map((attachment) => ({
-            blobId: attachment.blobId,
-            type: attachment.type,
-            size: attachment.size,
-            name: attachment.name,
-            disposition: "attachment"
-          }))
-        ]
-      };
-      emailCreate.bodyValues = {
-        body: {
-          value: params.text,
-          isTruncated: false
-        }
-      };
-    } else {
-      emailCreate.bodyValues = {
-        body: {
-          value: params.text,
-          charset: "utf-8"
-        }
-      };
-      emailCreate.textBody = [{ partId: "body", type: "text/plain" }];
-    }
+    emailCreate.bodyValues = {
+      body: {
+        value: params.text,
+        charset: "utf-8"
+      }
+    };
+    emailCreate.textBody = [{ partId: "body", type: "text/plain" }];
     if (params.inReplyTo) {
       emailCreate["header:In-Reply-To:asText"] = ` ${sanitize(params.inReplyTo)}`;
     }
@@ -2350,6 +2428,25 @@ function buildRegisteredCommandDispatchPayload(opts) {
   };
 }
 var DEFAULT_TASK_DISPATCH_CONCURRENCY = 10;
+function asStreamRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return void 0;
+  return value;
+}
+function normalizeSseStreamEvent(params) {
+  const record = asStreamRecord(params.data) ?? {};
+  const payload = asStreamRecord(record.payload) ?? record;
+  const seqValue = Number(record.seq);
+  return {
+    id: typeof record.id === "string" && record.id ? record.id : params.eventId,
+    streamId: String(record.streamId ?? params.streamId),
+    taskId: String(record.taskId ?? ""),
+    seq: Number.isFinite(seqValue) ? seqValue : params.seq,
+    timestamp: String(record.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()),
+    type: String(record.type ?? params.eventType ?? "message"),
+    payload
+  };
+}
 function normalizeTaskDispatchConcurrency(value) {
   if (value == null)
     return DEFAULT_TASK_DISPATCH_CONCURRENCY;
@@ -2365,6 +2462,7 @@ var AampClient = class _AampClient extends TinyEmitter {
   taskDispatchConcurrency;
   pendingTaskDispatches = [];
   activeTaskDispatchCount = 0;
+  discoveryPromise;
   streamAppendQueues = /* @__PURE__ */ new Map();
   constructor(config) {
     super();
@@ -2476,6 +2574,8 @@ var AampClient = class _AampClient extends TinyEmitter {
   }
   static createPairingCode = createPairingCode;
   static buildPairingUrl = buildPairingUrl;
+  static buildPairingWebUrl = buildPairingWebUrl;
+  static pairingUrlToWebUrl = pairingUrlToWebUrl;
   static parsePairingUrl = parsePairingUrl;
   static isPairingUrl = isPairingUrl;
   static consumePairingCode = consumePairingCode;
@@ -2513,6 +2613,38 @@ var AampClient = class _AampClient extends TinyEmitter {
       ...opts.body ? { body: JSON.stringify(opts.body) } : {}
     });
   }
+  discoverCachedAampService() {
+    if (!this.discoveryPromise) {
+      const discoveryPromise = _AampClient.discoverAampService(this.config.baseUrl, this.config.fetch);
+      this.discoveryPromise = discoveryPromise;
+      void discoveryPromise.catch(() => {
+        if (this.discoveryPromise === discoveryPromise) {
+          this.discoveryPromise = void 0;
+        }
+      });
+    }
+    return this.discoveryPromise;
+  }
+  async callAampApi(opts) {
+    const fetchImpl = this.config.fetch ?? fetch;
+    const discovery = await this.discoverCachedAampService();
+    const base = this.config.baseUrl.replace(/\/$/, "");
+    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 fetchImpl(apiUrl, {
+      method: opts.method ?? "GET",
+      headers: {
+        ...opts.authToken ? { Authorization: `Basic ${opts.authToken}` } : {},
+        ...opts.body ? { "Content-Type": "application/json" } : {}
+      },
+      body: opts.body ? JSON.stringify(opts.body) : void 0
+    });
+  }
   static async registerMailbox(opts) {
     const base = opts.aampHost.replace(/\/$/, "");
     const registerRes = await _AampClient.callDiscoveredApi(base, {
@@ -2738,7 +2870,7 @@ var AampClient = class _AampClient extends TinyEmitter {
     };
   }
   async resolveStreamCapability() {
-    const discovery = await _AampClient.discoverAampService(this.config.baseUrl, this.config.fetch);
+    const discovery = await this.discoverCachedAampService();
     const stream = discovery.capabilities?.stream;
     if (!stream?.transport) {
       throw new Error("AAMP stream capability is not available on this service");
@@ -2747,11 +2879,10 @@ var AampClient = class _AampClient extends TinyEmitter {
   }
   async createStream(opts) {
     const stream = await this.resolveStreamCapability();
-    const res = await _AampClient.callDiscoveredApi(this.config.baseUrl, {
+    const res = await this.callAampApi({
       action: stream.createAction ?? "aamp.stream.create",
       method: "POST",
       authToken: this.config.mailboxToken,
-      fetch: this.config.fetch,
       body: opts
     });
     if (!res.ok) {
@@ -2794,11 +2925,10 @@ var AampClient = class _AampClient extends TinyEmitter {
   }
   async dispatchStreamAppend(opts) {
     const stream = await this.resolveStreamCapability();
-    const res = await _AampClient.callDiscoveredApi(this.config.baseUrl, {
+    const res = await this.callAampApi({
       action: stream.appendAction ?? "aamp.stream.append",
       method: "POST",
       authToken: this.config.mailboxToken,
-      fetch: this.config.fetch,
       body: opts
     });
     if (!res.ok) {
@@ -2900,11 +3030,10 @@ var AampClient = class _AampClient extends TinyEmitter {
   async closeStream(opts) {
     await this.flushStreamAppendQueue(opts.streamId);
     const stream = await this.resolveStreamCapability();
-    const res = await _AampClient.callDiscoveredApi(this.config.baseUrl, {
+    const res = await this.callAampApi({
       action: stream.closeAction ?? "aamp.stream.close",
       method: "POST",
       authToken: this.config.mailboxToken,
-      fetch: this.config.fetch,
       body: opts
     });
     if (!res.ok) {
@@ -2915,10 +3044,9 @@ var AampClient = class _AampClient extends TinyEmitter {
   }
   async getTaskStream(opts) {
     const stream = await this.resolveStreamCapability();
-    const res = await _AampClient.callDiscoveredApi(this.config.baseUrl, {
+    const res = await this.callAampApi({
       action: stream.getAction ?? "aamp.stream.get",
       authToken: this.config.mailboxToken,
-      fetch: this.config.fetch,
       query: {
         ...opts.taskId ? { taskId: opts.taskId } : {},
         ...opts.streamId ? { streamId: opts.streamId } : {}
@@ -2949,7 +3077,8 @@ var AampClient = class _AampClient extends TinyEmitter {
     const res = await fetchImpl(url, {
       headers: {
         Authorization: `Basic ${this.config.mailboxToken}`,
-        Accept: "text/event-stream"
+        Accept: "text/event-stream",
+        ...opts.lastEventId ? { "Last-Event-ID": opts.lastEventId } : {}
       },
       signal: controller.signal
     });
@@ -2963,16 +3092,19 @@ var AampClient = class _AampClient extends TinyEmitter {
     let currentEvent = "message";
     let currentId = "";
     let currentData = [];
+    let fallbackSeq = 0;
     const flush = () => {
       if (!currentData.length)
         return;
       try {
-        const parsed = JSON.parse(currentData.join("\n"));
-        handlers.onEvent({
-          ...parsed,
-          ...currentId ? { id: currentId } : {},
-          type: parsed.type ?? currentEvent
-        });
+        fallbackSeq += 1;
+        handlers.onEvent(normalizeSseStreamEvent({
+          data: JSON.parse(currentData.join("\n")),
+          streamId,
+          eventType: currentEvent,
+          eventId: currentId || void 0,
+          seq: fallbackSeq
+        }));
       } catch (err) {
         handlers.onError?.(err);
       } finally {
@@ -3058,6 +3190,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { randomBytes as randomBytes2 } from "node:crypto";
+var DEFAULT_PAIRING_WEB_URL2 = "https://meshmail.ai/pair";
 function defaultCredentialsPath() {
   return join(homedir(), ".openclaw", "extensions", "aamp-openclaw-plugin", ".credentials.json");
 }
@@ -3131,6 +3264,14 @@ function createPairingCode2(params) {
   writeFileSync(resolved, JSON.stringify(state, null, 2), "utf-8");
   return state;
 }
+function pairingUrlToWebUrl2(connectUrl) {
+  const parsed = new URL(connectUrl);
+  const url = new URL(DEFAULT_PAIRING_WEB_URL2);
+  for (const [key, value] of parsed.searchParams) {
+    url.searchParams.set(key, value);
+  }
+  return url.toString();
+}
 function consumePairingCode2(params) {
   const resolved = params.file ?? defaultPairingPath();
   if (!existsSync(resolved))
@@ -3317,8 +3458,11 @@ async function ensureTaskStream(task) {
   });
   await aampClient.appendStreamEvent({
     streamId: created.streamId,
-    type: "status",
-    payload: { state: "running", label: "Task queued in OpenClaw" }
+    type: "todo",
+    payload: {
+      items: [{ id: "openclaw-queued", content: "Task queued in OpenClaw", status: "in_progress" }],
+      summary: "Task queued in OpenClaw"
+    }
   });
   activeTaskStreams.set(task.taskId, created.streamId);
   return created.streamId;
@@ -3750,8 +3894,10 @@ var src_default = {
         mailbox: email,
         file: cfg.pairingFile ?? defaultPairingPath()
       });
-      const qr = await renderTerminalQr(pairing.connectUrl);
+      const webUrl = pairingUrlToWebUrl2(pairing.connectUrl);
+      const qr = await renderTerminalQr(webUrl);
       api.logger.info(`[AAMP] Pair with AAMP App before ${pairing.expiresAt}: ${pairing.connectUrl}`);
+      api.logger.info(`[AAMP] Web pairing link: ${webUrl}`);
       if (qr)
         api.logger.info(`
 ${qr}`);
@@ -3762,7 +3908,8 @@ ${qr}`);
 Scan this QR code:
 ${qr}` : "\nCould not render a terminal QR code.",
         `
-Pairing URL: ${pairing.connectUrl}`
+Pairing link: ${webUrl}`,
+        `Pairing URL: ${pairing.connectUrl}`
       ].join("\n");
     }
     function wakeAgentForPendingTask(task) {
@@ -3854,7 +4001,7 @@ Pairing URL: ${pairing.connectUrl}`
         file: cfg.pairingFile ?? defaultPairingPath()
       });
       api.logger.info(`[AAMP] Pair with AAMP App before ${pairing.expiresAt}: ${pairing.connectUrl}`);
-      const qr = await renderTerminalQr(pairing.connectUrl);
+      const qr = await renderTerminalQr(pairingUrlToWebUrl2(pairing.connectUrl));
       if (qr)
         api.logger.info(`
 ${qr}`);
@@ -4590,9 +4737,9 @@ ${task.bodyText}` : "",
             content: readBinaryFile(a.path)
           }));
         }
-        await appendTaskStream(task.taskId, "status", {
-          state: "completing",
-          label: `Sending ${p.status} result`
+        await appendTaskStream(task.taskId, "todo", {
+          items: [{ id: "openclaw-result", content: `Sending ${p.status} result`, status: "completed" }],
+          summary: `Sending ${p.status} result`
         });
         if (p.output) {
           await appendTaskStream(task.taskId, "text.delta", { text: p.output });
@@ -4671,9 +4818,9 @@ ${task.bodyText}` : "",
         if (!aampClient?.isConnected()) {
           return { content: [{ type: "text", text: "Error: AAMP client is not connected." }] };
         }
-        await appendTaskStream(task.taskId, "status", {
-          state: "help_needed",
-          label: p.blockedReason
+        await appendTaskStream(task.taskId, "todo", {
+          items: [{ id: "openclaw-help", content: p.blockedReason, status: "completed" }],
+          summary: p.blockedReason
         });
         try {
           await aampClient.sendHelp({
@@ -4686,12 +4833,9 @@ ${task.bodyText}` : "",
           });
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
-          await appendTaskStream(task.taskId, "error", {
-            message: `Failed to send help request: ${message}`
-          });
-          await appendTaskStream(task.taskId, "status", {
-            state: "running",
-            label: "Help request failed; task still needs a reply"
+          await appendTaskStream(task.taskId, "todo", {
+            items: [{ id: "openclaw-help", content: "Help request failed; task still needs a reply", status: "in_progress" }],
+            summary: `Failed to send help request: ${message}`
           });
           api.logger.error(`[AAMP] aamp_send_help failed for ${task.taskId}: ${message}`);
           return {
@@ -4751,7 +4895,7 @@ ${lines.join("\n")}`
     }, { name: "aamp_pending_tasks" });
     api.registerTool({
       name: "aamp_pairing_code",
-      description: "Generate a fresh five-minute AAMP pairing code for this OpenClaw agent and show a QR code. Use this when the user asks to pair AAMP App or another AAMP runtime with this agent.",
+      description: 'Generate a fresh five-minute AAMP pairing code for this OpenClaw agent and show a QR code. Use this immediately when the user asks for a pairing code, connect code, QR code, pairing link, invite link, or Chinese requests such as "\u53D1\u5BF9\u63A5\u7801", "\u751F\u6210\u914D\u5BF9\u7801", "\u5F39\u51FA\u4E8C\u7EF4\u7801", or "\u7ED9\u6211\u8FDE\u63A5\u4E8C\u7EF4\u7801".',
       parameters: { type: "object", properties: {} },
       execute: async () => ({
         content: [{ type: "text", text: await renderPairingCodeForCurrentAgent() }]
@@ -5020,7 +5164,7 @@ Question: ${h.question}`,
     });
     api.registerCommand({
       name: "aamp-pair",
-      description: "Show a fresh AAMP pairing QR code for this OpenClaw agent",
+      description: "Show a fresh AAMP pairing QR code, web pairing link, and aamp://connect URL for this OpenClaw agent",
       acceptsArgs: false,
       requireAuth: false,
       handler: async () => ({