@jackwener/opencli 1.0.3 → 1.0.5

package/src/clis/antigravity/serve.ts

@@ -0,0 +1,329 @@
+/**
+ * antigravity serve — Anthropic-compatible `/v1/messages` proxy server.
+ *
+ * Starts an HTTP server that accepts Anthropic Messages API requests,
+ * forwards them to a running Antigravity app via CDP, polls for the response,
+ * and returns it in Anthropic format.
+ *
+ * Usage:
+ *   OPENCLI_CDP_ENDPOINT=http://127.0.0.1:9224 opencli antigravity serve --port 8082
+ *   ANTHROPIC_BASE_URL=http://localhost:8082 claude
+ */
+
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import { CDPBridge } from '../../browser/cdp.js';
+import type { IPage } from '../../types.js';
+
+// ─── Types ───────────────────────────────────────────────────────────
+
+interface AnthropicRequest {
+  model?: string;
+  max_tokens?: number;
+  system?: string | Array<{ type: string; text: string }>;
+  messages: Array<{ role: string; content: string | Array<{ type: string; text?: string }> }>;
+  stream?: boolean;
+}
+
+interface AnthropicResponse {
+  id: string;
+  type: 'message';
+  role: 'assistant';
+  content: Array<{ type: 'text'; text: string }>;
+  model: string;
+  stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence';
+  stop_sequence: null;
+  usage: { input_tokens: number; output_tokens: number };
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────
+
+function generateMsgId(): string {
+  const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+  let id = 'msg_';
+  for (let i = 0; i < 24; i++) id += chars[Math.floor(Math.random() * chars.length)];
+  return id;
+}
+
+function estimateTokens(text: string): number {
+  // Rough approximation: ~4 chars per token for English, ~2 for CJK
+  return Math.max(1, Math.ceil(text.length / 3));
+}
+
+function extractTextContent(content: string | Array<{ type: string; text?: string }>): string {
+  if (typeof content === 'string') return content;
+  return content
+    .filter(b => b.type === 'text' && b.text)
+    .map(b => b.text!)
+    .join('\n');
+}
+
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on('data', (c: Buffer) => chunks.push(c));
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+    req.on('error', reject);
+  });
+}
+
+function jsonResponse(res: ServerResponse, status: number, data: unknown): void {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    'Content-Type': 'application/json',
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, x-api-key, anthropic-version, Authorization',
+  });
+  res.end(body);
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// ─── Antigravity CDP Operations ──────────────────────────────────────
+
+async function getConversationText(page: IPage): Promise<string> {
+  const text = await page.evaluate(`
+    (() => {
+      const container = document.getElementById('conversation');
+      return container ? container.innerText : '';
+    })()
+  `);
+  return String(text ?? '');
+}
+
+async function sendMessage(page: IPage, message: string): Promise<void> {
+  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(message)});
+    })()
+  `);
+  await sleep(500);
+  await page.pressKey('Enter');
+}
+
+async function waitForReply(
+  page: IPage,
+  beforeText: string,
+  opts: { timeout?: number; pollInterval?: number; stableThreshold?: number } = {},
+): Promise<string> {
+  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;
+  let lastText = beforeText;
+  let stableCount = 0;
+
+  // Wait a bit for the model to start generating
+  await sleep(1000);
+
+  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();
+        }
+      } else {
+        // Still generating
+        stableCount = 0;
+        lastText = current;
+      }
+    }
+
+    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: AnthropicRequest,
+  page: IPage,
+): Promise<AnthropicResponse> {
+  // Extract the last user message
+  const userMessages = body.messages.filter(m => m.role === 'user');
+  if (userMessages.length === 0) {
+    throw new Error('No user message found in request');
+  }
+  const lastUserMsg = userMessages[userMessages.length - 1];
+  const userText = extractTextContent(lastUserMsg.content);
+
+  if (!userText.trim()) {
+    throw new Error('Empty user message');
+  }
+
+  // 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
+  console.error('[serve] Waiting for reply...');
+  const replyText = await waitForReply(page, beforeText);
+  console.error(`[serve] Got reply: "${replyText.slice(0, 80)}${replyText.length > 80 ? '...' : ''}"`);
+
+  return {
+    id: generateMsgId(),
+    type: 'message',
+    role: 'assistant',
+    content: [{ type: 'text', text: replyText }],
+    model: body.model ?? 'antigravity',
+    stop_reason: 'end_turn',
+    stop_sequence: null,
+    usage: {
+      input_tokens: estimateTokens(userText),
+      output_tokens: estimateTokens(replyText),
+    },
+  };
+}
+
+// ─── Server ──────────────────────────────────────────────────────────
+
+export async function startServe(opts: { port?: number } = {}): Promise<void> {
+  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).`);
+
+  let requestInFlight = false;
+
+  const server = createServer(async (req, res) => {
+    // CORS preflight
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204, {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, x-api-key, anthropic-version, Authorization',
+      });
+      res.end();
+      return;
+    }
+
+    const url = req.url ?? '/';
+    const pathname = url.split('?')[0];
+
+    try {
+      // GET /v1/models — return available models
+      if (req.method === 'GET' && pathname === '/v1/models') {
+        jsonResponse(res, 200, {
+          data: [
+            {
+              id: 'antigravity',
+              object: 'model',
+              created: Math.floor(Date.now() / 1000),
+              owned_by: 'antigravity',
+            },
+          ],
+        });
+        return;
+      }
+
+      // POST /v1/messages — main endpoint
+      if (req.method === 'POST' && pathname === '/v1/messages') {
+        if (requestInFlight) {
+          jsonResponse(res, 429, {
+            type: 'error',
+            error: {
+              type: 'rate_limit_error',
+              message: 'Another request is currently being processed. Antigravity can only handle one request at a time.',
+            },
+          });
+          return;
+        }
+
+        requestInFlight = true;
+        try {
+          const rawBody = await readBody(req);
+          const body = JSON.parse(rawBody) as AnthropicRequest;
+
+          if (body.stream) {
+            // We don't support streaming — return error
+            jsonResponse(res, 400, {
+              type: 'error',
+              error: {
+                type: 'invalid_request_error',
+                message: 'Streaming is not supported. Set "stream": false.',
+              },
+            });
+            return;
+          }
+
+          const response = await handleMessages(body, page);
+          jsonResponse(res, 200, response);
+        } finally {
+          requestInFlight = false;
+        }
+        return;
+      }
+
+      // Health check
+      if (req.method === 'GET' && (pathname === '/' || pathname === '/health')) {
+        jsonResponse(res, 200, { ok: true, status: 'connected' });
+        return;
+      }
+
+      jsonResponse(res, 404, {
+        type: 'error',
+        error: { type: 'not_found_error', message: `Not found: ${pathname}` },
+      });
+    } catch (err) {
+      console.error('[serve] Error:', err);
+      jsonResponse(res, 500, {
+        type: 'error',
+        error: {
+          type: 'api_error',
+          message: err instanceof Error ? err.message : 'Internal server error',
+        },
+      });
+    }
+  });
+
+  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(`\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(() => {});
+    server.close();
+    process.exit(0);
+  };
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', shutdown);
+
+  // Keep alive
+  await new Promise(() => {});
+}

package/src/clis/bilibili/download.ts

@@ -17,6 +17,7 @@ import {
   sanitizeFilename,
   getTempDir,
   exportCookiesToNetscape,
+  formatCookieHeader,
 } from '../../download/index.js';
 import { DownloadProgressTracker, formatBytes } from '../../download/progress.js';
 
@@ -63,30 +64,18 @@ cli({
     const title = sanitizeFilename(data?.title || 'video');
 
     // Extract cookies for authenticated downloads
-    const cookieString = await page.evaluate(`(() => document.cookie)()`);
+    const cookies = await page.getCookies({ domain: 'bilibili.com' });
+    const cookieString = formatCookieHeader(cookies);
 
     // Create output directory
     fs.mkdirSync(output, { recursive: true });
 
     // Export cookies to Netscape format for yt-dlp
     let cookiesFile: string | undefined;
-    if (typeof cookieString === 'string' && cookieString) {
+    if (cookies.length > 0) {
       const tempDir = getTempDir();
       fs.mkdirSync(tempDir, { recursive: true });
       cookiesFile = path.join(tempDir, `bilibili_cookies_${Date.now()}.txt`);
-
-      const cookies = cookieString.split(';').map((c) => {
-        const [name, ...rest] = c.trim().split('=');
-        return {
-          name: name || '',
-          value: rest.join('=') || '',
-          domain: '.bilibili.com',
-          path: '/',
-          secure: true,
-          httpOnly: false,
-        };
-      }).filter((c) => c.name);
-
       exportCookiesToNetscape(cookies, cookiesFile);
     }
 

package/src/clis/boss/resume.ts

@@ -0,0 +1,262 @@
+/**
+ * BOSS直聘 resume — view candidate resume/profile via chat page UI scraping (boss side).
+ *
+ * Flow: navigate to chat page → click on candidate → scrape the right panel info.
+ * The chat page loads candidate basic info, work experience, and education
+ * in the right panel when a candidate is selected.
+ *
+ * HTML structure (right panel):
+ *  .base-info-single-detial → name, gender, age, experience, degree
+ *  .experience-content.time-list → time ranges (icon-base-info-work / icon-base-info-edu)
+ *  .experience-content.detail-list → details (company·position / school·major·degree)
+ *  .position-content → job being discussed + expectation
+ */
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'boss',
+  name: 'resume',
+  description: 'BOSS直聘查看候选人简历（招聘端）',
+  domain: 'www.zhipin.com',
+  strategy: Strategy.COOKIE,
+
+  browser: true,
+  args: [
+    { name: 'uid', required: true, help: 'Encrypted UID of the candidate (from chatlist)' },
+  ],
+  columns: [
+    'name', 'gender', 'age', 'experience', 'degree', 'active_time',
+    'work_history', 'education',
+    'job_chatting', 'expect',
+  ],
+  func: async (page: IPage | null, kwargs) => {
+    if (!page) throw new Error('Browser page required');
+
+    const uid = kwargs.uid;
+
+    // Step 1: Navigate to chat page
+    await page.goto('https://www.zhipin.com/web/chat/index');
+    await page.wait({ time: 3 });
+
+    // Step 2: Get friend list to find candidate's numeric uid
+    const friendData: any = await page.evaluate(`
+      async () => {
+        return new Promise((resolve, reject) => {
+          const xhr = new XMLHttpRequest();
+          xhr.open('GET', 'https://www.zhipin.com/wapi/zprelation/friend/getBossFriendListV2.json?page=1&status=0&jobId=0', true);
+          xhr.withCredentials = true;
+          xhr.timeout = 15000;
+          xhr.setRequestHeader('Accept', 'application/json');
+          xhr.onload = () => { try { resolve(JSON.parse(xhr.responseText)); } catch(e) { reject(e); } };
+          xhr.onerror = () => reject(new Error('Network Error'));
+          xhr.send();
+        });
+      }
+    `);
+
+    if (friendData.code !== 0) {
+      if (friendData.code === 7 || friendData.code === 37) {
+        throw new Error('Cookie 已过期！请在当前 Chrome 浏览器中重新登录 BOSS 直聘。');
+      }
+      throw new Error('获取好友列表失败: ' + (friendData.message || friendData.code));
+    }
+
+    let friend: any = null;
+    const allFriends = friendData.zpData?.friendList || [];
+    friend = allFriends.find((f: any) => f.encryptUid === uid);
+
+    if (!friend) {
+      for (let p = 2; p <= 5; p++) {
+        const moreUrl = `https://www.zhipin.com/wapi/zprelation/friend/getBossFriendListV2.json?page=${p}&status=0&jobId=0`;
+        const moreData: any = await page.evaluate(`
+          async () => {
+            return new Promise((resolve, reject) => {
+              const xhr = new XMLHttpRequest();
+              xhr.open('GET', '${moreUrl}', true);
+              xhr.withCredentials = true;
+              xhr.timeout = 15000;
+              xhr.setRequestHeader('Accept', 'application/json');
+              xhr.onload = () => { try { resolve(JSON.parse(xhr.responseText)); } catch(e) { reject(e); } };
+              xhr.onerror = () => reject(new Error('Network Error'));
+              xhr.send();
+            });
+          }
+        `);
+        if (moreData.code === 0) {
+          const list = moreData.zpData?.friendList || [];
+          friend = list.find((f: any) => f.encryptUid === uid);
+          if (friend) break;
+          if (list.length === 0) break;
+        }
+      }
+    }
+
+    if (!friend) throw new Error('未找到该候选人，请确认 uid 是否正确');
+
+    const numericUid = friend.uid;
+
+    // Step 3: Click on candidate in chat list
+    const clicked: any = await page.evaluate(`
+      async () => {
+        const item = document.querySelector('#_${numericUid}-0') || document.querySelector('[id^="_${numericUid}"]');
+        if (item) {
+          item.click();
+          return { clicked: true };
+        }
+        const items = document.querySelectorAll('.geek-item');
+        for (const el of items) {
+          if (el.id && el.id.startsWith('_${numericUid}')) {
+            el.click();
+            return { clicked: true };
+          }
+        }
+        return { clicked: false };
+      }
+    `);
+
+    if (!clicked.clicked) {
+      throw new Error('无法在聊天列表中找到该用户，请确认聊天列表中有此人');
+    }
+
+    // Step 4: Wait for right panel to load
+    await page.wait({ time: 2 });
+
+    // Step 5: Scrape the right panel
+    const resumeInfo: any = await page.evaluate(`
+      (() => {
+        const container = document.querySelector('.base-info-single-container') || document.querySelector('.base-info-content');
+        if (!container) return { error: 'no container found' };
+
+        // === Basic Info ===
+        const nameEl = container.querySelector('.base-name');
+        const name = nameEl ? nameEl.textContent.trim() : '';
+
+        // Gender
+        let gender = '';
+        const detailDiv = container.querySelector('.base-info-single-detial');
+        if (detailDiv) {
+          const uses = detailDiv.querySelectorAll('use');
+          for (const u of uses) {
+            const href = u.getAttribute('xlink:href') || u.getAttribute('href') || '';
+            if (href.includes('icon-men')) { gender = '男'; break; }
+            if (href.includes('icon-women')) { gender = '女'; break; }
+          }
+        }
+
+        // Active time
+        const activeEl = container.querySelector('.active-time');
+        const activeTime = activeEl ? activeEl.textContent.trim() : '';
+
+        // Age, experience, degree — direct child divs of .base-info-single-detial
+        let age = '', experience = '', degree = '';
+        if (detailDiv) {
+          for (const el of detailDiv.children) {
+            if (el.classList.contains('name-contet') || el.classList.contains('high-light-orange') ||
+                el.classList.contains('resume-btn-content') || el.classList.contains('label-remark-content') ||
+                el.classList.contains('base-info-item')) continue;
+            const text = el.textContent.trim();
+            if (!text) continue;
+            if (text.match(/\\d+岁/)) age = text;
+            else if (text.match(/年|经验|应届/)) experience = text;
+            else if (['博士', '硕士', '本科', '大专', '高中', '中专', '中技', '初中'].some(d => text.includes(d))) degree = text;
+          }
+        }
+
+        // === Work & Education ===
+        // Structure: two .experience-content divs
+        //   1. .time-list → <li> items with icon (work/edu) and time span
+        //   2. .detail-list → <li> items with icon (work/edu) and detail text
+        // Each <li> has a <use> with xlink:href "#icon-base-info-work" or "#icon-base-info-edu"
+
+        const workTimes = [];
+        const eduTimes = [];
+        const workDetails = [];
+        const eduDetails = [];
+
+        const timeList = container.querySelector('.experience-content.time-list');
+        if (timeList) {
+          const lis = timeList.querySelectorAll('li');
+          for (const li of lis) {
+            const useEl = li.querySelector('use');
+            const href = useEl ? (useEl.getAttribute('xlink:href') || useEl.getAttribute('href') || '') : '';
+            const timeSpan = li.querySelector('.time');
+            const timeText = timeSpan ? timeSpan.textContent.trim() : li.textContent.trim();
+            if (href.includes('base-info-edu')) {
+              eduTimes.push(timeText);
+            } else {
+              workTimes.push(timeText);
+            }
+          }
+        }
+
+        const detailList = container.querySelector('.experience-content.detail-list');
+        if (detailList) {
+          const lis = detailList.querySelectorAll('li');
+          for (const li of lis) {
+            const useEl = li.querySelector('use');
+            const href = useEl ? (useEl.getAttribute('xlink:href') || useEl.getAttribute('href') || '') : '';
+            const valueSpan = li.querySelector('.value');
+            const valueText = valueSpan ? valueSpan.textContent.trim() : li.textContent.trim();
+            if (href.includes('base-info-edu')) {
+              eduDetails.push(valueText);
+            } else {
+              workDetails.push(valueText);
+            }
+          }
+        }
+
+        // Combine times and details
+        const workHistory = [];
+        for (let i = 0; i < Math.max(workTimes.length, workDetails.length); i++) {
+          const parts = [];
+          if (workTimes[i]) parts.push(workTimes[i]);
+          if (workDetails[i]) parts.push(workDetails[i]);
+          if (parts.length) workHistory.push(parts.join('  '));
+        }
+
+        const education = [];
+        for (let i = 0; i < Math.max(eduTimes.length, eduDetails.length); i++) {
+          const parts = [];
+          if (eduTimes[i]) parts.push(eduTimes[i]);
+          if (eduDetails[i]) parts.push(eduDetails[i]);
+          if (parts.length) education.push(parts.join('  '));
+        }
+
+        // === Job Chatting & Expect ===
+        const positionContent = container.querySelector('.position-content');
+        let jobChatting = '', expect = '';
+        if (positionContent) {
+          const posNameEl = positionContent.querySelector('.position-name');
+          if (posNameEl) jobChatting = posNameEl.textContent.trim();
+
+          const expectEl = positionContent.querySelector('.position-item.expect .value');
+          if (expectEl) expect = expectEl.textContent.trim();
+        }
+
+        return {
+          name, gender, age, experience, degree, activeTime,
+          workHistory, education,
+          jobChatting, expect,
+        };
+      })()
+    `);
+
+    if (resumeInfo.error) {
+      throw new Error('无法获取简历面板: ' + resumeInfo.error);
+    }
+
+    return [{
+      name: resumeInfo.name || friend.name || '',
+      gender: resumeInfo.gender || '',
+      age: resumeInfo.age || '',
+      experience: resumeInfo.experience || '',
+      degree: resumeInfo.degree || '',
+      active_time: resumeInfo.activeTime || '',
+      work_history: (resumeInfo.workHistory || []).join('\\n') || '(未获取到)',
+      education: (resumeInfo.education || []).join('\\n') || '(未获取到)',
+      job_chatting: resumeInfo.jobChatting || '',
+      expect: resumeInfo.expect || '',
+    }];
+  },
+});