@jackwener/opencli 1.0.6 → 1.1.0

package/dist/cli.js

@@ -9,6 +9,7 @@ import { PKG_VERSION } from './version.js';
 import { printCompletionScript } from './completion.js';
 import { CliError } from './errors.js';
 import { shouldUseBrowserSession } from './capabilityRouting.js';
+import { loadExternalClis, executeExternalCli, installExternalCli, registerExternalCli, isBinaryInstalled } from './external.js';
 export function runCli(BUILTIN_CLIS, USER_CLIS) {
     const program = new Command();
     program.name('opencli').description('Make any website your CLI. Zero setup. AI-powered.').version(PKG_VERSION);
@@ -53,7 +54,17 @@ export function runCli(BUILTIN_CLIS, USER_CLIS) {
             }
             console.log();
         }
-        console.log(chalk.dim(`  ${commands.length} commands across ${sites.size} sites`));
+        const externalClis = loadExternalClis();
+        if (externalClis.length > 0) {
+            console.log(chalk.bold.cyan(`  external CLIs`));
+            for (const ext of externalClis) {
+                const isInstalled = isBinaryInstalled(ext.binary);
+                const tag = isInstalled ? chalk.green('[installed]') : chalk.yellow('[auto-install]');
+                console.log(`    ${ext.name} ${tag}${ext.description ? chalk.dim(` — ${ext.description}`) : ''}`);
+            }
+            console.log();
+        }
+        console.log(chalk.dim(`  ${commands.length} built-in commands across ${sites.size} sites, ${externalClis.length} external CLIs`));
         console.log();
     });
     program.command('validate').description('Validate CLI definitions').argument('[target]', 'site or site/name')
@@ -126,6 +137,45 @@ export function runCli(BUILTIN_CLIS, USER_CLIS) {
         .action((shell) => {
         printCompletionScript(shell);
     });
+    const externalClis = loadExternalClis();
+    program.command('install')
+        .description('Install an external CLI')
+        .argument('<name>', 'Name of the external CLI')
+        .action((name) => {
+        const ext = externalClis.find(e => e.name === name);
+        if (!ext) {
+            console.error(chalk.red(`External CLI '${name}' not found in registry.`));
+            process.exitCode = 1;
+            return;
+        }
+        installExternalCli(ext);
+    });
+    program.command('register')
+        .description('Register an external CLI')
+        .argument('<name>', 'Name of the CLI')
+        .option('--binary <bin>', 'Binary name if different from name')
+        .option('--install <cmd>', 'Auto-install command')
+        .option('--desc <text>', 'Description')
+        .action((name, opts) => {
+        registerExternalCli(name, opts.binary, opts.install, opts.desc);
+    });
+    for (const ext of externalClis) {
+        if (program.commands.some(c => c.name() === ext.name))
+            continue;
+        program.command(ext.name)
+            .description(`(External) ${ext.description || ext.name}`)
+            .allowUnknownOption()
+            .action(() => {
+            // Retrieve args passed to the external CLI
+            // Commander consumes standard args before the action, so we must slice process.argv directly.
+            const extIndex = process.argv.indexOf(ext.name);
+            const args = process.argv.slice(extIndex + 1);
+            executeExternalCli(ext.name, args).catch(err => {
+                console.error(chalk.red(`Error: ${err.message}`));
+                process.exitCode = 1;
+            });
+        });
+    }
     // ── Antigravity serve (built-in, long-running) ──────────────────────────────
     const antigravityCmd = program.command('antigravity').description('antigravity commands');
     antigravityCmd.command('serve')

package/dist/clis/antigravity/serve.js

@@ -52,68 +52,254 @@ function jsonResponse(res, status, data) {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+// ─── DOM helpers ─────────────────────────────────────────────────────
+/**
+ * Click the 'New Conversation' button to reset context.
+ */
+async function startNewConversation(page) {
+    await page.evaluate(`
+    (() => {
+      const btn = document.querySelector('[data-tooltip-id="new-conversation-tooltip"]');
+      if (btn) btn.click();
+    })()
+  `);
+    await sleep(1000); // Give UI time to clear
+}
+/**
+ * Switch the active model in Antigravity UI.
+ */
+async function switchModel(page, anthropicModelId) {
+    // Map standard model IDs to Antigravity UI names based on actual UI
+    let targetName = 'claude sonnet 4.6'; // Default fallback
+    const id = anthropicModelId.toLowerCase();
+    if (id.includes('sonnet')) {
+        targetName = 'claude sonnet 4.6';
+    }
+    else if (id.includes('opus')) {
+        targetName = 'claude opus 4.6';
+    }
+    else if (id.includes('gemini') && id.includes('pro')) {
+        targetName = 'gemini 3.1 pro (high)';
+    }
+    else if (id.includes('gemini') && id.includes('flash')) {
+        targetName = 'gemini 3 flash';
+    }
+    else if (id.includes('gpt')) {
+        targetName = 'gpt-oss 120b';
+    }
+    try {
+        await page.evaluate(`
+      async () => {
+        const targetModelName = ${JSON.stringify(targetName)};
+        const trigger = document.querySelector('div[aria-haspopup="dialog"] > div[tabindex="0"]');
+        if (!trigger) return; // Silent fail if UI changed
+        
+        // Open dropdown only if not already selected
+        if (trigger.innerText.toLowerCase().includes(targetModelName)) return;
+        
+        trigger.click();
+        await new Promise(r => setTimeout(r, 200));
+        
+        const spans = Array.from(document.querySelectorAll('[role="dialog"] span'));
+        const target = spans.find(s => s.innerText.toLowerCase().includes(targetModelName));
+        if (target) {
+          const optionNode = target.closest('.cursor-pointer') || target;
+          optionNode.click();
+        } else {
+          // Close if not found
+          trigger.click(); 
+        }
+      }
+    `);
+        await sleep(500); // Wait for switch
+    }
+    catch (err) {
+        console.error(`[serve] Warning: Could not switch to model ${targetName}:`, err);
+    }
+}
+/**
+ * Check if the Antigravity UI is currently generating a response
+ * by looking for Stop/Cancel buttons or loading indicators.
+ */
+async function isGenerating(page) {
+    const result = await page.evaluate(`
+    (() => {
+      // Look for a cancel/stop button in the UI
+      const cancelBtn = document.querySelector('button[aria-label*="cancel" i], button[aria-label*="stop" i], button[title*="cancel" i], button[title*="stop" i]');
+      return !!cancelBtn;
+    })()
+  `);
+    return Boolean(result);
+}
+/**
+ * Walk from the scroll container and find the deepest element that
+ * has multiple non-empty children (our message container).
+ */
+function findMessageContainer(root, depth = 0) {
+    if (!root || depth > 12)
+        return null;
+    const nonEmpty = Array.from(root.children).filter(c => c.innerText?.trim().length > 5);
+    if (nonEmpty.length >= 2)
+        return root;
+    if (nonEmpty.length === 1)
+        return findMessageContainer(nonEmpty[0], depth + 1);
+    return root;
+}
 // ─── Antigravity CDP Operations ──────────────────────────────────────
+/**
+ * Get the full chat text for change-detection polling.
+ */
 async function getConversationText(page) {
     const text = await page.evaluate(`
     (() => {
       const container = document.getElementById('conversation');
-      return container ? container.innerText : '';
+      if (!container) return '';
+      // Read only the first child div (actual chat content),
+      // skipping UI chrome like file change panels, model selectors, etc.
+      const chatContent = container.children[0];
+      return chatContent ? chatContent.innerText : container.innerText;
     })()
   `);
     return String(text ?? '');
 }
-async function sendMessage(page, message) {
-    await page.evaluate(`
-    (async () => {
+/**
+ * Get the text of the last assistant reply by navigating to the message container
+ * and extracting the last non-empty message block.
+ */
+async function getLastAssistantReply(page, userText) {
+    const text = await page.evaluate(`
+    (() => {
+      const conv = document.getElementById('conversation')?.children[0];
+      const scroll = conv?.querySelector('.overflow-y-auto');
+      
+      // Walk down until we find a container with multiple message siblings
+      function findMsgContainer(el, depth) {
+        if (!el || depth > 12) return null;
+        const nonEmpty = Array.from(el.children).filter(c => c.innerText && c.innerText.trim().length > 5);
+        if (nonEmpty.length >= 2) return el;
+        if (nonEmpty.length === 1) return findMsgContainer(nonEmpty[0], depth + 1);
+        return null;
+      }
+      
+      const container = findMsgContainer(scroll || conv, 0);
+      if (!container) return '';
+      
+      // Get all non-empty children (skip trailing empty UI divs)
+      const msgs = Array.from(container.children).filter(
+        c => c.innerText && c.innerText.trim().length > 5
+      );
+      
+      if (msgs.length === 0) return '';
+      
+      // The last element is the last assistant reply
+      const last = msgs[msgs.length - 1];
+      return last.innerText || '';
+    })()
+  `);
+    let reply = String(text ?? '').trim();
+    // Strip echoed user message from the top (Antigravity sometimes includes it)
+    if (userText && reply.startsWith(userText)) {
+        reply = reply.slice(userText.length).trim();
+    }
+    // Strip thinking block: "Thought for Xs\n..." at the start
+    reply = reply.replace(/^Thought for[^\n]*\n+/i, '').trim();
+    // Strip "Copy" button text at the end
+    reply = reply.replace(/\s*\bCopy\b\s*$/m, '').trim();
+    // De-duplicate trailing repeated content (e.g., "OK\n\nOK" → "OK")
+    const half = Math.floor(reply.length / 2);
+    const firstHalf = reply.slice(0, half).trim();
+    const secondHalf = reply.slice(half).trim();
+    if (firstHalf && firstHalf === secondHalf) {
+        reply = firstHalf;
+    }
+    return reply;
+}
+async function sendMessage(page, message, bridge) {
+    if (!bridge) {
+        // Fallback: use JS-based approach
+        await page.evaluate(`
+      (() => {
+        const container = document.getElementById('antigravity.agentSidePanelInputBox');
+        const editor = container?.querySelector('[data-lexical-editor="true"]');
+        if (!editor) throw new Error('Could not find input box');
+        editor.focus();
+        document.execCommand('insertText', false, ${JSON.stringify(message)});
+      })()
+    `);
+        await sleep(500);
+        await page.pressKey('Enter');
+        return;
+    }
+    // Get the bounding box of the Lexical editor for a physical mouse click
+    const rect = await page.evaluate(`
+    (() => {
       const container = document.getElementById('antigravity.agentSidePanelInputBox');
       if (!container) throw new Error('Could not find antigravity.agentSidePanelInputBox');
       const editor = container.querySelector('[data-lexical-editor="true"]');
       if (!editor) throw new Error('Could not find Antigravity input box');
-      
-      editor.focus();
-      document.execCommand('insertText', false, ${JSON.stringify(message)});
+      const r = editor.getBoundingClientRect();
+      return JSON.stringify({ x: r.left + r.width / 2, y: r.top + r.height / 2 });
     })()
   `);
-    await sleep(500);
-    await page.pressKey('Enter');
+    const { x, y } = JSON.parse(String(rect));
+    // Physical mouse click to give the element real browser focus
+    await bridge.send('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 });
+    await sleep(50);
+    await bridge.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 1 });
+    await sleep(200);
+    // Inject text at the CDP level (no deprecated execCommand)
+    await bridge.send('Input.insertText', { text: message });
+    await sleep(300);
+    // Send Enter via native CDP key event
+    await bridge.send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13 });
+    await sleep(50);
+    await bridge.send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13 });
 }
 async function waitForReply(page, beforeText, opts = {}) {
     const timeout = opts.timeout ?? 120_000; // 2 minutes max
     const pollInterval = opts.pollInterval ?? 500; // 500ms polling
-    const stableThreshold = opts.stableThreshold ?? 6; // 6 × 500ms = 3s stable
     const deadline = Date.now() + timeout;
+    // Wait a bit to ensure the UI transitions to "generating" state after we hit Enter
+    await sleep(1000);
+    let hasStartedGenerating = false;
     let lastText = beforeText;
     let stableCount = 0;
-    // Wait a bit for the model to start generating
-    await sleep(1000);
+    const stableThreshold = 4; // 4 * 500ms = 2s of stability fallback
     while (Date.now() < deadline) {
-        const current = await getConversationText(page);
-        if (current.length > beforeText.length) {
-            // New content appeared
-            if (current === lastText) {
-                stableCount++;
-                if (stableCount >= stableThreshold) {
-                    // Text has been stable — reply is complete
-                    return current.slice(beforeText.length).trim();
-                }
+        const generating = await isGenerating(page);
+        const currentText = await getConversationText(page);
+        const textChanged = currentText !== beforeText && currentText.length > 0;
+        if (generating) {
+            hasStartedGenerating = true;
+            stableCount = 0; // Reset stability while generating
+        }
+        else {
+            if (hasStartedGenerating) {
+                // It actively generated and now it stopped -> DONE
+                // Provide a small buffer to let React render the final message fully
+                await sleep(500);
+                return;
             }
-            else {
-                // Still generating
-                stableCount = 0;
-                lastText = current;
+            // Fallback: If it never showed "Generating/Cancel", but text changed and is stable
+            if (textChanged) {
+                if (currentText === lastText) {
+                    stableCount++;
+                    if (stableCount >= stableThreshold) {
+                        return; // Text has been stable for 2 seconds -> DONE
+                    }
+                }
+                else {
+                    stableCount = 0;
+                    lastText = currentText;
+                }
             }
         }
         await sleep(pollInterval);
     }
-    // Timeout — return whatever we have
-    const finalText = await getConversationText(page);
-    if (finalText.length > beforeText.length) {
-        return finalText.slice(beforeText.length).trim();
-    }
     throw new Error('Timeout waiting for Antigravity reply');
 }
 // ─── Request Handlers ────────────────────────────────────────────────
-async function handleMessages(body, page) {
+async function handleMessages(body, page, bridge) {
     // Extract the last user message
     const userMessages = body.messages.filter(m => m.role === 'user');
     if (userMessages.length === 0) {
@@ -124,14 +310,25 @@ async function handleMessages(body, page) {
     if (!userText.trim()) {
         throw new Error('Empty user message');
     }
+    // Optimization 1: New conversation if this is the first message in the session
+    if (body.messages.length === 1) {
+        console.error(`[serve] New session detected (1 message). Starting new conversation in UI.`);
+        await startNewConversation(page);
+    }
+    // Optimization 3: Switch model if requested
+    if (body.model) {
+        await switchModel(page, body.model);
+    }
     // Get conversation state before sending
     const beforeText = await getConversationText(page);
     // Send the message
     console.error(`[serve] Sending: "${userText.slice(0, 80)}${userText.length > 80 ? '...' : ''}"`);
-    await sendMessage(page, userText);
-    // Poll for reply
+    await sendMessage(page, userText, bridge);
+    // Poll for reply (change detection)
     console.error('[serve] Waiting for reply...');
-    const replyText = await waitForReply(page, beforeText);
+    await waitForReply(page, beforeText);
+    // Extract the actual reply text precisely from the DOM
+    const replyText = await getLastAssistantReply(page, userText);
     console.error(`[serve] Got reply: "${replyText.slice(0, 80)}${replyText.length > 80 ? '...' : ''}"`);
     return {
         id: generateMsgId(),
@@ -150,15 +347,65 @@ async function handleMessages(body, page) {
 // ─── Server ──────────────────────────────────────────────────────────
 export async function startServe(opts = {}) {
     const port = opts.port ?? 8082;
-    // Establish persistent CDP connection
-    console.error('[serve] Connecting to Antigravity via CDP...');
-    const cdp = new CDPBridge();
-    const page = await cdp.connect({ timeout: 15_000 });
-    console.error('[serve] CDP connected successfully.');
-    // Verify we can read conversation
-    const testText = await getConversationText(page);
-    console.error(`[serve] Conversation element found (${testText.length} chars).`);
+    // Lazy CDP connection — connect when first request comes in
+    let cdp = null;
+    let page = null;
     let requestInFlight = false;
+    async function ensureConnected() {
+        if (page) {
+            try {
+                await page.evaluate('1+1');
+                return page;
+            }
+            catch {
+                console.error('[serve] CDP connection lost, reconnecting...');
+                cdp?.close().catch(() => { });
+                cdp = null;
+                page = null;
+            }
+        }
+        const endpoint = process.env.OPENCLI_CDP_ENDPOINT;
+        if (!endpoint) {
+            throw new Error('OPENCLI_CDP_ENDPOINT is not set.\n' +
+                'Usage: OPENCLI_CDP_ENDPOINT=http://127.0.0.1:9224 opencli antigravity serve');
+        }
+        // Note: Antigravity chat panel lives inside editor windows, not in Launchpad.
+        // If multiple editor windows are open, set OPENCLI_CDP_TARGET to the window title.
+        if (process.env.OPENCLI_CDP_TARGET) {
+            console.error(`[serve] Using OPENCLI_CDP_TARGET=${process.env.OPENCLI_CDP_TARGET}`);
+        }
+        // List available targets for debugging
+        try {
+            const res = await fetch(`${endpoint.replace(/\/$/, '')}/json`);
+            const targets = await res.json();
+            const pages = targets.filter(t => t.type === 'page');
+            console.error(`[serve] Available targets: ${pages.map(t => `"${t.title}"`).join(', ')}`);
+        }
+        catch { /* ignore */ }
+        console.error(`[serve] Connecting via CDP (target pattern: "${process.env.OPENCLI_CDP_TARGET}")...`);
+        cdp = new CDPBridge();
+        try {
+            page = await cdp.connect({ timeout: 15_000 });
+        }
+        catch (err) {
+            cdp = null;
+            const isRefused = err?.cause?.code === 'ECONNREFUSED' || err?.message?.includes('ECONNREFUSED');
+            throw new Error(isRefused
+                ? `Cannot connect to Antigravity at ${endpoint}.\n` +
+                    '  1. Make sure Antigravity is running\n' +
+                    '  2. Launch with: --remote-debugging-port=9224'
+                : `CDP connection failed: ${err.message}`);
+        }
+        console.error('[serve] ✅ CDP connected.');
+        // Quick verification
+        const hasUI = await page.evaluate(`
+      (() => !!document.getElementById('conversation') || !!document.getElementById('antigravity.agentSidePanelInputBox'))()
+    `);
+        if (!hasUI) {
+            console.error('[serve] ⚠️  Warning: chat UI elements not found in this target. Try setting OPENCLI_CDP_TARGET to the correct window title.');
+        }
+        return page;
+    }
     const server = createServer(async (req, res) => {
         // CORS preflight
         if (req.method === 'OPTIONS') {
@@ -204,7 +451,6 @@ export async function startServe(opts = {}) {
                     const rawBody = await readBody(req);
                     const body = JSON.parse(rawBody);
                     if (body.stream) {
-                        // We don't support streaming — return error
                         jsonResponse(res, 400, {
                             type: 'error',
                             error: {
@@ -214,7 +460,9 @@ export async function startServe(opts = {}) {
                         });
                         return;
                     }
-                    const response = await handleMessages(body, page);
+                    // Lazy connect on first request
+                    const activePage = await ensureConnected();
+                    const response = await handleMessages(body, activePage, cdp ?? undefined);
                     jsonResponse(res, 200, response);
                 }
                 finally {
@@ -224,7 +472,7 @@ export async function startServe(opts = {}) {
             }
             // Health check
             if (req.method === 'GET' && (pathname === '/' || pathname === '/health')) {
-                jsonResponse(res, 200, { ok: true, status: 'connected' });
+                jsonResponse(res, 200, { ok: true, cdpConnected: page !== null });
                 return;
             }
             jsonResponse(res, 404, {
@@ -233,7 +481,7 @@ export async function startServe(opts = {}) {
             });
         }
         catch (err) {
-            console.error('[serve] Error:', err);
+            console.error('[serve] Error:', err instanceof Error ? err.message : err);
             jsonResponse(res, 500, {
                 type: 'error',
                 error: {
@@ -246,13 +494,14 @@ export async function startServe(opts = {}) {
     server.listen(port, '127.0.0.1', () => {
         console.error(`\n[serve] ✅ Antigravity API proxy running at http://127.0.0.1:${port}`);
         console.error(`[serve] Compatible with Anthropic /v1/messages API`);
+        console.error(`[serve] CDP connection will be established on first request.`);
         console.error(`\n[serve] Usage with Claude Code:`);
         console.error(`  ANTHROPIC_BASE_URL=http://localhost:${port} claude\n`);
     });
     // Graceful shutdown
     const shutdown = () => {
         console.error('\n[serve] Shutting down...');
-        cdp.close().catch(() => { });
+        cdp?.close().catch(() => { });
         server.close();
         process.exit(0);
     };

package/dist/clis/arxiv/paper.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/arxiv/paper.js

@@ -0,0 +1,21 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { arxivFetch, parseEntries } from './utils.js';
+cli({
+    site: 'arxiv',
+    name: 'paper',
+    description: 'Get arXiv paper details by ID',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'arXiv paper ID (e.g. 1706.03762)' },
+    ],
+    columns: ['id', 'title', 'authors', 'published', 'abstract', 'url'],
+    func: async (_page, args) => {
+        const xml = await arxivFetch(`id_list=${encodeURIComponent(args.id)}`);
+        const entries = parseEntries(xml);
+        if (!entries.length)
+            throw new CliError('NOT_FOUND', `Paper ${args.id} not found`, 'Check the arXiv ID format, e.g. 1706.03762');
+        return entries;
+    },
+});

package/dist/clis/arxiv/search.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/arxiv/search.js

@@ -0,0 +1,24 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { arxivFetch, parseEntries } from './utils.js';
+cli({
+    site: 'arxiv',
+    name: 'search',
+    description: 'Search arXiv papers',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'keyword', positional: true, required: true, help: 'Search keyword (e.g. "attention is all you need")' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max results (max 25)' },
+    ],
+    columns: ['id', 'title', 'authors', 'published'],
+    func: async (_page, args) => {
+        const limit = Math.max(1, Math.min(Number(args.limit), 25));
+        const query = encodeURIComponent(`all:${args.keyword}`);
+        const xml = await arxivFetch(`search_query=${query}&max_results=${limit}&sortBy=relevance`);
+        const entries = parseEntries(xml);
+        if (!entries.length)
+            throw new CliError('NOT_FOUND', 'No papers found', 'Try a different keyword');
+        return entries.map(e => ({ id: e.id, title: e.title, authors: e.authors, published: e.published }));
+    },
+});

package/dist/clis/arxiv/utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * arXiv adapter utilities.
+ *
+ * arXiv exposes a public Atom/XML API — no key required.
+ * https://info.arxiv.org/help/api/index.html
+ */
+export declare const ARXIV_BASE = "https://export.arxiv.org/api/query";
+export declare function arxivFetch(params: string): Promise<string>;
+export interface ArxivEntry {
+    id: string;
+    title: string;
+    authors: string;
+    abstract: string;
+    published: string;
+    url: string;
+}
+/** Parse Atom XML feed into structured entries. */
+export declare function parseEntries(xml: string): ArxivEntry[];

package/dist/clis/arxiv/utils.js

@@ -0,0 +1,49 @@
+/**
+ * arXiv adapter utilities.
+ *
+ * arXiv exposes a public Atom/XML API — no key required.
+ * https://info.arxiv.org/help/api/index.html
+ */
+import { CliError } from '../../errors.js';
+export const ARXIV_BASE = 'https://export.arxiv.org/api/query';
+export async function arxivFetch(params) {
+    const resp = await fetch(`${ARXIV_BASE}?${params}`);
+    if (!resp.ok) {
+        throw new CliError('FETCH_ERROR', `arXiv API HTTP ${resp.status}`, 'Check your search term or paper ID');
+    }
+    return resp.text();
+}
+/** Extract the text content of the first matching XML tag. */
+function extract(xml, tag) {
+    const m = xml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`));
+    return m ? m[1].trim() : '';
+}
+/** Extract all text contents of a repeated XML tag. */
+function extractAll(xml, tag) {
+    const re = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'g');
+    const results = [];
+    let m;
+    while ((m = re.exec(xml)) !== null)
+        results.push(m[1].trim());
+    return results;
+}
+/** Parse Atom XML feed into structured entries. */
+export function parseEntries(xml) {
+    const entryRe = /<entry>([\s\S]*?)<\/entry>/g;
+    const entries = [];
+    let m;
+    while ((m = entryRe.exec(xml)) !== null) {
+        const e = m[1];
+        const rawId = extract(e, 'id');
+        const arxivId = rawId.replace(/^https?:\/\/arxiv\.org\/abs\//, '').replace(/v\d+$/, '');
+        entries.push({
+            id: arxivId,
+            title: extract(e, 'title').replace(/\s+/g, ' '),
+            authors: extractAll(e, 'name').slice(0, 3).join(', '),
+            abstract: (() => { const s = extract(e, 'summary').replace(/\s+/g, ' '); return s.length > 200 ? s.slice(0, 200) + '...' : s; })(),
+            published: extract(e, 'published').slice(0, 10),
+            url: `https://arxiv.org/abs/${arxivId}`,
+        });
+    }
+    return entries;
+}

package/dist/clis/boss/batchgreet.d.ts

@@ -0,0 +1 @@
+export {};