@jackwener/opencli 0.8.0 → 0.9.1

package/dist/clis/antigravity/send.js

@@ -0,0 +1,35 @@
+import { cli, Strategy } from '../../registry.js';
+export const sendCommand = cli({
+    site: 'antigravity',
+    name: 'send',
+    description: 'Send a message to Antigravity AI via the internal Lexical editor',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'message', help: 'The message text to send', required: true, positional: true }
+    ],
+    columns: ['status', 'message'],
+    func: async (page, kwargs) => {
+        const text = kwargs.message;
+        // We use evaluate to focus and insert text because Lexical editors maintain
+        // absolute control over their DOM and don't respond to raw node.textContent.
+        // document.execCommand simulates a native paste/typing action perfectly.
+        await page.evaluate(`
+      async () => {
+        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(text)});
+      }
+    `);
+        // Wait for the React/Lexical state to flush the new input
+        await page.wait(0.5);
+        // Press Enter to submit the message
+        await page.pressKey('Enter');
+        return [{ status: 'Sent successfully', message: text }];
+    },
+});

package/dist/clis/antigravity/status.d.ts

@@ -0,0 +1 @@
+export declare const statusCommand: import("../../registry.js").CliCommand;

package/dist/clis/antigravity/status.js

@@ -0,0 +1,18 @@
+import { cli, Strategy } from '../../registry.js';
+export const statusCommand = cli({
+    site: 'antigravity',
+    name: 'status',
+    description: 'Check Antigravity CDP connection and get current page state',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['status', 'url', 'title'],
+    func: async (page) => {
+        return {
+            status: 'Connected',
+            url: await page.evaluate('window.location.href'),
+            title: await page.evaluate('document.title'),
+        };
+    },
+});

package/dist/clis/antigravity/watch.d.ts

@@ -0,0 +1 @@
+export declare const watchCommand: import("../../registry.js").CliCommand;

package/dist/clis/antigravity/watch.js

@@ -0,0 +1,41 @@
+import { cli, Strategy } from '../../registry.js';
+export const watchCommand = cli({
+    site: 'antigravity',
+    name: 'watch',
+    description: 'Stream new chat messages from Antigravity in real-time',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    timeoutSeconds: 86400, // Run for up to 24 hours
+    columns: [], // We use direct stdout streaming
+    func: async (page) => {
+        console.log('Watching Antigravity chat... (Press Ctrl+C to stop)');
+        let lastLength = 0;
+        // Loop until process gets killed
+        while (true) {
+            const text = await page.evaluate(`
+        async () => {
+          const container = document.getElementById('conversation');
+          return container ? container.innerText : '';
+        }
+      `);
+            const currentLength = text.length;
+            if (currentLength > lastLength) {
+                // Delta mode
+                const newSegment = text.substring(lastLength);
+                if (newSegment.trim().length > 0) {
+                    process.stdout.write(newSegment);
+                }
+                lastLength = currentLength;
+            }
+            else if (currentLength < lastLength) {
+                // The conversation was cleared or updated significantly
+                lastLength = currentLength;
+                console.log('\\n--- Conversation Cleared/Changed ---\\n');
+                process.stdout.write(text);
+            }
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+    },
+});

package/dist/clis/codex/dump.d.ts

@@ -0,0 +1 @@
+export declare const dumpCommand: import("../../registry.js").CliCommand;

package/dist/clis/codex/dump.js

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '../../registry.js';
+import * as fs from 'fs';
+export const dumpCommand = cli({
+    site: 'codex',
+    name: 'dump',
+    description: 'Dump the DOM and Accessibility tree of Codex for reverse-engineering',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    columns: ['action', 'files'],
+    func: async (page) => {
+        // Extract full HTML
+        const dom = await page.evaluate('document.body.innerHTML');
+        fs.writeFileSync('/tmp/codex-dom.html', dom);
+        // Get accessibility snapshot
+        const snap = await page.snapshot({ interactive: false });
+        fs.writeFileSync('/tmp/codex-snapshot.json', JSON.stringify(snap, null, 2));
+        return [
+            {
+                action: 'Dom extraction finished',
+                files: '/tmp/codex-dom.html, /tmp/codex-snapshot.json',
+            },
+        ];
+    },
+});

package/dist/clis/codex/extract-diff.d.ts

@@ -0,0 +1 @@
+export declare const extractDiffCommand: import("../../registry.js").CliCommand;

package/dist/clis/codex/extract-diff.js

@@ -0,0 +1,44 @@
+import { cli, Strategy } from '../../registry.js';
+export const extractDiffCommand = cli({
+    site: 'codex',
+    name: 'extract-diff',
+    description: 'Extract visual code review diff patches from Codex',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    columns: ['File', 'Diff'],
+    func: async (page) => {
+        const diffs = await page.evaluate(`
+      (function() {
+        const results = [];
+        // Assuming diffs are rendered with standard diff classes or monaco difference editors
+        const diffBlocks = document.querySelectorAll('.diff-editor, .monaco-diff-editor, [data-testid="diff-view"]');
+        
+        diffBlocks.forEach((block, index) => {
+            // Very roughly scrape text representing additions/deletions mapped from the inner wrapper
+            results.push({
+                File: block.getAttribute('data-filename') || \`DiffBlock_\${index+1}\`,
+                Diff: block.innerText || block.textContent
+            });
+        });
+
+        // If no structured diffs found, try to find any code blocks labeled as patches
+        if (results.length === 0) {
+            const codeBlocks = document.querySelectorAll('pre code.language-diff, pre code.language-patch');
+            codeBlocks.forEach((code, index) => {
+                results.push({
+                    File: \`Patch_\${index+1}\`,
+                    Diff: code.innerText || code.textContent
+                });
+            });
+        }
+        
+        return results;
+      })()
+    `);
+        if (diffs.length === 0) {
+            return [{ File: 'No diffs found', Diff: 'Try running opencli codex send "/review" first' }];
+        }
+        return diffs;
+    },
+});

package/dist/clis/codex/new.d.ts

@@ -0,0 +1 @@
+export declare const newCommand: import("../../registry.js").CliCommand;

package/dist/clis/codex/new.js

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '../../registry.js';
+export const newCommand = cli({
+    site: 'codex',
+    name: 'new',
+    description: 'Start a new Codex conversation thread / isolated workspace',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    columns: ['Status', 'Action'],
+    func: async (page) => {
+        // According to research, Cmd+N / Ctrl+N spins up a new thread
+        const isMac = process.platform === 'darwin';
+        const newThreadKey = isMac ? 'Meta+N' : 'Control+N';
+        // Simulate keyboard shortcut
+        await page.pressKey(newThreadKey);
+        // Wait a brief moment for UI animation
+        await page.wait(1);
+        return [
+            {
+                Status: 'Success',
+                Action: `Pressed ${newThreadKey} to trigger New Thread`,
+            },
+        ];
+    },
+});

package/dist/clis/codex/read.d.ts

@@ -0,0 +1 @@
+export declare const readCommand: import("../../registry.js").CliCommand;

package/dist/clis/codex/read.js

@@ -0,0 +1,31 @@
+import { cli, Strategy } from '../../registry.js';
+export const readCommand = cli({
+    site: 'codex',
+    name: 'read',
+    description: 'Read the contents of the current Codex conversation thread',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    columns: ['Thread_Content'],
+    func: async (page) => {
+        const historyText = await page.evaluate(`
+      (function() {
+        // Fallback robust scraping heuristic for chat history panes
+        // We look for large scrolling areas or generic message lists
+        const threadContainer = document.querySelector('[role="log"], [data-testid="conversation"], main, .thread-container, .messages-list');
+        
+        if (threadContainer) {
+          return threadContainer.innerText || threadContainer.textContent;
+        }
+        
+        // If specific containers fail, just dump the whole body's readable text minus the navigation
+        return document.body.innerText;
+      })()
+    `);
+        return [
+            {
+                Thread_Content: historyText,
+            },
+        ];
+    },
+});

package/dist/clis/codex/send.d.ts

@@ -0,0 +1 @@
+export declare const sendCommand: import("../../registry.js").CliCommand;

package/dist/clis/codex/send.js

@@ -0,0 +1,44 @@
+import { cli, Strategy } from '../../registry.js';
+export const sendCommand = cli({
+    site: 'codex',
+    name: 'send',
+    description: 'Send text/commands to the Codex AI composer',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [{ name: 'text', required: true, help: 'Text, command (e.g. /review), or skill (e.g. $imagegen)' }],
+    columns: ['Status', 'InjectedText'],
+    func: async (page, kwargs) => {
+        const textToInsert = kwargs.text;
+        // We use evaluate to inject text bypassing complex nested shadow roots or contenteditables
+        await page.evaluate(`
+      (function(text) {
+        // Attempt 1: Look for standard textarea/composer input
+        let composer = document.querySelector('textarea, [contenteditable="true"]');
+        
+        // Basic heuristic: prioritize elements that are deeply nested, visible, and have 'composer' or 'input' classes
+        const editables = Array.from(document.querySelectorAll('[contenteditable="true"]'));
+        if (editables.length > 0) {
+           composer = editables[editables.length - 1]; // Often the active input is appended near the end
+        }
+
+        if (!composer) {
+          throw new Error('Could not find Composer input element in Codex UI');
+        }
+
+        composer.focus();
+        
+        // This handles Lexical/ProseMirror/Monaco rich-text editors effectively by mimicking human paste/type deeply.
+        document.execCommand('insertText', false, text);
+      })(${JSON.stringify(textToInsert)})
+    `);
+        // Simulate Enter key to submit
+        await page.pressKey('Enter');
+        return [
+            {
+                Status: 'Success',
+                InjectedText: textToInsert,
+            },
+        ];
+    },
+});

package/dist/clis/codex/status.d.ts

@@ -0,0 +1 @@
+export declare const statusCommand: import("../../registry.js").CliCommand;

package/dist/clis/codex/status.js

@@ -0,0 +1,21 @@
+import { cli, Strategy } from '../../registry.js';
+export const statusCommand = cli({
+    site: 'codex',
+    name: 'status',
+    description: 'Check active CDP connection to OpenAI Codex App',
+    domain: 'localhost',
+    strategy: Strategy.UI, // Interactive UI manipulation
+    browser: true,
+    columns: ['Status', 'Url', 'Title'],
+    func: async (page) => {
+        const url = await page.evaluate('window.location.href');
+        const title = await page.evaluate('document.title');
+        return [
+            {
+                Status: 'Connected',
+                Url: url,
+                Title: title,
+            },
+        ];
+    },
+});

package/dist/clis/xiaoyuzhou/episode.d.ts

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

package/dist/clis/xiaoyuzhou/episode.js

@@ -0,0 +1,28 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { fetchPageProps, formatDuration, formatDate } from './utils.js';
+cli({
+    site: 'xiaoyuzhou',
+    name: 'episode',
+    description: 'View details of a Xiaoyuzhou podcast episode',
+    domain: 'www.xiaoyuzhoufm.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'id', positional: true, required: true, help: 'Episode ID (eid from podcast-episodes output)' }],
+    columns: ['title', 'podcast', 'duration', 'plays', 'comments', 'likes', 'date'],
+    func: async (_page, args) => {
+        const pageProps = await fetchPageProps(`/episode/${args.id}`);
+        const ep = pageProps.episode;
+        if (!ep)
+            throw new CliError('NOT_FOUND', 'Episode not found', 'Please check the ID');
+        return [{
+                title: ep.title,
+                podcast: ep.podcast?.title,
+                duration: formatDuration(ep.duration),
+                plays: ep.playCount,
+                comments: ep.commentCount,
+                likes: ep.clapCount,
+                date: formatDate(ep.pubDate),
+            }];
+    },
+});

package/dist/clis/xiaoyuzhou/podcast-episodes.d.ts

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

package/dist/clis/xiaoyuzhou/podcast-episodes.js

@@ -0,0 +1,36 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { fetchPageProps, formatDuration, formatDate } from './utils.js';
+cli({
+    site: 'xiaoyuzhou',
+    name: 'podcast-episodes',
+    description: 'List recent episodes of a Xiaoyuzhou podcast (up to 15, SSR limit)',
+    domain: 'www.xiaoyuzhoufm.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'Podcast ID (from xiaoyuzhoufm.com URL)' },
+        { name: 'limit', type: 'int', default: 15, help: 'Max episodes to show (up to 15, SSR limit)' },
+    ],
+    columns: ['eid', 'title', 'duration', 'plays', 'date'],
+    func: async (_page, args) => {
+        const pageProps = await fetchPageProps(`/podcast/${args.id}`);
+        const podcast = pageProps.podcast;
+        if (!podcast)
+            throw new CliError('NOT_FOUND', 'Podcast not found', 'Please check the ID');
+        const allEpisodes = podcast.episodes ?? [];
+        const requestedLimit = Number(args.limit);
+        if (!Number.isInteger(requestedLimit) || requestedLimit < 1) {
+            throw new CliError('INVALID_ARGUMENT', 'limit must be a positive integer', 'Example: --limit 5');
+        }
+        const limit = Math.min(requestedLimit, allEpisodes.length);
+        const episodes = allEpisodes.slice(0, limit);
+        return episodes.map((ep) => ({
+            eid: ep.eid,
+            title: ep.title,
+            duration: formatDuration(ep.duration),
+            plays: ep.playCount,
+            date: formatDate(ep.pubDate),
+        }));
+    },
+});

package/dist/clis/xiaoyuzhou/podcast.d.ts

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

package/dist/clis/xiaoyuzhou/podcast.js

@@ -0,0 +1,27 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { fetchPageProps, formatDate } from './utils.js';
+cli({
+    site: 'xiaoyuzhou',
+    name: 'podcast',
+    description: 'View a Xiaoyuzhou podcast profile',
+    domain: 'www.xiaoyuzhoufm.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'id', positional: true, required: true, help: 'Podcast ID (from xiaoyuzhoufm.com URL)' }],
+    columns: ['title', 'author', 'description', 'subscribers', 'episodes', 'updated'],
+    func: async (_page, args) => {
+        const pageProps = await fetchPageProps(`/podcast/${args.id}`);
+        const p = pageProps.podcast;
+        if (!p)
+            throw new CliError('NOT_FOUND', 'Podcast not found', 'Please check the ID');
+        return [{
+                title: p.title,
+                author: p.author,
+                description: p.brief,
+                subscribers: p.subscriptionCount,
+                episodes: p.episodeCount,
+                updated: formatDate(p.latestEpisodePubDate),
+            }];
+    },
+});

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

@@ -0,0 +1,16 @@
+/**
+ * Shared Xiaoyuzhou utilities — page data extraction and formatting.
+ *
+ * Xiaoyuzhou (小宇宙) is a Next.js app that embeds full page data in
+ * <script id="__NEXT_DATA__">. We fetch the HTML and extract that JSON
+ * instead of using their authenticated API.
+ */
+/**
+ * Fetch a Xiaoyuzhou page and extract __NEXT_DATA__.props.pageProps.
+ * @param path - URL path, e.g. '/podcast/xxx' or '/episode/xxx'
+ */
+export declare function fetchPageProps(path: string): Promise<any>;
+/** Format seconds to mm:ss (e.g. 3890 → "64:50"). Returns '-' for invalid input. */
+export declare function formatDuration(seconds: number): string;
+/** Format ISO date string to YYYY-MM-DD. Returns '-' for missing input. */
+export declare function formatDate(iso: string): string;

package/dist/clis/xiaoyuzhou/utils.js

@@ -0,0 +1,55 @@
+/**
+ * Shared Xiaoyuzhou utilities — page data extraction and formatting.
+ *
+ * Xiaoyuzhou (小宇宙) is a Next.js app that embeds full page data in
+ * <script id="__NEXT_DATA__">. We fetch the HTML and extract that JSON
+ * instead of using their authenticated API.
+ */
+import { CliError } from '../../errors.js';
+/**
+ * Fetch a Xiaoyuzhou page and extract __NEXT_DATA__.props.pageProps.
+ * @param path - URL path, e.g. '/podcast/xxx' or '/episode/xxx'
+ */
+export async function fetchPageProps(path) {
+    const url = `https://www.xiaoyuzhoufm.com${path}`;
+    // Node.js fetch sends UA "node" which gets blocked; use a browser-like UA
+    const resp = await fetch(url, {
+        headers: { 'User-Agent': 'Mozilla/5.0 (compatible; opencli)' },
+    });
+    if (!resp.ok) {
+        throw new CliError('FETCH_ERROR', `HTTP ${resp.status} for ${path}`, 'Please check the ID — you can find it in xiaoyuzhoufm.com URLs');
+    }
+    const html = await resp.text();
+    // [\s\S]*? for multiline safety (JSON may span lines)
+    const match = html.match(/<script id="__NEXT_DATA__"[^>]*>([\s\S]*?)<\/script>/);
+    if (!match) {
+        throw new CliError('PARSE_ERROR', 'Failed to extract __NEXT_DATA__', 'Page structure may have changed');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(match[1]);
+    }
+    catch {
+        throw new CliError('PARSE_ERROR', 'Malformed __NEXT_DATA__ JSON', 'Page structure may have changed');
+    }
+    const pageProps = parsed.props?.pageProps;
+    if (!pageProps || Object.keys(pageProps).length === 0) {
+        throw new CliError('NOT_FOUND', 'Resource not found', 'Please check the ID — you can find it in xiaoyuzhoufm.com URLs');
+    }
+    return pageProps;
+}
+/** Format seconds to mm:ss (e.g. 3890 → "64:50"). Returns '-' for invalid input. */
+export function formatDuration(seconds) {
+    if (!Number.isFinite(seconds) || seconds < 0)
+        return '-';
+    seconds = Math.round(seconds);
+    const m = Math.floor(seconds / 60);
+    const s = seconds % 60;
+    return `${m}:${String(s).padStart(2, '0')}`;
+}
+/** Format ISO date string to YYYY-MM-DD. Returns '-' for missing input. */
+export function formatDate(iso) {
+    if (!iso)
+        return '-';
+    return iso.slice(0, 10);
+}

package/dist/clis/xiaoyuzhou/utils.test.d.ts

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

package/dist/clis/xiaoyuzhou/utils.test.js

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { formatDuration, formatDate, fetchPageProps } from './utils.js';
+describe('formatDuration', () => {
+    it('formats typical duration', () => {
+        expect(formatDuration(3890)).toBe('64:50');
+    });
+    it('formats zero seconds', () => {
+        expect(formatDuration(0)).toBe('0:00');
+    });
+    it('pads single-digit seconds', () => {
+        expect(formatDuration(65)).toBe('1:05');
+    });
+    it('formats exact minutes', () => {
+        expect(formatDuration(3600)).toBe('60:00');
+    });
+    it('rounds floating-point seconds', () => {
+        expect(formatDuration(3890.7)).toBe('64:51');
+    });
+    it('returns dash for NaN', () => {
+        expect(formatDuration(NaN)).toBe('-');
+    });
+    it('returns dash for negative', () => {
+        expect(formatDuration(-1)).toBe('-');
+    });
+});
+describe('formatDate', () => {
+    it('extracts YYYY-MM-DD from ISO string', () => {
+        expect(formatDate('2026-03-13T11:00:06.686Z')).toBe('2026-03-13');
+    });
+    it('handles date-only string', () => {
+        expect(formatDate('2025-01-01')).toBe('2025-01-01');
+    });
+    it('returns dash for undefined/empty', () => {
+        expect(formatDate('')).toBe('-');
+        expect(formatDate(undefined)).toBe('-');
+    });
+});
+describe('fetchPageProps', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('extracts pageProps from valid HTML', async () => {
+        const mockHtml = `<html><script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{"podcast":{"title":"Test"}}}}</script></html>`;
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            text: () => Promise.resolve(mockHtml),
+        }));
+        const result = await fetchPageProps('/podcast/abc123');
+        expect(result).toEqual({ podcast: { title: 'Test' } });
+    });
+    it('throws on HTTP error', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: false,
+            status: 404,
+            text: () => Promise.resolve('Not Found'),
+        }));
+        await expect(fetchPageProps('/podcast/invalid')).rejects.toThrow('HTTP 404');
+    });
+    it('throws when __NEXT_DATA__ is missing', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            text: () => Promise.resolve('<html><body>No data here</body></html>'),
+        }));
+        await expect(fetchPageProps('/podcast/abc')).rejects.toThrow('Failed to extract');
+    });
+    it('throws when pageProps is empty', async () => {
+        const mockHtml = `<script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{}}}</script>`;
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            text: () => Promise.resolve(mockHtml),
+        }));
+        await expect(fetchPageProps('/podcast/abc')).rejects.toThrow('Resource not found');
+    });
+    it('throws on malformed JSON in __NEXT_DATA__', async () => {
+        const mockHtml = `<script id="__NEXT_DATA__" type="application/json">{broken json</script>`;
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            text: () => Promise.resolve(mockHtml),
+        }));
+        await expect(fetchPageProps('/podcast/abc')).rejects.toThrow('Malformed __NEXT_DATA__');
+    });
+    it('handles multiline JSON in __NEXT_DATA__', async () => {
+        const mockHtml = `<script id="__NEXT_DATA__" type="application/json">
+{
+  "props": {
+    "pageProps": {
+      "episode": {"title": "Multiline Test"}
+    }
+  }
+}
+</script>`;
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            text: () => Promise.resolve(mockHtml),
+        }));
+        const result = await fetchPageProps('/episode/abc');
+        expect(result).toEqual({ episode: { title: 'Multiline Test' } });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "publishConfig": {
     "access": "public"
   },

package/src/clis/antigravity/README.md

@@ -0,0 +1,49 @@
+# Antigravity CLI Adapter
+
+🔥 **CLI All Electron Apps! The Most Powerful Update Has Arrived!** 🔥
+
+Turn ANY Electron application into a CLI tool! Recombine, script, and extend applications like Antigravity Ultra seamlessly. Now AI can control itself natively. Unlimited possibilities await!
+
+Turn your local Antigravity desktop application into a programmable AI node via Chrome DevTools Protocol (CDP). This allows you to compose complex LLM workflows entirely through the terminal by manipulating the actual UI natively, bypassing any API restrictions.
+
+## Prerequisites
+
+Start the Antigravity desktop app with the Chrome DevTools `remote-debugging-port` flag:
+
+\`\`\`bash
+# Start Antigravity in the background
+/Applications/Antigravity.app/Contents/MacOS/Electron \\
+  --remote-debugging-port=9224 \\
+  --remote-allow-origins="*"
+\`\`\`
+
+*(Note: Depending on your installation, the executable might be named differently, e.g., \`Antigravity\` instead of \`Electron\`.)*
+
+Next, set the target port in your terminal session to tell OpenCLI where to connect:
+
+\`\`\`bash
+export OPENCLI_CDP_ENDPOINT="http://127.0.0.1:9224"
+\`\`\`
+
+## Available Commands
+
+### \`opencli antigravity status\`
+Check the Chromium CDP connection. Returns the current window title and active internal URL.
+
+### \`opencli antigravity send <message>\`
+Send a text prompt to the AI. Automatically locates the Lexical editor input box, types the prompt securely, and hits Enter.
+
+### \`opencli antigravity read\`
+Scrape the entire current conversation history block as pure text. Useful for feeding the context to another script.
+
+### \`opencli antigravity new\`
+Click the "New Conversation" button to instantly clear the UI state and start fresh.
+
+### \`opencli antigravity extract-code\`
+Extract any multi-line code blocks from the current conversation view. Ideal for automated script extraction (e.g. \`opencli antigravity extract-code > script.sh\`).
+
+### \`opencli antigravity model <name>\`
+Quickly target and switch the active LLM engine. Example: \`opencli antigravity model claude\` or \`opencli antigravity model gemini\`.
+
+### \`opencli antigravity watch\`
+A long-running, streaming process that continuously polls the Antigravity UI for chat updates and outputs them in real-time to standard output.