@pmate/cli 0.21.15 → 0.21.17

package/dist/index.js

@@ -9435,8 +9435,8 @@ __export(index_exports, {
   parseCommandArgs: () => parseCommandArgs
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_fs21 = require("fs");
-var import_node_path26 = __toESM(require("path"));
+var import_node_fs22 = require("fs");
+var import_node_path27 = __toESM(require("path"));
 var import_chalk4 = __toESM(require("chalk"));
 
 // src/cli.ts
@@ -14585,9 +14585,9 @@ ${indent}\`\`\``;
   static richTextToPlain(richText) {
     return richText.map((item) => item.plain_text ?? item.text?.content ?? "").join("").trim();
   }
-  static async requestJson(path27, init) {
+  static async requestJson(path28, init) {
     const token = this.getToken();
-    const response = await fetch(`${this.baseUrl}${path27}`, {
+    const response = await fetch(`${this.baseUrl}${path28}`, {
       method: init.method,
       headers: {
         Authorization: `Bearer ${token}`,
@@ -15664,6 +15664,10 @@ var QuizCommandHandler = class {
 
 // src/commands/CollectCommandHandler.ts
 var import_playwright = require("playwright");
+var import_node_crypto4 = require("crypto");
+var import_node_fs12 = require("fs");
+var import_node_os7 = __toESM(require("os"));
+var import_node_path17 = __toESM(require("path"));
 
 // src/collectStore.ts
 var import_node_crypto3 = require("crypto");
@@ -15683,30 +15687,18 @@ function toThreadKey(name) {
   return `${base}-${suffix}`;
 }
 async function readStoredThread(rootDir, threadKey) {
-  const filePath = getThreadMetaFilePath(rootDir, threadKey);
+  const filePath = getThreadFilePath(rootDir, threadKey);
   try {
     const raw = await import_node_fs11.promises.readFile(filePath, "utf8");
-    const parsed = JSON.parse(raw);
-    if ("messages" in parsed && Array.isArray(parsed.messages)) {
-      return parsed;
-    }
-    const messages2 = await readStoredMessages(rootDir, threadKey);
-    return {
-      ...parsed,
-      messages: messages2
-    };
+    return JSON.parse(raw);
   } catch {
-    return readLegacyStoredThread(rootDir, threadKey);
+    return null;
   }
 }
 async function writeStoredThread(rootDir, thread) {
-  const metaPath = getThreadMetaFilePath(rootDir, thread.threadKey);
-  const messagePath = getThreadMessagesFilePath(rootDir, thread.threadKey);
-  const { messages: messages2, ...meta } = thread;
-  await import_node_fs11.promises.mkdir(import_node_path16.default.dirname(metaPath), { recursive: true });
-  await import_node_fs11.promises.writeFile(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf8");
-  const body = messages2.map((message) => JSON.stringify(message)).join("\n");
-  await import_node_fs11.promises.writeFile(messagePath, `${body}${body ? "\n" : ""}`, "utf8");
+  const filePath = getThreadFilePath(rootDir, thread.threadKey);
+  await import_node_fs11.promises.mkdir(import_node_path16.default.dirname(filePath), { recursive: true });
+  await import_node_fs11.promises.writeFile(filePath, JSON.stringify(thread, null, 2) + "\n", "utf8");
 }
 async function writeStoredIndex(rootDir, index) {
   await import_node_fs11.promises.mkdir(rootDir, { recursive: true });
@@ -15714,91 +15706,22 @@ async function writeStoredIndex(rootDir, index) {
   await import_node_fs11.promises.writeFile(filePath, JSON.stringify(index, null, 2) + "\n", "utf8");
 }
 function mergeMessages(existing, incoming) {
-  const seenMessageIds = new Set(
-    existing.map((message) => normalizeMessageId(message.messageId)).filter((value) => !!value)
-  );
+  const seen = new Set(existing.map((message) => message.hash));
   const merged = [...existing];
   let added = 0;
   for (const message of incoming) {
-    const incomingMessageId = normalizeMessageId(message.messageId);
-    if (incomingMessageId && seenMessageIds.has(incomingMessageId)) {
-      continue;
-    }
-    const upgradeIndex = merged.findIndex((current) => shouldUpgradeMessage(current, message));
-    if (upgradeIndex >= 0) {
-      merged[upgradeIndex] = message;
-      if (incomingMessageId) {
-        seenMessageIds.add(incomingMessageId);
-      }
+    if (seen.has(message.hash)) {
       continue;
     }
-    if (incomingMessageId) {
-      seenMessageIds.add(incomingMessageId);
-    }
+    seen.add(message.hash);
     merged.push(message);
     added += 1;
   }
   return { messages: merged, added };
 }
-function shouldUpgradeMessage(existing, incoming) {
-  const existingMessageId = normalizeMessageId(existing.messageId);
-  const incomingMessageId = normalizeMessageId(incoming.messageId);
-  if (existingMessageId && incomingMessageId && existingMessageId === incomingMessageId) {
-    return false;
-  }
-  if (existing.time && incoming.time && existing.time !== incoming.time) {
-    return false;
-  }
-  return normalizeMessageField(existing.sender) === normalizeMessageField(incoming.sender) && normalizeMessageField(existing.content) === normalizeMessageField(incoming.content) && joinNormalized(existing.links) === joinNormalized(incoming.links) && joinNormalized(existing.images) === joinNormalized(incoming.images) && (!!incoming.time && !existing.time);
-}
-function normalizeMessageField(value) {
-  return (value ?? "").trim();
-}
-function normalizeMessageId(value) {
-  const normalized = (value ?? "").trim();
-  return normalized || null;
-}
-function joinNormalized(values) {
-  return values.map((value) => value.trim()).join("|");
-}
-async function readStoredMessages(rootDir, threadKey) {
-  const filePath = getThreadMessagesFilePath(rootDir, threadKey);
-  try {
-    const raw = await import_node_fs11.promises.readFile(filePath, "utf8");
-    return raw.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => normalizeStoredMessage(JSON.parse(line)));
-  } catch {
-    return [];
-  }
-}
-async function readLegacyStoredThread(rootDir, threadKey) {
-  const filePath = getLegacyThreadFilePath(rootDir, threadKey);
-  try {
-    const raw = await import_node_fs11.promises.readFile(filePath, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function getThreadMetaFilePath(rootDir, threadKey) {
-  return import_node_path16.default.join(rootDir, "threads", `${threadKey}.json`);
-}
-function getThreadMessagesFilePath(rootDir, threadKey) {
-  return import_node_path16.default.join(rootDir, "threads", `${threadKey}.jsonl`);
-}
-function getLegacyThreadFilePath(rootDir, threadKey) {
+function getThreadFilePath(rootDir, threadKey) {
   return import_node_path16.default.join(rootDir, "threads", `${threadKey}.json`);
 }
-function normalizeStoredMessage(message) {
-  return {
-    messageId: normalizeMessageId(message.messageId),
-    time: message.time ?? null,
-    sender: message.sender ?? null,
-    content: message.content ?? "",
-    links: Array.isArray(message.links) ? message.links : [],
-    images: Array.isArray(message.images) ? message.images : [],
-    collectedAt: message.collectedAt
-  };
-}
 
 // src/commands/CollectCommandHandler.ts
 var CollectCommandHandler = class {
@@ -15813,39 +15736,22 @@ var CollectCommandHandler = class {
       if (!targetPage) {
         throw new Error("Cannot find target page from CDP contexts.");
       }
-      const threads = await this.extractThreadsFromConversationData(targetPage);
+      const { rows } = await this.locateThreadRows(targetPage);
+      const threads = await this.extractThreads(rows);
       if (threads.length === 0) {
-        throw new Error("No threads found in CC data store.");
+        throw new Error("No threads found in target page.");
       }
       const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
       const results = [];
-      const failures = [];
       for (const thread of threads) {
-        try {
-          const threadKey = toThreadKey(thread.name);
-          const existing = await readStoredThread(target.rootDir, threadKey);
-          const messages2 = await this.extractMessages(targetPage, thread, existing?.messages ?? []);
-          const result = await this.persistThread(
-            target.rootDir,
-            target,
-            thread,
-            messages2,
-            syncedAt,
-            existing
-          );
-          results.push(result);
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          failures.push({ threadName: thread.name, message });
-          ui.warn(`Skipped thread: ${thread.name}`, message);
-        }
-      }
-      if (results.length === 0) {
-        const firstFailure = failures[0]?.message ?? "No thread could be collected.";
-        throw new Error(firstFailure);
+        await this.clickThreadRow(rows, thread);
+        await targetPage.waitForTimeout(1200);
+        const messages2 = await this.extractMessages(targetPage, thread.name);
+        const result = await this.persistThread(target.rootDir, target, thread, messages2, syncedAt);
+        results.push(result);
       }
       await this.writeIndex(target.rootDir, target, results, syncedAt);
-      this.printSyncSummary(target.sourceKey, target.rootDir, threads.length, results, failures);
+      this.printSyncSummary(target.sourceKey, target.rootDir, threads.length, results);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw new Error(`collect failed: ${message}`);
@@ -15853,10 +15759,11 @@ var CollectCommandHandler = class {
       await browser?.close().catch(() => void 0);
     }
   }
-  async persistThread(rootDir, target, thread, messages2, syncedAt, existing) {
+  async persistThread(rootDir, target, thread, messages2, syncedAt) {
     const threadKey = toThreadKey(thread.name);
+    const existing = await readStoredThread(rootDir, threadKey);
     const incoming = messages2.map((message) => ({
-      messageId: message.messageId,
+      hash: message.hash,
       time: message.time,
       sender: message.sender,
       content: message.content,
@@ -15904,18 +15811,14 @@ var CollectCommandHandler = class {
       threads
     });
   }
-  printSyncSummary(sourceKey, rootDir, scannedThreads, results, failures) {
+  printSyncSummary(sourceKey, rootDir, scannedThreads, results) {
     const updatedThreads = results.filter((result) => result.updated).length;
     const newMessages = results.reduce((sum, result) => sum + result.addedMessages, 0);
     ui.plain(`Synced source: ${sourceKey}`);
     ui.plain(`Threads scanned: ${scannedThreads}`);
     ui.plain(`Threads updated: ${updatedThreads}`);
-    ui.plain(`Threads failed: ${failures.length}`);
     ui.plain(`New messages: ${newMessages}`);
     ui.plain(`Saved under: ${rootDir}`);
-    for (const failure of failures.slice(0, 10)) {
-      ui.warn(`Thread failed: ${failure.threadName}`, failure.message);
-    }
   }
   async pickTargetPage(pages) {
     let best = null;
@@ -15930,307 +15833,364 @@ var CollectCommandHandler = class {
     }
     return best?.page ?? null;
   }
-  async extractThreadsFromConversationData(page) {
-    const result = await this.evaluateInPage(page, buildListThreadsExpr()).catch((error) => ({
-      ok: false,
-      reason: error instanceof Error ? error.message : String(error)
-    }));
-    if (!result || !("ok" in result) || !result.ok || !Array.isArray(result.threads)) {
-      throw new Error(
-        result && "reason" in result && typeof result.reason === "string" ? result.reason : "unknown error"
-      );
+  async locateThreadRows(page) {
+    const preferred = page.locator(".ReactVirtualized__Grid__innerScrollContainer").first();
+    const preferredCount = await preferred.locator(":scope > *").count().catch(() => 0);
+    if (preferredCount >= 1) {
+      return { rows: preferred.locator(":scope > *") };
+    }
+    const seeds = [
+      '[role="list"]',
+      '[role="listbox"]',
+      '[class*="list" i]',
+      '[class*="conversation" i]',
+      '[class*="thread" i]',
+      '[class*="chat" i]',
+      "div"
+    ];
+    let best = null;
+    for (const seed of seeds) {
+      const containers = page.locator(seed);
+      const count = await containers.count().catch(() => 0);
+      const max = seed === "div" ? Math.min(count, 180) : Math.min(count, 40);
+      for (let i = 0; i < max; i += 1) {
+        const rows = containers.nth(i).locator(":scope > *");
+        const rowCount = await rows.count().catch(() => 0);
+        if (rowCount < 1 || rowCount > 500) {
+          continue;
+        }
+        const textCount = await containers.nth(i).locator("text=/./").count().catch(() => 0);
+        const score = rowCount + Math.min(textCount, rowCount * 4);
+        if (!best || score > best.score) {
+          best = { rows, score };
+        }
+      }
     }
-    return result.threads.map((thread) => ({
-      conversationId: normalizeText(thread.conversationId ?? ""),
-      name: normalizeText(thread.name ?? ""),
-      unread: normalizeUnreadCount(thread.unread),
-      preview: normalizeText(thread.preview ?? ""),
-      time: formatSentAt(thread.sentAt)
-    })).filter((thread) => thread.conversationId && thread.name);
-  }
-  async extractMessages(page, thread, existingMessages) {
-    const fromDataStore = await this.extractMessagesFromConversationData(
-      page,
-      thread,
-      existingMessages
-    );
-    if ("error" in fromDataStore) {
-      throw new Error(
-        `Failed to load messages from CC data store for thread: ${thread.name} (${fromDataStore.error})`
-      );
+    if (!best) {
+      throw new Error("Failed to detect thread list container.");
     }
-    return fromDataStore.messages;
+    return { rows: best.rows };
   }
-  async extractMessagesFromConversationData(page, thread, existingMessages) {
-    const limit = Math.max(existingMessages.length + 40, 100);
-    const result = await this.evaluateInPage(
-      page,
-      buildGetMessagesByConversationExpr(thread.conversationId, limit)
-    ).catch((error) => ({ ok: false, reason: error instanceof Error ? error.message : String(error) }));
-    if (!result || !("ok" in result) || !result.ok || !Array.isArray(result.messages)) {
-      return {
-        error: result && "reason" in result && typeof result.reason === "string" ? result.reason : "unknown error"
-      };
-    }
-    const seenMessageIds = new Set(
-      existingMessages.map((message) => (message.messageId ?? "").trim()).filter((value) => !!value)
-    );
-    const collected = [];
-    for (let i = result.messages.length - 1; i >= 0; i -= 1) {
-      const raw = result.messages[i];
-      const contentParts = [normalizeText(raw.body ?? "")];
-      if (raw.quote?.text) {
-        contentParts.unshift(`Quote: ${normalizeText(raw.quote.text)}`);
-      }
-      const attachmentPaths = Array.isArray(raw.attachments) ? raw.attachments.map((attachment) => attachment.path ?? null).filter((value) => !!value) : [];
+  async extractThreads(rows) {
+    const count = await rows.count().catch(() => 0);
+    const result = [];
+    for (let i = 0; i < count; i += 1) {
+      const lines = await this.collectLines(rows.nth(i), 12);
+      if (lines.length === 0) {
+        continue;
+      }
+      const unread = this.extractUnread(lines);
+      const time = this.findTime(lines);
+      const name = this.findThreadName(lines, time);
+      if (!name) {
+        continue;
+      }
+      const preview = lines.find(
+        (line) => line !== name && line !== time && !/^\d{1,4}\+?$/.test(line) && !/^\[[^\]]+\]$/.test(line)
+      ) ?? "";
+      result.push({ index: i, name, unread, preview, time });
+    }
+    return dedupeThreads(result);
+  }
+  async extractMessages(page, threadName) {
+    const container = await this.locateMessageContainer(page);
+    const rows = container.locator(":scope > *");
+    const count = await rows.count().catch(() => 0);
+    const messages2 = [];
+    let lastFingerprint = "";
+    for (let i = 0; i < count; i += 1) {
+      const row = rows.nth(i);
+      const rawText = normalizeText(await row.textContent().catch(() => "") || "");
+      const links = await this.extractLinks(row);
+      const images = await this.extractImages(row);
+      const parsed = parseMessageText(rawText);
       const message = {
-        index: raw.index,
-        messageId: normalizeText(raw.id ?? "") || null,
-        time: formatSentAt(raw.sentAt),
-        sender: normalizeText(raw.senderName ?? raw.source ?? "") || null,
-        content: contentParts.filter(Boolean).join("\n") || (attachmentPaths.length > 0 ? "[Image]" : ""),
-        links: [],
-        images: attachmentPaths
+        index: i,
+        hash: "",
+        time: parsed.time,
+        sender: parsed.sender,
+        content: parsed.content || (images.length > 0 ? "[Image]" : ""),
+        links,
+        images
       };
-      if (!message.content && message.images.length === 0) {
+      message.hash = computeMessageHash(threadName, message);
+      const fingerprint = [
+        message.time ?? "",
+        message.sender ?? "",
+        message.content,
+        message.links.join("|"),
+        message.images.join("|")
+      ].join("||");
+      if (!message.content && message.links.length === 0 && message.images.length === 0) {
         continue;
       }
-      if (message.messageId && seenMessageIds.has(message.messageId)) {
-        break;
+      if (fingerprint === lastFingerprint) {
+        continue;
       }
-      collected.push(message);
+      lastFingerprint = fingerprint;
+      messages2.push(message);
     }
-    return { messages: finalizeIncrementalMessages(collected, true) };
+    return messages2;
   }
-  async evaluateInPage(page, expression) {
-    const session = await page.context().newCDPSession(page);
-    try {
-      const response = await session.send("Runtime.evaluate", {
-        expression,
-        returnByValue: true,
-        awaitPromise: true
-      });
-      if (response.exceptionDetails) {
-        throw new Error(response.exceptionDetails.text || "Runtime.evaluate failed");
+  async clickThreadRow(rows, matched) {
+    const row = rows.nth(matched.index);
+    const clicked = await this.tryClick(row);
+    if (!clicked) {
+      const exactInRows = rows.filter({ hasText: matched.name }).first();
+      const exactCount = await exactInRows.count().catch(() => 0);
+      if (exactCount > 0 && await this.tryClick(exactInRows)) {
+        return;
       }
-      return response.result?.value;
-    } finally {
-      await session.detach().catch(() => void 0);
+      throw new Error(`Failed to select thread row: ${matched.name}`);
     }
   }
-};
-function normalizeText(value) {
-  return value.replace(/\s+/g, " ").replace(/\u200B/g, "").trim();
-}
-function normalizeUnreadCount(value) {
-  const parsed = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number.parseInt(value, 10) : 0;
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
-}
-function buildListThreadsExpr() {
-  return `(function() {
+  async tryClick(row) {
     try {
-      var runtime = globalThis;
-      var controller = runtime.ConversationController;
-      if (!controller) return { ok: false, reason: 'ConversationController unavailable' };
-      function normalize(value) {
-        return String(value || '').replace(/\\s+/g, ' ').trim();
-      }
-      function pickName(model) {
-        var fields = [
-          model && model.get ? model.get('name') : model && model.name,
-          model && model.get ? model.get('groupDisplayName') : model && model.groupDisplayName,
-          model && model.get ? model.get('title') : model && model.title,
-          model && model.get ? model.get('profileName') : model && model.profileName,
-          model && model.get ? model.get('e164') : model && model.e164,
-          model && model.get ? model.get('id') : model && model.id,
-        ];
-        for (var i = 0; i < fields.length; i++) {
-          var value = normalize(fields[i]);
-          if (value) return value;
-        }
-        return '';
-      }
-      function pickPreview(model) {
-        var attrs = typeof model.attributes === 'object' ? model.attributes : model || {};
-        var fields = [
-          attrs.draft,
-          attrs.lastMessage,
-          attrs.lastMessageText,
-          attrs.snippet,
-          attrs.body,
-        ];
-        for (var i = 0; i < fields.length; i++) {
-          var value = normalize(fields[i]);
-          if (value) return value;
-        }
-        return '';
-      }
-      function pickUnread(model) {
-        var attrs = typeof model.attributes === 'object' ? model.attributes : model || {};
-        var candidates = [
-          attrs.unreadCount,
-          attrs.unreadMessagesCount,
-          attrs.unread,
-          model && model.get ? model.get('unreadCount') : null,
-          model && model.get ? model.get('unreadMessagesCount') : null,
-          model && model.get ? model.get('unread') : null,
-        ];
-        for (var i = 0; i < candidates.length; i++) {
-          var value = Number(candidates[i] || 0);
-          if (Number.isFinite(value) && value > 0) return value;
-        }
-        return 0;
+      await row.scrollIntoViewIfNeeded({ timeout: 3e3 });
+      await row.click({ timeout: 5e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async extractLinks(row) {
+    const links = row.locator("a[href]");
+    const count = await links.count().catch(() => 0);
+    const out = [];
+    for (let i = 0; i < count; i += 1) {
+      const href = await links.nth(i).getAttribute("href").catch(() => null);
+      if (href && !out.includes(href)) {
+        out.push(href);
       }
-      function pickSentAt(model) {
-        var attrs = typeof model.attributes === 'object' ? model.attributes : model || {};
-        var candidates = [
-          attrs.active_at,
-          attrs.timestamp,
-          attrs.sent_at,
-          attrs.lastMessageReceivedAt,
-          model && model.get ? model.get('active_at') : null,
-          model && model.get ? model.get('timestamp') : null,
-          model && model.get ? model.get('sent_at') : null,
-        ];
-        for (var i = 0; i < candidates.length; i++) {
-          var value = Number(candidates[i] || 0);
-          if (Number.isFinite(value) && value > 0) return value;
+    }
+    return out;
+  }
+  async extractImages(row) {
+    const imgs = row.locator(
+      'img.module-image__image, img[alt="Image attached to message"]'
+    );
+    const count = await imgs.count().catch(() => 0);
+    const out = [];
+    for (let i = 0; i < count; i += 1) {
+      const src = await imgs.nth(i).getAttribute("src").catch(() => null);
+      if (src && !out.includes(src)) {
+        const displayable = await toDisplayableImagePath(src);
+        out.push(displayable);
+      }
+    }
+    return out;
+  }
+  async locateMessageContainer(page) {
+    const strong = page.locator(".messages");
+    const strongCount = await strong.count().catch(() => 0);
+    if (strongCount > 0) {
+      let bestIdx = 0;
+      let bestRows = -1;
+      for (let i = 0; i < strongCount; i += 1) {
+        const el = strong.nth(i);
+        const visible = await el.isVisible().catch(() => false);
+        if (!visible) {
+          continue;
+        }
+        const rows = await el.locator(":scope > *").count().catch(() => 0);
+        if (rows >= bestRows) {
+          bestRows = rows;
+          bestIdx = i;
         }
-        return null;
       }
-      var all = [];
-      if (typeof controller.getAllPrivateConversations === 'function') {
-        var privates = controller.getAllPrivateConversations();
-        all.push.apply(all, privates.models || privates || []);
-      }
-      if (typeof controller.getAllGroups === 'function') {
-        var groups = controller.getAllGroups();
-        all.push.apply(all, groups.models || groups || []);
-      }
-      var seen = {};
-      var threads = [];
-      for (var i = 0; i < all.length; i++) {
-        var model = all[i];
-        var conversationId = normalize(model && model.get ? model.get('id') : model && model.id);
-        if (!conversationId || seen[conversationId]) continue;
-        seen[conversationId] = true;
-        var name = pickName(model);
-        if (!name) continue;
-        threads.push({
-          conversationId: conversationId,
-          name: name,
-          unread: pickUnread(model),
-          preview: pickPreview(model),
-          sentAt: pickSentAt(model),
-        });
+      if (bestRows >= 0) {
+        return strong.nth(bestIdx);
       }
-      threads.sort(function(left, right) {
-        return (Number(right.sentAt || 0) - Number(left.sentAt || 0)) || left.name.localeCompare(right.name);
-      });
-      return { ok: true, threads: threads };
-    } catch(e) {
-      return { ok: false, reason: e && e.message ? e.message : String(e) };
     }
-  })()`;
-}
-function buildGetMessagesByConversationExpr(conversationId, limit) {
-  const escapedConversationId = escapeForJs(conversationId);
-  return `(async function() {
-    try {
-      var runtime = globalThis;
-      var controller = runtime.ConversationController;
-      var signal = (runtime.window && runtime.window.Signal) || runtime.Signal;
-      var whisper = runtime.Whisper;
-      if (!controller) return { ok: false, reason: 'ConversationController unavailable' };
-      if (!signal || !signal.Data || !signal.Data.getMessagesByConversation || !whisper || !whisper.MessageCollection) {
-        return { ok: false, reason: 'Signal data APIs are unavailable' };
-      }
-      function normalize(value) {
-        return String(value || '').replace(/\\s+/g, ' ').trim();
-      }
-      function resolveSenderName(source, model) {
-        if (!source) return null;
-        var contact = typeof controller.get === 'function' ? controller.get(source) : null;
-        var fields = [
-          contact && contact.get ? contact.get('name') : contact && contact.name,
-          contact && contact.get ? contact.get('profileName') : contact && contact.profileName,
-          contact && contact.get ? contact.get('title') : contact && contact.title,
-          source,
-        ];
-        for (var i = 0; i < fields.length; i++) {
-          var value = normalize(fields[i]);
-          if (value) return value;
-        }
-        return null;
+    const fallback = page.locator(".discussion-container, .conversation-stack, .main.panel, div");
+    const count = await fallback.count().catch(() => 0);
+    let best = null;
+    for (let i = 0; i < Math.min(count, 280); i += 1) {
+      const el = fallback.nth(i);
+      const visible = await el.isVisible().catch(() => false);
+      if (!visible) {
+        continue;
+      }
+      const children = await el.locator(":scope > *").count().catch(() => 0);
+      const texts = await el.locator("text=/./").count().catch(() => 0);
+      const score = texts + children;
+      if (!best || score > best.score) {
+        best = { idx: i, score };
       }
-      var conversation = typeof controller.get === 'function' ? controller.get('${escapedConversationId}') : null;
-      if (!conversation) return { ok: false, reason: 'Conversation not found: ${escapedConversationId}' };
-      var fetched = await signal.Data.getMessagesByConversation('${escapedConversationId}', {
-        limit: ${limit},
-        MessageCollection: whisper.MessageCollection,
-      });
-      var models = (fetched.models || fetched || []).slice();
-      models.sort(function(left, right) {
-        var leftSentAt = left && left.get ? (left.get('sent_at') || 0) : (left && left.sent_at) || 0;
-        var rightSentAt = right && right.get ? (right.get('sent_at') || 0) : (right && right.sent_at) || 0;
-        return leftSentAt - rightSentAt;
-      });
-      return {
-        ok: true,
-        conversationId: '${escapedConversationId}',
-        messages: models.map(function(model, index) {
-          var attrs = typeof model.attributes === 'object' ? model.attributes : model;
-          var source = (typeof model.getSource === 'function' ? model.getSource() : attrs.source) || null;
-          var quote = attrs.quote ? {
-            id: attrs.quote.id || null,
-            author: attrs.quote.author || null,
-            text: attrs.quote.text || null,
-          } : null;
-          var attachments = Array.isArray(attrs.attachments) ? attrs.attachments.map(function(attachment) {
-            return {
-              path: attachment && attachment.path || null,
-              contentType: attachment && attachment.contentType || null,
-              fileName: attachment && attachment.fileName || null,
-            };
-          }) : [];
-          return {
-            index: index,
-            body: attrs.body || '',
-            source: source,
-            senderName: resolveSenderName(source, model),
-            sentAt: attrs.sent_at || attrs.timestamp || null,
-            id: attrs.id || model.id || '',
-            attachments: attachments,
-            quote: quote,
-          };
-        }),
-      };
-    } catch(e) {
-      return { ok: false, reason: e && e.message ? e.message : String(e) };
     }
-  })()`;
+    if (!best) {
+      throw new Error("Cannot find conversation container.");
+    }
+    return fallback.nth(best.idx);
+  }
+  async collectLines(row, max = 12) {
+    const items = row.locator("text=/./");
+    const count = await items.count().catch(() => 0);
+    const lines = [];
+    for (let i = 0; i < Math.min(count, max); i += 1) {
+      const text = normalizeText(await items.nth(i).textContent().catch(() => "") || "");
+      if (text && !lines.includes(text)) {
+        lines.push(text);
+      }
+    }
+    return lines;
+  }
+  extractUnread(lines) {
+    let unread = 0;
+    for (const line of lines) {
+      if (!/^\d{1,4}\+?$/.test(line)) {
+        continue;
+      }
+      const value = Number.parseInt(line.replace("+", ""), 10);
+      if (Number.isFinite(value)) {
+        unread = Math.max(unread, value);
+      }
+    }
+    return unread;
+  }
+  findTime(lines) {
+    return lines.find(
+      (line) => /^\d{1,2}:\d{2}\s?(?:AM|PM)?$/i.test(line) || /^\d{1,2}\/\d{1,2}$/.test(line) || /^\d{4}\/\d{1,2}\/\d{1,2}$/.test(line)
+    ) ?? null;
+  }
+  findThreadName(lines, time) {
+    const candidates = [];
+    for (const line of lines) {
+      if (line === time) {
+        continue;
+      }
+      if (/^\d{1,4}\+?$/.test(line)) {
+        continue;
+      }
+      if (/^\[[^\]]+\]$/.test(line)) {
+        continue;
+      }
+      candidates.push(line);
+    }
+    const alphaNoColon = candidates.find(
+      (line) => /[A-Za-z\u4e00-\u9fff]/.test(line) && !line.includes(":")
+    );
+    if (alphaNoColon) {
+      return alphaNoColon;
+    }
+    const alphaPreferred = candidates.find((line) => /[A-Za-z\u4e00-\u9fff]/.test(line));
+    if (alphaPreferred) {
+      return alphaPreferred;
+    }
+    return candidates[0] ?? "";
+  }
+};
+function dedupeThreads(threads) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const thread of threads) {
+    const key = `${thread.name}::${thread.preview}::${thread.time ?? ""}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    result.push(thread);
+  }
+  return result;
 }
-function escapeForJs(value) {
-  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+function normalizeText(value) {
+  return value.replace(/\s+/g, " ").replace(/\u200B/g, "").trim();
 }
-function formatSentAt(sentAt) {
-  const value = typeof sentAt === "number" ? sentAt : typeof sentAt === "string" && /^\d+$/.test(sentAt) ? Number.parseInt(sentAt, 10) : NaN;
-  if (!Number.isFinite(value) || value <= 0) {
-    return null;
+function computeMessageHash(threadName, message) {
+  const base = [
+    normalizeText(threadName),
+    normalizeText(message.sender ?? ""),
+    normalizeText(message.time ?? ""),
+    normalizeText(message.content),
+    message.links.map(normalizeText).join("|"),
+    message.images.map(normalizeText).join("|")
+  ].join("||");
+  return (0, import_node_crypto4.createHash)("sha1").update(base).digest("hex").slice(0, 16);
+}
+function parseMessageText(rawText) {
+  const text = normalizeText(rawText);
+  if (!text) {
+    return { time: null, sender: null, content: "" };
+  }
+  const timeMatch = text.match(/^(\d{1,2}:\d{2}\s?(?:AM|PM)?)\s+(.*)$/i) ?? text.match(/^(\d{1,2}\/\d{1,2}|\d{4}\/\d{1,2}\/\d{1,2})\s+(.*)$/);
+  if (!timeMatch) {
+    return { time: null, sender: null, content: text };
+  }
+  const time = timeMatch[1];
+  const rest = normalizeText(timeMatch[2] ?? "");
+  if (!rest) {
+    return { time, sender: null, content: "" };
+  }
+  const senderMatch = rest.match(/^([^:]{1,80}):\s*(.*)$/);
+  if (!senderMatch) {
+    return { time, sender: null, content: rest };
   }
-  const date = new Date(value);
-  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())} ${pad2(date.getHours())}:${pad2(date.getMinutes())}`;
+  return {
+    time,
+    sender: normalizeText(senderMatch[1] ?? "") || null,
+    content: normalizeText(senderMatch[2] ?? "")
+  };
 }
-function finalizeIncrementalMessages(collectedNewestFirst, _reachedKnownMessage) {
-  return [...collectedNewestFirst].reverse();
+async function toDisplayableImagePath(src) {
+  if (!import_node_path17.default.isAbsolute(src)) {
+    return src;
+  }
+  const ext = import_node_path17.default.extname(src);
+  if (ext) {
+    return src;
+  }
+  try {
+    const stat = await import_node_fs12.promises.stat(src);
+    if (!stat.isFile()) {
+      return src;
+    }
+    const fh = await import_node_fs12.promises.open(src, "r");
+    try {
+      const buf = Buffer.alloc(32);
+      const { bytesRead } = await fh.read(buf, 0, 32, 0);
+      const header = buf.subarray(0, bytesRead);
+      const guessedExt = guessImageExtension(header);
+      if (!guessedExt) {
+        return src;
+      }
+      const cacheDir = import_node_path17.default.join(
+        import_node_os7.default.homedir(),
+        ".pmate",
+        "messages",
+        "images"
+      );
+      await import_node_fs12.promises.mkdir(cacheDir, { recursive: true });
+      const base = (0, import_node_crypto4.createHash)("sha1").update(src).digest("hex");
+      const displayPath = import_node_path17.default.join(cacheDir, `${base}.${guessedExt}`);
+      await import_node_fs12.promises.rm(displayPath, { force: true }).catch(() => void 0);
+      await import_node_fs12.promises.copyFile(src, displayPath);
+      return displayPath;
+    } finally {
+      await fh.close();
+    }
+  } catch {
+    return src;
+  }
 }
-function pad2(value) {
-  return String(value).padStart(2, "0");
+function guessImageExtension(header) {
+  if (header.length >= 3 && header[0] === 255 && header[1] === 216 && header[2] === 255) {
+    return "jpg";
+  }
+  if (header.length >= 8 && header[0] === 137 && header[1] === 80 && header[2] === 78 && header[3] === 71) {
+    return "png";
+  }
+  if (header.length >= 4 && header[0] === 71 && header[1] === 73 && header[2] === 70 && header[3] === 56) {
+    return "gif";
+  }
+  if (header.length >= 12 && header.subarray(0, 4).toString("ascii") === "RIFF" && header.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "webp";
+  }
+  return null;
 }
 
 // src/commands/AgentCommandHandler.ts
-var import_node_fs12 = require("fs");
-var import_node_path17 = __toESM(require("path"));
+var import_node_fs13 = require("fs");
+var import_node_path18 = __toESM(require("path"));
 init_AgentLlmClient();
 init_sessionStore();
 
@@ -16238,7 +16198,7 @@ init_sessionStore();
 var STORE_LOG_VERSION = 1;
 var LOG_KIND_TABLE = 1e4;
 var LOG_KIND_MAPPING = 6003;
-function createHash3() {
+function createHash4() {
   return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
 function createDescriptor(input) {
@@ -16263,8 +16223,8 @@ function descriptorPathSegments(descriptor) {
   return ["chains", normalized.chain, "namespaces", normalized.ns, normalized.kind, normalized.name];
 }
 function buildPathUrl(baseUrl, pathSegments, query) {
-  const path27 = `/${pathSegments.map((segment) => encodeURIComponent(segment)).join("/")}`;
-  const url = new URL(path27, baseUrl);
+  const path28 = `/${pathSegments.map((segment) => encodeURIComponent(segment)).join("/")}`;
+  const url = new URL(path28, baseUrl);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       url.searchParams.set(key, String(value));
@@ -16377,7 +16337,7 @@ var Namespace = class {
       },
       appendRow: async (data) => {
         const log = {
-          hash: createHash3(),
+          hash: createHash4(),
           t: Date.now(),
           kind: LOG_KIND_TABLE,
           topic: descriptorToTopic(descriptor),
@@ -16389,7 +16349,7 @@ var Namespace = class {
       updateRow: async (data) => {
         const { id, ...value } = data;
         const log = {
-          hash: createHash3(),
+          hash: createHash4(),
           t: Date.now(),
           kind: LOG_KIND_TABLE,
           topic: descriptorToTopic(descriptor),
@@ -16400,7 +16360,7 @@ var Namespace = class {
       },
       deleteRow: async (id) => {
         const log = {
-          hash: createHash3(),
+          hash: createHash4(),
           t: Date.now(),
           kind: LOG_KIND_TABLE,
           topic: descriptorToTopic(descriptor),
@@ -16443,7 +16403,7 @@ var Namespace = class {
       },
       set: async (key, value) => {
         const log = {
-          hash: createHash3(),
+          hash: createHash4(),
           t: Date.now(),
           kind: LOG_KIND_MAPPING,
           topic: descriptorToTopic(descriptor),
@@ -16454,7 +16414,7 @@ var Namespace = class {
       },
       delete: async (key) => {
         const log = {
-          hash: createHash3(),
+          hash: createHash4(),
           t: Date.now(),
           kind: LOG_KIND_MAPPING,
           topic: descriptorToTopic(descriptor),
@@ -16696,11 +16656,11 @@ var AgentCommandHandler = class {
     }).token;
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path17.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs12.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs13.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs12.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs13.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -16711,7 +16671,7 @@ var AgentCommandHandler = class {
   readJsonObjectFile(filePath) {
     const parsed = this.readJsonFile(filePath);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      const absolutePath = import_node_path17.default.resolve(process.cwd(), filePath);
+      const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
       throw new Error(`Invalid JSON in ${absolutePath}: expected an object`);
     }
     return parsed;
@@ -16795,8 +16755,8 @@ var AgentCommandHandler = class {
 };
 
 // src/commands/RunnerCommandHandler.ts
-var import_node_fs13 = require("fs");
-var import_node_path18 = __toESM(require("path"));
+var import_node_fs14 = require("fs");
+var import_node_path19 = __toESM(require("path"));
 init_sessionStore();
 init_namespacedRef();
 var RunnerCommandHandler = class {
@@ -16891,11 +16851,11 @@ var RunnerCommandHandler = class {
     }).token;
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs13.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path19.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs14.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs13.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -17014,8 +16974,8 @@ var NsCommandHandler = class {
 };
 
 // src/commands/StoreCommandHandler.ts
-var import_node_fs14 = require("fs");
-var import_node_path19 = __toESM(require("path"));
+var import_node_fs15 = require("fs");
+var import_node_path20 = __toESM(require("path"));
 var StoreCommandHandler = class {
   async handle(args) {
     if (args.scope === "namespace") {
@@ -17157,11 +17117,11 @@ var StoreCommandHandler = class {
     return payload.data ?? [];
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path19.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs14.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path20.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs15.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs15.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -17213,13 +17173,13 @@ var StoreCommandHandler = class {
 };
 
 // src/commands/AppCommandHandler.ts
-var import_node_fs16 = require("fs");
-var import_node_path21 = __toESM(require("path"));
+var import_node_fs17 = require("fs");
+var import_node_path22 = __toESM(require("path"));
 init_sessionStore();
 
 // src/appIcon.ts
-var import_node_fs15 = require("fs");
-var import_node_path20 = __toESM(require("path"));
+var import_node_fs16 = require("fs");
+var import_node_path21 = __toESM(require("path"));
 var import_sharp = __toESM(require("sharp"));
 init_namespacedRef();
 var ANDROID_ICON_SPECS = [
@@ -17240,33 +17200,19 @@ var IOS_ICON_SPECS = [
 var pngToIco = require("png-to-ico").default;
 function normalizeAppIcon(icon, cwd) {
   if (typeof icon !== "string" || !icon.trim()) {
-    throw new Error("App icon must be a non-empty SVG string or .svg file path.");
+    throw new Error("App icon must be a non-empty http(s) URL.");
   }
   const trimmed = icon.trim();
   if (looksLikeSvgMarkup(trimmed)) {
-    return trimmed;
+    throw new Error("App icon cannot be inline SVG. Upload the SVG to OSS first and use its http(s) URL.");
   }
   if (trimmed.startsWith("data:")) {
-    return normalizeSvgDataUrl(trimmed);
+    throw new Error("App icon cannot be a data URL. Upload the SVG to OSS first and use its http(s) URL.");
   }
   if (/^https?:\/\//i.test(trimmed)) {
-    throw new Error("App icon must be SVG source, not a remote URL.");
-  }
-  const absolutePath = import_node_path20.default.resolve(cwd, trimmed);
-  if (!(0, import_node_fs15.existsSync)(absolutePath)) {
-    if (trimmed.toLowerCase().endsWith(".svg")) {
-      throw new Error(`App icon SVG file not found: ${absolutePath}`);
-    }
-    throw new Error("App icon must be inline SVG, an SVG data URL, or a .svg file path.");
-  }
-  if (import_node_path20.default.extname(absolutePath).toLowerCase() !== ".svg") {
-    throw new Error(`App icon file must use the .svg extension: ${absolutePath}`);
-  }
-  const svg = (0, import_node_fs15.readFileSync)(absolutePath, "utf8").trim();
-  if (!looksLikeSvgMarkup(svg)) {
-    throw new Error(`App icon file is not valid SVG: ${absolutePath}`);
+    return trimmed;
   }
-  return svg;
+  throw new Error("App icon must be an http(s) URL. Upload SVG files to OSS first and use the public link.");
 }
 function prepareAppPayload(payload, cwd) {
   if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
@@ -17287,13 +17233,13 @@ function createAppIconExportPlans(input) {
     if (!input.outDir) {
       throw new Error("App icon preset export requires --out-dir.");
     }
-    const outDir = import_node_path20.default.resolve(input.cwd, input.outDir);
-    (0, import_node_fs15.mkdirSync)(outDir, { recursive: true });
+    const outDir = import_node_path21.default.resolve(input.cwd, input.outDir);
+    (0, import_node_fs16.mkdirSync)(outDir, { recursive: true });
     return specs.map((spec) => ({
       width: spec.width,
       height: spec.height,
       format: "png",
-      outputPath: import_node_path20.default.join(
+      outputPath: import_node_path21.default.join(
         outDir,
         `${namespace}-${objectId}-${spec.name}-${spec.width}x${spec.height}.png`
       )
@@ -17306,8 +17252,8 @@ function createAppIconExportPlans(input) {
   if (!input.output) {
     throw new Error("Single-size app icon export requires --output.");
   }
-  const resolvedOutput = import_node_path20.default.resolve(input.cwd, input.output);
-  (0, import_node_fs15.mkdirSync)(import_node_path20.default.dirname(resolvedOutput), { recursive: true });
+  const resolvedOutput = import_node_path21.default.resolve(input.cwd, input.output);
+  (0, import_node_fs16.mkdirSync)(import_node_path21.default.dirname(resolvedOutput), { recursive: true });
   return [
     {
       width: input.width,
@@ -17317,11 +17263,34 @@ function createAppIconExportPlans(input) {
     }
   ];
 }
-async function exportAppIcon(svg, plans) {
+async function exportAppIcon(icon, plans) {
+  const svg = await resolveAppIconSvg(icon);
   for (const plan of plans) {
     const bytes = await renderAppIcon(svg, plan.width, plan.height, plan.format);
-    (0, import_node_fs15.writeFileSync)(plan.outputPath, bytes);
+    (0, import_node_fs16.writeFileSync)(plan.outputPath, bytes);
+  }
+}
+async function resolveAppIconSvg(icon) {
+  const trimmed = icon.trim();
+  if (looksLikeSvgMarkup(trimmed)) {
+    return trimmed;
+  }
+  if (!/^https?:\/\//i.test(trimmed)) {
+    throw new Error("App icon export requires inline SVG or an http(s) SVG URL.");
+  }
+  const response = await fetch(trimmed);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch app icon SVG: ${response.status} ${response.statusText}`.trim());
+  }
+  const contentType = response.headers.get("content-type")?.toLowerCase() || "";
+  const svg = (await response.text()).trim();
+  if (contentType && !contentType.includes("image/svg+xml") && !looksLikeSvgMarkup(svg)) {
+    throw new Error(`App icon URL must return SVG content. Received: ${contentType}`);
   }
+  if (!looksLikeSvgMarkup(svg)) {
+    throw new Error("App icon URL does not contain valid SVG markup.");
+  }
+  return svg;
 }
 async function renderAppIcon(svg, width, height, format) {
   if (format === "svg") {
@@ -17343,23 +17312,6 @@ async function renderAppIcon(svg, width, height, format) {
 function looksLikeSvgMarkup(value) {
   return /<svg[\s>]/i.test(value);
 }
-function normalizeSvgDataUrl(value) {
-  const match = /^data:([^;,]+)?(?:;charset=[^;,]+)?(?:;(base64))?,(.*)$/i.exec(value);
-  if (!match) {
-    throw new Error("Invalid app icon data URL.");
-  }
-  const mimeType = (match[1] || "").toLowerCase();
-  if (mimeType !== "image/svg+xml") {
-    throw new Error(`App icon data URL must be image/svg+xml. Received: ${mimeType || "unknown"}`);
-  }
-  const payload = match[3] || "";
-  const decoded = match[2] ? Buffer.from(payload, "base64").toString("utf8") : decodeURIComponent(payload);
-  const svg = decoded.trim();
-  if (!looksLikeSvgMarkup(svg)) {
-    throw new Error("App icon data URL does not contain valid SVG markup.");
-  }
-  return svg;
-}
 
 // src/commands/AppCommandHandler.ts
 init_namespacedRef();
@@ -17375,7 +17327,12 @@ var AppCommandHandler = class {
           "GET",
           "/apps"
         );
-        const items = args.namespace ? response.items.filter((item) => item.namespace === args.namespace) : response.items;
+        const items = response.items.filter((item) => {
+          if (!args.all && item.status !== "active") {
+            return false;
+          }
+          return args.namespace ? item.namespace === args.namespace : true;
+        });
         this.renderList(items, args.json);
         return;
       }
@@ -17511,10 +17468,10 @@ var AppCommandHandler = class {
   }
   readJsonFile(filePath) {
     const absolutePath = this.resolveFilePath(filePath);
-    if (!(0, import_node_fs16.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs17.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs16.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs17.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -17524,10 +17481,10 @@ var AppCommandHandler = class {
   }
   preparePayload(filePath) {
     const absolutePath = this.resolveFilePath(filePath);
-    return prepareAppPayload(this.readJsonFile(filePath), import_node_path21.default.dirname(absolutePath));
+    return prepareAppPayload(this.readJsonFile(filePath), import_node_path22.default.dirname(absolutePath));
   }
   resolveFilePath(filePath) {
-    return import_node_path21.default.resolve(process.cwd(), filePath);
+    return import_node_path22.default.resolve(process.cwd(), filePath);
   }
   async request(baseUrl, token, method, pathname, body) {
     const response = await fetch(`${baseUrl}${pathname}`, {
@@ -17601,15 +17558,15 @@ function readNamespaceFromPayload(payload) {
 }
 
 // src/commands/ServiceCommandHandler.ts
-var import_node_fs18 = require("fs");
+var import_node_fs19 = require("fs");
 var import_promises5 = require("fs/promises");
-var import_node_path23 = __toESM(require("path"));
+var import_node_path24 = __toESM(require("path"));
 var import_promises6 = require("readline/promises");
 
 // src/services/ServiceRuntimeRunner.ts
-var import_node_fs17 = require("fs");
-var import_node_os7 = __toESM(require("os"));
-var import_node_path22 = __toESM(require("path"));
+var import_node_fs18 = require("fs");
+var import_node_os8 = __toESM(require("os"));
+var import_node_path23 = __toESM(require("path"));
 var import_node_child_process10 = require("child_process");
 var import_node_readline = require("readline");
 var import_chalk3 = __toESM(require("chalk"));
@@ -17774,14 +17731,14 @@ var ServiceRuntimeRunner = class {
   }
   resolveRepoRoot(service, cwd) {
     if (cwd) {
-      return import_node_path22.default.resolve(process.cwd(), cwd);
+      return import_node_path23.default.resolve(process.cwd(), cwd);
     }
     const repository = this.getType(service) === "vite" || this.getType(service) === "static" ? this.getSite(service).repository?.trim() : this.getType(service) === "ios" || this.getType(service) === "android" ? void 0 : this.getNetwork(service).repository?.trim();
     if (repository) {
       const repoName = repository.replace(/\/+$/, "").split("/").pop()?.replace(/\.git$/i, "");
       if (repoName) {
-        const candidate = import_node_path22.default.join(import_node_os7.default.homedir(), "dev", "pmate", repoName);
-        if ((0, import_node_fs17.existsSync)(candidate)) {
+        const candidate = import_node_path23.default.join(import_node_os8.default.homedir(), "dev", "pmate", repoName);
+        if ((0, import_node_fs18.existsSync)(candidate)) {
           return candidate;
         }
       }
@@ -17794,12 +17751,12 @@ var ServiceRuntimeRunner = class {
     if (!dir) {
       throw new Error(`Missing service dir for ${service.id}`);
     }
-    return import_node_path22.default.resolve(repoRoot, dir);
+    return import_node_path23.default.resolve(repoRoot, dir);
   }
   async deployVite(service, options) {
     const appDir = this.resolveLocalDir(service, options.cwd);
-    const packageJsonPath = import_node_path22.default.join(appDir, "package.json");
-    if (!(0, import_node_fs17.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path23.default.join(appDir, "package.json");
+    if (!(0, import_node_fs18.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -17808,8 +17765,8 @@ var ServiceRuntimeRunner = class {
       throw new Error(`Missing package name in ${packageJsonPath}`);
     }
     await this.runCommand("pnpm", ["--filter", pkgName, "build"], this.resolveRepoRoot(service, options.cwd));
-    const distDir = import_node_path22.default.join(appDir, "dist");
-    if (!(0, import_node_fs17.existsSync)(distDir)) {
+    const distDir = import_node_path23.default.join(appDir, "dist");
+    if (!(0, import_node_fs18.existsSync)(distDir)) {
       throw new Error(`No dist directory found at ${distDir}`);
     }
     const site = this.getSite(service);
@@ -17821,8 +17778,8 @@ var ServiceRuntimeRunner = class {
   }
   async deployStatic(service, options) {
     const appDir = this.resolveLocalDir(service, options.cwd);
-    const srcDir = import_node_path22.default.join(appDir, "src");
-    if (!(0, import_node_fs17.existsSync)(srcDir)) {
+    const srcDir = import_node_path23.default.join(appDir, "src");
+    if (!(0, import_node_fs18.existsSync)(srcDir)) {
       throw new Error(`No src directory found at ${srcDir}`);
     }
     const site = this.getSite(service);
@@ -17942,7 +17899,7 @@ var ServiceRuntimeRunner = class {
       const serverAddress = await resolveServerAddress(server);
       const templateName = exposeType === "websocket" ? "nginx.ws.template" : "nginx.rest.template";
       const templatePath = this.resolveTemplatePath(templateName);
-      const template = (0, import_node_fs17.readFileSync)(templatePath, "utf8");
+      const template = (0, import_node_fs18.readFileSync)(templatePath, "utf8");
       const host = `${subdomain}.${("domain" in network ? network.domain?.trim() : void 0) || "pmate.chat"}`;
       const rendered = template.replace(/\$\{\{PORT\}\}/g, String(port)).replace(/\$\{\{HOSTS\}\}/g, host).replace(/\$\{\{HOST\}\}/g, host);
       const remotePath = `/etc/nginx/sites-enabled/${subdomain}.conf`;
@@ -17974,11 +17931,11 @@ var ServiceRuntimeRunner = class {
     }
     if (config.ensurePackageJson) {
       const appDir = this.resolveLocalDir(service, options.cwd);
-      const packageJsonPath = import_node_path22.default.join(appDir, "package.json");
-      if (!(0, import_node_fs17.existsSync)(packageJsonPath)) {
+      const packageJsonPath = import_node_path23.default.join(appDir, "package.json");
+      if (!(0, import_node_fs18.existsSync)(packageJsonPath)) {
         throw new Error(`Missing package.json at ${packageJsonPath}`);
       }
-      const pkgStat = (0, import_node_fs17.statSync)(packageJsonPath);
+      const pkgStat = (0, import_node_fs18.statSync)(packageJsonPath);
       if (!pkgStat.isFile()) {
         throw new Error(`package.json is not a file at ${packageJsonPath}`);
       }
@@ -18402,9 +18359,9 @@ var ServiceRuntimeRunner = class {
     return tokens;
   }
   readPathValue(source, pathExpr) {
-    const path27 = pathExpr.split(".").map((segment) => segment.trim()).filter(Boolean);
+    const path28 = pathExpr.split(".").map((segment) => segment.trim()).filter(Boolean);
     let cursor = source;
-    for (const segment of path27) {
+    for (const segment of path28) {
       if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) {
         return void 0;
       }
@@ -18447,12 +18404,12 @@ var ServiceRuntimeRunner = class {
   }
   resolveTemplatePath(templateName) {
     const candidates = [
-      import_node_path22.default.join(__dirname, "..", "templates", templateName),
-      import_node_path22.default.join(__dirname, "..", "src", "templates", templateName),
-      import_node_path22.default.join(__dirname, "templates", templateName)
+      import_node_path23.default.join(__dirname, "..", "templates", templateName),
+      import_node_path23.default.join(__dirname, "..", "src", "templates", templateName),
+      import_node_path23.default.join(__dirname, "templates", templateName)
     ];
     for (const candidate of candidates) {
-      if ((0, import_node_fs17.existsSync)(candidate)) {
+      if ((0, import_node_fs18.existsSync)(candidate)) {
         return candidate;
       }
     }
@@ -18484,7 +18441,7 @@ var ServiceRuntimeRunner = class {
     });
   }
   loadPackageJson(packageJsonPath) {
-    const raw = (0, import_node_fs17.readFileSync)(packageJsonPath, "utf8");
+    const raw = (0, import_node_fs18.readFileSync)(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") {
       throw new Error(`Invalid package.json at ${packageJsonPath}`);
@@ -18493,7 +18450,7 @@ var ServiceRuntimeRunner = class {
   }
   writePackageJson(packageJsonPath, data) {
     const serialized = JSON.stringify(data, null, 2);
-    (0, import_node_fs17.writeFileSync)(packageJsonPath, `${serialized}
+    (0, import_node_fs18.writeFileSync)(packageJsonPath, `${serialized}
 `, "utf8");
   }
   runCommand(command, args, cwd) {
@@ -18830,7 +18787,7 @@ var ServiceCommandHandler = class {
             format: "dotenv"
           }
         );
-        const outputPath = import_node_path23.default.resolve(process.cwd(), args.output);
+        const outputPath = import_node_path24.default.resolve(process.cwd(), args.output);
         await (0, import_promises5.writeFile)(outputPath, payload.content, "utf8");
         ui.success(`Wrote env file for ${args.appId} to ${outputPath}`);
         this.renderJson({ ...payload, output: outputPath }, args.json);
@@ -18859,11 +18816,11 @@ var ServiceCommandHandler = class {
     return (baseUrl || process.env.PMATE_APPS_API_BASE_URL || "https://apps-api.pmate.chat").replace(/\/+$/, "");
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path23.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs18.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path24.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs19.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs18.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs19.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -19203,8 +19160,8 @@ var RoleCommandHandler = class {
 };
 
 // src/commands/AccountCommandHandler.ts
-var import_node_fs19 = require("fs");
-var import_node_path24 = __toESM(require("path"));
+var import_node_fs20 = require("fs");
+var import_node_path25 = __toESM(require("path"));
 init_sessionStore();
 var AccountCommandHandler = class {
   async handle(args) {
@@ -19452,10 +19409,10 @@ var AccountCommandHandler = class {
       throw new Error("Missing visible apps input");
     }
     const absolutePath = this.resolveFilePath(args.filePath);
-    if (!(0, import_node_fs19.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs20.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs19.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs20.readFileSync)(absolutePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -19469,7 +19426,7 @@ var AccountCommandHandler = class {
     return parsed;
   }
   resolveFilePath(filePath) {
-    return import_node_path24.default.resolve(process.cwd(), filePath);
+    return import_node_path25.default.resolve(process.cwd(), filePath);
   }
 };
 function encodePathSegment(value) {
@@ -19477,8 +19434,8 @@ function encodePathSegment(value) {
 }
 
 // src/commands/OrgCommandHandler.ts
-var import_node_fs20 = require("fs");
-var import_node_path25 = __toESM(require("path"));
+var import_node_fs21 = require("fs");
+var import_node_path26 = __toESM(require("path"));
 init_sessionStore();
 var OrgCommandHandler = class {
   async handle(args) {
@@ -19649,11 +19606,11 @@ var OrgCommandHandler = class {
     if (!filePath) {
       throw new Error(`Missing ${itemLabel} input`);
     }
-    const absolutePath = import_node_path25.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs20.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path26.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs21.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs20.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs21.readFileSync)(absolutePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -20552,6 +20509,7 @@ function parseAppArgs(tokens) {
   };
   if (action === "list") {
     let namespace;
+    let all = false;
     while (rest.length > 0) {
       const token = rest.shift();
       switch (token) {
@@ -20559,6 +20517,9 @@ function parseAppArgs(tokens) {
         case "--namespace":
           namespace = requireValue5(rest, token);
           break;
+        case "--all":
+          all = true;
+          break;
         case "--base-url":
           baseUrl = requireValue5(rest, token);
           break;
@@ -20569,7 +20530,7 @@ function parseAppArgs(tokens) {
           throw new Error(`Unknown app list option: ${token}`);
       }
     }
-    return { type: "app" /* App */, action, namespace, baseUrl, json };
+    return { type: "app" /* App */, action, namespace, all, baseUrl, json };
   }
   if (action === "view") {
     const rawRef = rest.shift();
@@ -22138,7 +22099,7 @@ function requireValue11(tokens, option) {
 
 // src/index.ts
 var pkg = JSON.parse(
-  (0, import_node_fs21.readFileSync)(import_node_path26.default.resolve(__dirname, "..", "package.json"), "utf8")
+  (0, import_node_fs22.readFileSync)(import_node_path27.default.resolve(__dirname, "..", "package.json"), "utf8")
 );
 var HELP_TEXT = [
   import_chalk4.default.bold(`pmate v${pkg.version}`),
@@ -22281,7 +22242,7 @@ var HELP_TEXT = [
   `  ${import_chalk4.default.gray("                  kv list|get|exists|set|delete <name> [options]")}`,
   `  ${import_chalk4.default.gray("                  defaults: chain=pmate namespace=pmate env base URLs from BLOCKCHAIN_BASE_URL / INDEXER_BASE_URL")}`,
   `  ${import_chalk4.default.cyan("app")}              Manage app registry entries via apps-api`,
-  `  ${import_chalk4.default.gray("                  list [--ns <namespace>] [--base-url <url>] [--json]")}`,
+  `  ${import_chalk4.default.gray("                  list [--ns <namespace>] [--all] [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  get <ns:objectId> [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  view <ns:objectId> [--base-url <url>]")}`,
   `  ${import_chalk4.default.gray("                  create --file <path> [--base-url <url>] [--json]")}`,