@zenalexa/unicli 0.218.1 → 0.220.0

package/src/adapters/chatgpt/web.ts

@@ -0,0 +1,286 @@
+/**
+ * @owner   src/adapters/chatgpt/web.ts
+ * @does    Register agent-facing ChatGPT web history and detail readers implemented with site-specific safety checks.
+ * @needs   Logged-in chatgpt.com browser session, visible sidebar links, rendered conversation messages.
+ * @feeds   surface coverage ledger, ChatGPT conversation discovery, and browser-session read workflows.
+ * @breaks  ChatGPT DOM selector drift or login gates can hide history/messages.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { intArg, js, str } from "../_shared/browser-tools.js";
+
+const CHATGPT_HOME = "https://chatgpt.com";
+const CONVERSATION_LINK_SELECTOR = 'a[href*="/c/"]';
+const CONVERSATION_MESSAGE_SELECTOR =
+  '[data-message-author-role], article[data-testid*="conversation-turn"]';
+
+interface RawChatGptConversation {
+  Id?: unknown;
+  Title?: unknown;
+  Url?: unknown;
+}
+
+interface RawChatGptMessage {
+  role?: unknown;
+  text?: unknown;
+  html?: unknown;
+}
+
+interface ChatGptBrowserPage {
+  goto: (url: string, opts?: Record<string, unknown>) => Promise<unknown>;
+  wait: (args: unknown) => Promise<unknown>;
+  evaluate: (script: string) => Promise<unknown>;
+}
+
+export function parseChatGptConversationId(value: unknown): string {
+  const raw = str(value).trim();
+  const match = raw.match(/(?:^|\/c\/)([A-Za-z0-9_-]{8,})(?:[/?#]|$)/);
+  if (match?.[1]) return match[1];
+  if (/^[A-Za-z0-9_-]{8,}$/.test(raw)) return raw;
+  throw new Error("chatgpt detail requires a conversation id or /c/<id> URL.");
+}
+
+export function normalizeChatGptBoolean(
+  value: unknown,
+  fallback = false,
+): boolean {
+  if (typeof value === "boolean") return value;
+  if (value === undefined || value === null || value === "") return fallback;
+  return /^(true|1|yes|on)$/i.test(str(value).trim());
+}
+
+export function chatGptHtmlToMarkdown(value: unknown): string {
+  return str(value)
+    .replace(/<br\s*\/?>/gi, "\n")
+    .replace(/<\/(p|div|li|h[1-6]|pre)>/gi, "\n")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/&nbsp;/g, " ")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&amp;/g, "&")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .replace(/[ \t]{2,}/g, " ")
+    .trim();
+}
+
+export function mapChatGptConversations(
+  items: RawChatGptConversation[],
+): Record<string, unknown>[] {
+  return items
+    .map((item, index) => ({
+      Index: index + 1,
+      Id: str(item.Id),
+      Title: str(item.Title, "(untitled)").trim() || "(untitled)",
+      Url: str(item.Url),
+    }))
+    .filter((item) => item.Id);
+}
+
+export function mapChatGptMessages(
+  items: RawChatGptMessage[],
+  wantMarkdown: boolean,
+): Record<string, unknown>[] {
+  return items
+    .map((item, index) => {
+      const role = /assistant/i.test(str(item.role)) ? "Assistant" : "User";
+      const text =
+        wantMarkdown && role === "Assistant" && str(item.html).trim()
+          ? chatGptHtmlToMarkdown(item.html)
+          : str(item.text).trim();
+      return {
+        Index: index + 1,
+        Role: role,
+        Text: text,
+      };
+    })
+    .filter((item) => item.Text);
+}
+
+async function openChatGpt(page: ChatGptBrowserPage): Promise<void> {
+  await page.goto(CHATGPT_HOME, { settleMs: 2000 });
+}
+
+async function readConversationLinks(
+  page: ChatGptBrowserPage,
+): Promise<RawChatGptConversation[]> {
+  const rows = await page.evaluate(`(() => {
+    const isVisible = (el) => {
+      if (!(el instanceof HTMLElement)) return false;
+      const style = window.getComputedStyle(el);
+      if (style.display === 'none' || style.visibility === 'hidden') return false;
+      const rect = el.getBoundingClientRect();
+      return rect.width > 0 && rect.height > 0;
+    };
+    const links = Array.from(document.querySelectorAll(${js(CONVERSATION_LINK_SELECTOR)}))
+      .filter((link) => link instanceof HTMLAnchorElement && isVisible(link));
+    const seen = new Set();
+    const items = [];
+    for (const link of links) {
+      const href = link.getAttribute('href') || '';
+      const match = href.match(/\\/c\\/([^/?#]+)/);
+      if (!match || seen.has(match[1])) continue;
+      seen.add(match[1]);
+      items.push({
+        Id: match[1],
+        Title: (link.innerText || link.textContent || '').replace(/\\s+/g, ' ').trim() || '(untitled)',
+        Url: href.startsWith('http') ? href : (${js(CHATGPT_HOME)} + href),
+      });
+    }
+    return items;
+  })()`);
+  return Array.isArray(rows) ? (rows as RawChatGptConversation[]) : [];
+}
+
+async function openSidebar(page: ChatGptBrowserPage): Promise<void> {
+  const opened = await page.evaluate(`(() => {
+    const button = Array.from(document.querySelectorAll('button'))
+      .find((node) => /open sidebar|打开边栏|打开侧边栏/i.test(node.getAttribute('aria-label') || ''));
+    if (button instanceof HTMLElement) {
+      button.click();
+      return true;
+    }
+    return false;
+  })()`);
+  if (opened) {
+    try {
+      await page.wait({ selector: CONVERSATION_LINK_SELECTOR, timeout: 3 });
+    } catch {
+      return;
+    }
+  }
+}
+
+async function getConversationHistory(
+  page: ChatGptBrowserPage,
+  limit: number,
+): Promise<Record<string, unknown>[]> {
+  await openChatGpt(page);
+  await openSidebar(page);
+  let rows = mapChatGptConversations(await readConversationLinks(page));
+  if (!rows.length) {
+    await page.goto(CHATGPT_HOME, { settleMs: 2000 });
+    try {
+      await page.wait({ selector: CONVERSATION_LINK_SELECTOR, timeout: 8 });
+    } catch {
+      rows = [];
+    }
+    rows = mapChatGptConversations(await readConversationLinks(page));
+  }
+  if (!rows.length) {
+    throw new Error(
+      "No ChatGPT conversation links were visible in the sidebar.",
+    );
+  }
+  return rows.slice(0, limit);
+}
+
+async function readVisibleMessages(
+  page: ChatGptBrowserPage,
+  wantMarkdown: boolean,
+): Promise<Record<string, unknown>[]> {
+  const rows = await page.evaluate(`(() => {
+    const isVisible = (el) => {
+      if (!(el instanceof HTMLElement)) return false;
+      const style = window.getComputedStyle(el);
+      if (style.display === 'none' || style.visibility === 'hidden') return false;
+      const rect = el.getBoundingClientRect();
+      return rect.width > 0 && rect.height > 0;
+    };
+    const normalize = (value) => String(value || '').replace(/\\u00a0/g, ' ').replace(/[ \\t]+\\n/g, '\\n').replace(/\\n{3,}/g, '\\n\\n').trim();
+    const roleOf = (node) => {
+      const attr = node.getAttribute('data-message-author-role') || node.getAttribute('data-author') || '';
+      if (/assistant/i.test(attr)) return 'Assistant';
+      if (/user/i.test(attr)) return 'User';
+      const testid = node.getAttribute('data-testid') || '';
+      if (/assistant/i.test(testid)) return 'Assistant';
+      if (/user/i.test(testid)) return 'User';
+      const label = node.getAttribute('aria-label') || '';
+      if (/assistant|chatgpt/i.test(label)) return 'Assistant';
+      if (/you|user/i.test(label)) return 'User';
+      return '';
+    };
+    const nodes = Array.from(document.querySelectorAll(${js(CONVERSATION_MESSAGE_SELECTOR)}))
+      .filter((node) => node instanceof HTMLElement && isVisible(node));
+    const seen = new Set();
+    const items = [];
+    for (const node of nodes) {
+      let role = roleOf(node);
+      const roleNode = node.querySelector('[data-message-author-role], [data-author]');
+      if (!role && roleNode) role = roleOf(roleNode);
+      if (!role) continue;
+      const contentNode = node.querySelector('[data-message-author-role] .markdown')
+        || node.querySelector('.markdown')
+        || node.querySelector('[data-message-author-role]')
+        || node;
+      const html = contentNode instanceof HTMLElement ? (contentNode.innerHTML || '') : '';
+      const text = normalize(contentNode instanceof HTMLElement ? (contentNode.innerText || contentNode.textContent || '') : '');
+      if (!text) continue;
+      const key = role + '\\n' + text;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      items.push({ role, text, html });
+    }
+    return items;
+  })()`);
+  const messages = Array.isArray(rows) ? (rows as RawChatGptMessage[]) : [];
+  const mapped = mapChatGptMessages(messages, wantMarkdown);
+  if (!mapped.length) {
+    throw new Error("No visible ChatGPT messages were found.");
+  }
+  return mapped;
+}
+
+cli({
+  site: "chatgpt",
+  name: "history",
+  description: "List visible ChatGPT web conversation history from the sidebar",
+  domain: "chatgpt.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [{ name: "limit", type: "int", default: 20 }],
+  columns: ["Index", "Id", "Title", "Url"],
+  func: async (page, kwargs) => {
+    const limit = intArg(kwargs.limit, 20, 100);
+    return getConversationHistory(page as ChatGptBrowserPage, limit);
+  },
+});
+
+cli({
+  site: "chatgpt",
+  name: "detail",
+  description: "Open a ChatGPT web conversation by ID and read its messages",
+  domain: "chatgpt.com",
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    {
+      name: "id",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "Conversation ID or full /c/<id> URL",
+    },
+    {
+      name: "markdown",
+      type: "bool",
+      default: false,
+      description: "Emit assistant replies as markdown",
+    },
+  ],
+  columns: ["Index", "Role", "Text"],
+  func: async (page, kwargs) => {
+    const p = page as ChatGptBrowserPage;
+    const id = parseChatGptConversationId(kwargs.id);
+    const wantMarkdown = normalizeChatGptBoolean(kwargs.markdown, false);
+    await p.goto(`${CHATGPT_HOME}/c/${id}`, { settleMs: 2000 });
+    try {
+      await p.wait({ selector: CONVERSATION_MESSAGE_SELECTOR, timeout: 10 });
+    } catch {
+      await p.wait(0.5);
+    }
+    return readVisibleMessages(p, wantMarkdown);
+  },
+});

package/src/adapters/claude/web.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, it, vi } from "vitest";
+import { resolveCommand } from "../../registry.js";
+import {
+  mapClaudeConversations,
+  mapClaudeMessages,
+  normalizeClaudeBoolean,
+  parseClaudeConversationId,
+  requireClaudePositiveInt,
+  requireClaudePrompt,
+} from "./web.js";
+
+const CONVERSATION_ID = "123e4567-e89b-12d3-a456-426614174000";
+
+function pageMock(evaluateResults: unknown[]) {
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    wait: vi.fn().mockResolvedValue(undefined),
+    waitForSelector: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn(async () => evaluateResults.shift()),
+    insertText: vi.fn().mockResolvedValue(undefined),
+    setFileInput: vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+describe("claude agent-facing web commands", () => {
+  it("validates helper inputs and maps rows", () => {
+    expect(normalizeClaudeBoolean(true)).toBe(true);
+    expect(normalizeClaudeBoolean("true")).toBe(true);
+    expect(normalizeClaudeBoolean("1")).toBe(false);
+    expect(requireClaudePrompt(" hi ", "Claude ask")).toBe("hi");
+    expect(() => requireClaudePrompt(" ", "Claude ask")).toThrow(
+      "Claude ask prompt cannot be empty.",
+    );
+    expect(requireClaudePositiveInt("3", 20, "Claude history limit")).toBe(3);
+    expect(() =>
+      requireClaudePositiveInt(0, 20, "Claude history limit"),
+    ).toThrow("Claude history limit must be a positive integer.");
+    expect(parseClaudeConversationId(CONVERSATION_ID.toUpperCase())).toBe(
+      CONVERSATION_ID,
+    );
+    expect(
+      parseClaudeConversationId(`https://claude.ai/chat/${CONVERSATION_ID}`),
+    ).toBe(CONVERSATION_ID);
+    expect(() => parseClaudeConversationId("not-a-uuid")).toThrow(
+      "Invalid Claude",
+    );
+    expect(
+      mapClaudeMessages([
+        { role: "user", text: "Hi" },
+        { role: "assistant", text: "Hello" },
+      ]),
+    ).toEqual([
+      { Index: 1, Role: "user", Text: "Hi" },
+      { Index: 2, Role: "assistant", Text: "Hello" },
+    ]);
+    expect(
+      mapClaudeConversations(
+        [
+          {
+            Id: CONVERSATION_ID,
+            Title: "",
+            Url: `https://claude.ai/chat/${CONVERSATION_ID}`,
+          },
+        ],
+        10,
+      ),
+    ).toEqual([
+      {
+        Index: 1,
+        Id: CONVERSATION_ID,
+        Title: "(untitled)",
+        Url: `https://claude.ai/chat/${CONVERSATION_ID}`,
+      },
+    ]);
+  });
+
+  it("reads the current Claude conversation", async () => {
+    const command = resolveCommand("claude", "read")?.command;
+    const page = pageMock([
+      `https://claude.ai/chat/${CONVERSATION_ID}`,
+      {
+        url: `https://claude.ai/chat/${CONVERSATION_ID}`,
+        hasComposer: true,
+        isLoggedIn: true,
+      },
+      [
+        { role: "user", text: "Hi" },
+        { role: "assistant", text: "Hello" },
+      ],
+    ]);
+    await expect(command!.func!(page, {})).resolves.toEqual([
+      { Index: 1, Role: "user", Text: "Hi" },
+      { Index: 2, Role: "assistant", Text: "Hello" },
+    ]);
+  });
+
+  it("lists Claude history from recents", async () => {
+    const command = resolveCommand("claude", "history")?.command;
+    const page = pageMock([
+      "https://claude.ai/new",
+      [
+        {
+          Id: CONVERSATION_ID,
+          Title: "Chat",
+          Url: `https://claude.ai/chat/${CONVERSATION_ID}`,
+        },
+      ],
+      {
+        url: "https://claude.ai/recents",
+        hasComposer: false,
+        isLoggedIn: true,
+      },
+    ]);
+    await expect(command!.func!(page, { limit: 20 })).resolves.toEqual([
+      {
+        Index: 1,
+        Id: CONVERSATION_ID,
+        Title: "Chat",
+        Url: `https://claude.ai/chat/${CONVERSATION_ID}`,
+      },
+    ]);
+    expect(page.goto).toHaveBeenCalledWith("https://claude.ai/recents", {
+      waitUntil: "load",
+      settleMs: 2500,
+    });
+  });
+
+  it("opens Claude detail and reads messages", async () => {
+    const command = resolveCommand("claude", "detail")?.command;
+    const page = pageMock([
+      {
+        url: `https://claude.ai/chat/${CONVERSATION_ID}`,
+        hasComposer: false,
+        isLoggedIn: true,
+      },
+      [{ role: "assistant", text: "Answer" }],
+    ]);
+    await expect(
+      command!.func!(page, { id: CONVERSATION_ID }),
+    ).resolves.toEqual([{ Index: 1, Role: "assistant", Text: "Answer" }]);
+    expect(page.goto).toHaveBeenCalledWith(
+      `https://claude.ai/chat/${CONVERSATION_ID}`,
+      { waitUntil: "load", settleMs: 2500 },
+    );
+  });
+
+  it("sends Claude prompts without waiting", async () => {
+    const command = resolveCommand("claude", "send")?.command;
+    const page = pageMock([
+      "https://claude.ai/new",
+      { url: "https://claude.ai/new", hasComposer: true, isLoggedIn: true },
+      true,
+      { ok: true, method: "send-button" },
+    ]);
+    await expect(command!.func!(page, { prompt: "hello" })).resolves.toEqual([
+      { Status: "Success", SubmittedBy: "send-button", InjectedText: "hello" },
+    ]);
+    expect(page.insertText).toHaveBeenCalledWith("hello");
+  });
+
+  it("starts new Claude chats and reports status", async () => {
+    const newCommand = resolveCommand("claude", "new")?.command;
+    const newPage = pageMock([
+      { url: "https://claude.ai/new", hasComposer: true, isLoggedIn: true },
+    ]);
+    await expect(newCommand!.func!(newPage, {})).resolves.toEqual([
+      { Status: "New chat started" },
+    ]);
+    expect(newPage.goto).toHaveBeenCalledWith("https://claude.ai/new", {
+      waitUntil: "load",
+      settleMs: 2500,
+    });
+
+    const statusCommand = resolveCommand("claude", "status")?.command;
+    const statusPage = pageMock([
+      "https://claude.ai/new",
+      { url: "https://claude.ai/new", hasComposer: true, isLoggedIn: true },
+    ]);
+    await expect(statusCommand!.func!(statusPage, {})).resolves.toEqual([
+      { Status: "Connected", Login: "Yes", Url: "https://claude.ai/new" },
+    ]);
+  });
+
+  it("asks Claude and waits for a stable response", async () => {
+    const command = resolveCommand("claude", "ask")?.command;
+    const page = pageMock([
+      "https://claude.ai/new",
+      { url: "https://claude.ai/new", hasComposer: true, isLoggedIn: true },
+      "https://claude.ai/new",
+      { ok: true },
+      { ok: true },
+      { ok: true },
+      0,
+      true,
+      { ok: true, method: "send-button" },
+      { count: 1, last: "answer", streaming: false },
+      { count: 1, last: "answer", streaming: false },
+      { count: 1, last: "answer", streaming: false },
+      { count: 1, last: "answer", streaming: false },
+    ]);
+    await expect(
+      command!.func!(page, { prompt: "hello", timeout: 120 }),
+    ).resolves.toEqual([{ response: "answer" }]);
+    expect(page.insertText).toHaveBeenCalledWith("hello");
+  });
+});