@jackwener/opencli 1.1.0 → 1.1.1

package/src/clis/bloomberg/utils.ts

@@ -0,0 +1,429 @@
+import { CliError } from '../../errors.js';
+
+export const BLOOMBERG_FEEDS = {
+  main: 'https://feeds.bloomberg.com/news.rss',
+  markets: 'https://feeds.bloomberg.com/markets/news.rss',
+  economics: 'https://feeds.bloomberg.com/economics/news.rss',
+  industries: 'https://feeds.bloomberg.com/industries/news.rss',
+  tech: 'https://feeds.bloomberg.com/technology/news.rss',
+  politics: 'https://feeds.bloomberg.com/politics/news.rss',
+  businessweek: 'https://feeds.bloomberg.com/businessweek/news.rss',
+  opinions: 'https://feeds.bloomberg.com/bview/news.rss',
+} as const;
+
+const DEFAULT_USER_AGENT = 'Mozilla/5.0 (compatible; opencli)';
+
+export type BloombergFeedName = keyof typeof BLOOMBERG_FEEDS;
+
+export interface BloombergFeedItem {
+  title: string;
+  summary: string;
+  link: string;
+  mediaLinks: string[];
+}
+
+export interface BloombergStory {
+  headline?: string;
+  summary?: string;
+  url?: string;
+  body?: any;
+  lede?: any;
+  ledeImageUrl?: string;
+  socialImageUrl?: string;
+  imageAttachments?: Record<string, any>;
+  videoAttachments?: Record<string, any>;
+}
+
+export async function fetchBloombergFeed(name: BloombergFeedName, limit: number = 1): Promise<BloombergFeedItem[]> {
+  const feedUrl = BLOOMBERG_FEEDS[name];
+  if (!feedUrl) {
+    throw new CliError('ARGUMENT', `Unknown Bloomberg feed: ${name}`);
+  }
+
+  const resp = await fetch(feedUrl, {
+    headers: { 'User-Agent': DEFAULT_USER_AGENT },
+  });
+
+  if (!resp.ok) {
+    throw new CliError(
+      'FETCH_ERROR',
+      `Bloomberg RSS HTTP ${resp.status}`,
+      'Bloomberg may be temporarily unavailable; try again later.',
+    );
+  }
+
+  const xml = await resp.text();
+  const items = parseBloombergRss(xml);
+  if (!items.length) {
+    throw new CliError(
+      'NOT_FOUND',
+      'Bloomberg RSS feed returned no items',
+      'Bloomberg may have changed the feed format.',
+    );
+  }
+
+  const count = Math.max(1, Math.min(Number(limit) || 1, 20));
+  return items.slice(0, count);
+}
+
+export function parseBloombergRss(xml: string): BloombergFeedItem[] {
+  const items: BloombergFeedItem[] = [];
+  const itemRegex = /<item\b[^>]*>([\s\S]*?)<\/item>/gi;
+  let match: RegExpExecArray | null;
+
+  while ((match = itemRegex.exec(xml))) {
+    const block = match[1];
+    const title = extractTagText(block, 'title');
+    const summary = extractTagText(block, 'description');
+    const link = extractTagText(block, 'link') || extractTagText(block, 'guid');
+    const mediaLinks = extractMediaLinksFromRssItem(block);
+
+    if (!title || !link) continue;
+    items.push({
+      title,
+      summary,
+      link,
+      mediaLinks,
+    });
+  }
+
+  return items;
+}
+
+export function normalizeBloombergLink(input: string): string {
+  const raw = String(input || '').trim();
+  if (!raw) {
+    throw new CliError('ARGUMENT', 'A Bloomberg link is required');
+  }
+  if (raw.startsWith('/')) return `https://www.bloomberg.com${raw}`;
+  return raw;
+}
+
+export function validateBloombergLink(input: string): string {
+  const normalized = normalizeBloombergLink(input);
+  let url: URL;
+  try {
+    url = new URL(normalized);
+  } catch {
+    throw new CliError(
+      'ARGUMENT',
+      `Invalid Bloomberg link: ${input}`,
+      'Pass a full https://www.bloomberg.com/... URL or a relative Bloomberg path.',
+    );
+  }
+
+  if (!/(?:\.|^)bloomberg\.com$/i.test(url.hostname)) {
+    throw new CliError(
+      'ARGUMENT',
+      `Expected a bloomberg.com link, got: ${url.hostname}`,
+      'Pass a Bloomberg article URL from bloomberg.com.',
+    );
+  }
+
+  return url.toString();
+}
+
+export function renderStoryBody(body: any): string {
+  const blocks = Array.isArray(body?.content) ? body.content : [];
+  const parts = blocks
+    .map((block: any) => renderBlock(block, 0))
+    .map((part: string) => normalizeBlockText(part))
+    .filter(Boolean);
+
+  return parts.join('\n\n').replace(/\n{3,}/g, '\n\n').trim();
+}
+
+export function extractStoryMediaLinks(story: BloombergStory): string[] {
+  const urls = new Set<string>();
+  collectMediaUrls(story?.ledeImageUrl, urls);
+  collectMediaUrls(story?.socialImageUrl, urls);
+  collectMediaUrls(story?.lede, urls);
+  collectMediaUrls(story?.imageAttachments, urls);
+  collectMediaUrls(story?.videoAttachments, urls);
+
+  const mediaBlocks = Array.isArray(story?.body?.content)
+    ? story.body.content.filter((block: any) => block?.type === 'media')
+    : [];
+  collectMediaUrls(mediaBlocks, urls);
+
+  return [...urls];
+}
+
+function renderBlock(block: any, depth: number): string {
+  if (!block || typeof block !== 'object') return '';
+
+  switch (block.type) {
+    case 'paragraph':
+      return renderInlineNodes(block.content || []);
+    case 'heading': {
+      const text = renderInlineNodes(block.content || []);
+      if (!text) return '';
+      const level = Number(block.data?.level ?? block.data?.weight ?? 2);
+      const prefix = level <= 1 ? '# ' : level === 2 ? '## ' : '### ';
+      return `${prefix}${text}`;
+    }
+    case 'blockquote': {
+      const text = renderInlineNodes(block.content || []);
+      if (!text) return '';
+      return text.split('\n').map((line: string) => line ? `> ${line}` : '>').join('\n');
+    }
+    case 'list':
+      return renderListBlock(block, depth);
+    case 'tabularData':
+      return renderTabularDataBlock(block);
+    case 'media':
+      return renderMediaBlock(block);
+    case 'inline-newsletter':
+    case 'newsletter':
+    case 'ad':
+      return '';
+    default: {
+      if (Array.isArray(block.content) && block.content.length > 0) {
+        const inlineText = renderInlineNodes(block.content);
+        if (inlineText) return inlineText;
+        const nested = block.content.map((child: any) => renderBlock(child, depth + 1)).filter(Boolean);
+        if (nested.length) return nested.join('\n');
+      }
+      return extractGenericText(block);
+    }
+  }
+}
+
+function renderInlineNodes(nodes: any[]): string {
+  return nodes.map((node) => renderInlineNode(node)).join('');
+}
+
+function renderInlineNode(node: any): string {
+  if (node == null) return '';
+  if (typeof node === 'string') return decodeXmlEntities(node);
+
+  switch (node.type) {
+    case 'text':
+      return decodeXmlEntities(node.value || '');
+    case 'linebreak':
+      return '\n';
+    case 'link':
+    case 'entity':
+    case 'strong':
+    case 'emphasis':
+    case 'italic':
+    case 'underline':
+    case 'span':
+      if (Array.isArray(node.content) && node.content.length > 0) {
+        return renderInlineNodes(node.content);
+      }
+      return decodeXmlEntities(node.value || '');
+    default:
+      if (Array.isArray(node.content) && node.content.length > 0) {
+        return renderInlineNodes(node.content);
+      }
+      if (typeof node.value === 'string') return decodeXmlEntities(node.value);
+      return '';
+  }
+}
+
+function renderListBlock(block: any, depth: number): string {
+  const items = Array.isArray(block.content) ? block.content : [];
+  if (!items.length) return '';
+
+  const listStyle = String(block.subType || block.data?.style || block.data?.listType || '');
+  const ordered = /\bordered\b|\bnumber(?:ed)?\b/i.test(listStyle);
+  let index = 1;
+
+  return items
+    .map((item: any) => {
+      const prefix = ordered ? `${index++}. ` : '- ';
+      return renderListItem(item, prefix, depth);
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+function renderListItem(item: any, prefix: string, depth: number): string {
+  const indent = '  '.repeat(depth);
+  const body = normalizeBlockText(renderListItemBody(item, depth + 1));
+  if (!body) return '';
+
+  const lines = body.split('\n');
+  const head = `${indent}${prefix}${lines[0]}`;
+  if (lines.length === 1) return head;
+
+  const continuationIndent = `${indent}${' '.repeat(prefix.length)}`;
+  const tail = lines.slice(1).map((line) => `${continuationIndent}${line}`).join('\n');
+  return `${head}\n${tail}`;
+}
+
+function renderListItemBody(item: any, depth: number): string {
+  if (!item || typeof item !== 'object') return '';
+
+  if (item.type === 'list-item' && Array.isArray(item.content)) {
+    const parts = item.content
+      .map((child: any) => child?.type === 'paragraph'
+        ? renderInlineNodes(child.content || [])
+        : renderBlock(child, depth))
+      .map((part: string) => normalizeBlockText(part))
+      .filter(Boolean);
+    return parts.join('\n');
+  }
+
+  return renderBlock(item, depth);
+}
+
+function renderTabularDataBlock(block: any): string {
+  const rows = block?.data?.rows ?? block?.data?.table?.rows ?? block?.content;
+  if (!Array.isArray(rows) || !rows.length) {
+    return extractGenericText(block.data || block.content || block);
+  }
+
+  const lines = rows
+    .map((row: any) => extractGenericText(row))
+    .map((line) => normalizeBlockText(line))
+    .filter(Boolean);
+
+  return lines.join('\n');
+}
+
+function renderMediaBlock(block: any): string {
+  const candidates = [
+    block?.data?.chart?.caption,
+    block?.data?.attachment?.caption,
+    block?.data?.attachment?.title,
+    block?.data?.attachment?.subtitle,
+    block?.data?.video?.caption,
+  ];
+
+  const caption = candidates
+    .map((value) => normalizeBlockText(stripHtml(String(value || ''))))
+    .find(Boolean);
+
+  return caption || '';
+}
+
+function extractGenericText(value: any): string {
+  const parts: string[] = [];
+  collectText(value, parts);
+  return parts.join(' ').replace(/\s+/g, ' ').trim();
+}
+
+function collectText(value: any, out: string[]): void {
+  if (value == null) return;
+  if (typeof value === 'string') {
+    const text = normalizeBlockText(stripHtml(decodeXmlEntities(value)));
+    if (text) out.push(text);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectText(item, out);
+    return;
+  }
+  if (typeof value === 'object') {
+    if (typeof value.value === 'string') {
+      const text = normalizeBlockText(stripHtml(decodeXmlEntities(value.value)));
+      if (text) out.push(text);
+      return;
+    }
+    if (Array.isArray(value.content)) {
+      collectText(value.content, out);
+      return;
+    }
+    for (const entry of Object.values(value)) collectText(entry, out);
+  }
+}
+
+function extractTagText(block: string, tag: string): string {
+  const safeTag = escapeRegExp(tag);
+  const match = block.match(new RegExp(`<${safeTag}(?:\\s[^>]*)?>([\\s\\S]*?)<\\/${safeTag}>`, 'i'));
+  if (!match) return '';
+  return normalizeBlockText(stripHtml(decodeXmlEntities(stripCdata(match[1]))));
+}
+
+function extractMediaLinksFromRssItem(block: string): string[] {
+  const links = new Set<string>();
+  const mediaRegex = /<(?:media:content|media:thumbnail|enclosure)\b[^>]*\burl="([^"]+)"[^>]*>/gi;
+  let match: RegExpExecArray | null;
+  while ((match = mediaRegex.exec(block))) {
+    const url = decodeXmlEntities(match[1] || '').trim();
+    if (url) links.add(url);
+  }
+  return [...links];
+}
+
+function collectMediaUrls(value: any, out: Set<string>, seen = new WeakSet<object>()): void {
+  if (value == null) return;
+
+  if (typeof value === 'string') {
+    const normalized = normalizeMediaUrl(value);
+    if (normalized) out.add(normalized);
+    return;
+  }
+
+  if (Array.isArray(value)) {
+    for (const item of value) collectMediaUrls(item, out, seen);
+    return;
+  }
+
+  if (typeof value === 'object') {
+    if (seen.has(value)) return;
+    seen.add(value);
+
+    for (const key of ['url', 'src', 'fallback', 'poster']) {
+      const candidate = (value as Record<string, any>)[key];
+      if (typeof candidate === 'string') {
+        const normalized = normalizeMediaUrl(candidate);
+        if (normalized) out.add(normalized);
+      }
+    }
+
+    for (const entry of Object.values(value)) {
+      collectMediaUrls(entry, out, seen);
+    }
+  }
+}
+
+function normalizeMediaUrl(value: string): string | null {
+  const url = decodeXmlEntities(String(value || '')).trim();
+  if (!/^https?:\/\//i.test(url)) return null;
+  if (!looksLikeMediaUrl(url)) return null;
+  return url;
+}
+
+function looksLikeMediaUrl(url: string): boolean {
+  return /(?:assets\.bwbx\.io|resource\.bloomberg\.com|media\.bloomberg\.com)/i.test(url)
+    || /\.(?:jpg|jpeg|png|webp|gif|svg|mp4|m3u8)(?:[?#].*)?$/i.test(url);
+}
+
+function stripCdata(value: string): string {
+  const match = value.match(/^<!\[CDATA\[([\s\S]*?)\]\]>$/);
+  return match ? match[1] : value;
+}
+
+function stripHtml(value: string): string {
+  return String(value || '').replace(/<[^>]+>/g, ' ');
+}
+
+function decodeXmlEntities(value: string): string {
+  return String(value || '')
+    .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1')
+    .replace(/&#(\d+);/g, (_m, code) => String.fromCodePoint(Number(code)))
+    .replace(/&#x([0-9a-f]+);/gi, (_m, code) => String.fromCodePoint(parseInt(code, 16)))
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&apos;/g, "'")
+    .replace(/&nbsp;/g, ' ');
+}
+
+function normalizeBlockText(value: string): string {
+  return String(value || '')
+    .replace(/\r/g, '')
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n[ \t]+/g, '\n')
+    .replace(/[ \t]{2,}/g, ' ')
+    .trim();
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/clis/boss/batchgreet.ts

@@ -15,7 +15,7 @@ cli({
   strategy: Strategy.COOKIE,
   browser: true,
   args: [
-    { name: 'job_id', default: '', help: 'Filter by encrypted job ID (greet all jobs if empty)' },
+    { name: 'job-id', default: '', help: 'Filter by encrypted job ID (greet all jobs if empty)' },
     { name: 'limit', type: 'int', default: 5, help: 'Max candidates to greet' },
     { name: 'text', default: '', help: 'Custom greeting message (uses default if empty)' },
   ],
@@ -23,7 +23,7 @@ cli({
   func: async (page: IPage | null, kwargs) => {
     if (!page) throw new Error('Browser page required');
 
-    const filterJobId = kwargs.job_id || '';
+    const filterJobId = kwargs['job-id'] || '';
     const limit = kwargs.limit || 5;
     const text = kwargs.text || '你好，请问您对这个职位感兴趣吗？';
 

package/src/clis/boss/chatlist.ts

@@ -11,14 +11,14 @@ cli({
   args: [
     { name: 'page', type: 'int', default: 1, help: 'Page number' },
     { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
-    { name: 'job_id', default: '0', help: 'Filter by job ID (0=all)' },
+    { name: 'job-id', default: '0', help: 'Filter by job ID (0=all)' },
   ],
   columns: ['name', 'job', 'last_msg', 'last_time', 'uid', 'security_id'],
   func: async (page: IPage | null, kwargs) => {
     if (!page) throw new Error('Browser page required');
     await page.goto('https://www.zhipin.com/web/chat/index');
     await page.wait({ time: 2 });
-    const jobId = kwargs.job_id || '0';
+    const jobId = kwargs['job-id'] || '0';
     const pageNum = kwargs.page || 1;
     const limit = kwargs.limit || 20;
     const targetUrl = `https://www.zhipin.com/wapi/zprelation/friend/getBossFriendListV2.json?page=${pageNum}&status=0&jobId=${jobId}`;

package/src/clis/boss/detail.ts

@@ -16,7 +16,7 @@ cli({
 
   browser: true,
   args: [
-    { name: 'security_id', required: true, help: 'Security ID from search results (securityId field)' },
+    { name: 'security-id', required: true, help: 'Security ID from search results (securityId field)' },
   ],
   columns: [
     'name', 'salary', 'experience', 'degree', 'city', 'district',
@@ -28,7 +28,7 @@ cli({
   func: async (page: IPage | null, kwargs) => {
     if (!page) throw new Error('Browser page required');
 
-    const securityId = kwargs.security_id;
+    const securityId = kwargs['security-id'];
 
     // Navigate to zhipin.com first to establish cookie context (referrer + cookies)
     await page.goto('https://www.zhipin.com/web/geek/job');

package/src/clis/boss/greet.ts

@@ -20,8 +20,8 @@ cli({
   browser: true,
   args: [
     { name: 'uid', required: true, help: 'Encrypted UID of the candidate (from recommend)' },
-    { name: 'security_id', required: true, help: 'Security ID of the candidate' },
-    { name: 'job_id', required: true, help: 'Encrypted job ID' },
+    { name: 'security-id', required: true, help: 'Security ID of the candidate' },
+    { name: 'job-id', required: true, help: 'Encrypted job ID' },
     { name: 'text', default: '', help: 'Custom greeting message (uses default template if empty)' },
   ],
   columns: ['status', 'detail'],
@@ -29,8 +29,8 @@ cli({
     if (!page) throw new Error('Browser page required');
 
     const uid = kwargs.uid;
-    const securityId = kwargs.security_id;
-    const jobId = kwargs.job_id;
+    const securityId = kwargs['security-id'];
+    const jobId = kwargs['job-id'];
     const text = kwargs.text;
 
     if (process.env.OPENCLI_VERBOSE) {

package/src/clis/boss/search.ts

@@ -72,7 +72,7 @@ cli({
 
   browser: true,
   args: [
-    { name: 'query', required: true, help: 'Search keyword (e.g. AI agent, 前端)' },
+    { name: 'query', required: true, positional: true, help: 'Search keyword (e.g. AI agent, 前端)' },
     { name: 'city', default: '北京', help: 'City name or code (e.g. 杭州, 上海, 101010100)' },
     { name: 'experience', default: '', help: 'Experience: 应届/1年以内/1-3年/3-5年/5-10年/10年以上' },
     { name: 'degree', default: '', help: 'Degree: 大专/本科/硕士/博士' },

package/src/clis/boss/send.ts

@@ -17,7 +17,7 @@ cli({
   browser: true,
   args: [
     { name: 'uid', required: true, help: 'Encrypted UID of the candidate (from chatlist)' },
-    { name: 'text', required: true, help: 'Message text to send' },
+    { name: 'text', required: true, positional: true, help: 'Message text to send' },
   ],
   columns: ['status', 'detail'],
   func: async (page: IPage | null, kwargs) => {

package/src/clis/boss/stats.ts

@@ -17,13 +17,13 @@ cli({
   strategy: Strategy.COOKIE,
   browser: true,
   args: [
-    { name: 'job_id', default: '', help: 'Encrypted job ID (show all if empty)' },
+    { name: 'job-id', default: '', help: 'Encrypted job ID (show all if empty)' },
   ],
   columns: ['job_name', 'salary', 'city', 'status', 'total_chats', 'encrypt_job_id'],
   func: async (page: IPage | null, kwargs) => {
     if (!page) throw new Error('Browser page required');
 
-    const filterJobId = kwargs.job_id || '';
+    const filterJobId = kwargs['job-id'] || '';
 
     if (process.env.OPENCLI_VERBOSE) {
       console.error('[opencli:boss] Fetching job statistics...');

package/src/clis/chaoxing/assignments.ts

@@ -3,7 +3,7 @@ import {
   getCourses, initSession, enterCourse, getTabIframeUrl,
   parseAssignmentsFromDom, sleep,
   type AssignmentRow,
-} from '../../chaoxing.js';
+} from './utils.js';
 
 cli({
   site: 'chaoxing',

package/src/clis/chaoxing/exams.ts

@@ -3,7 +3,7 @@ import {
   getCourses, initSession, enterCourse, getTabIframeUrl,
   parseExamsFromDom, sleep,
   type ExamRow,
-} from '../../chaoxing.js';
+} from './utils.js';
 
 cli({
   site: 'chaoxing',

package/src/{chaoxing.test.ts → clis/chaoxing/utils.test.ts}

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { formatTimestamp, workStatusLabel } from './chaoxing.js';
+import { formatTimestamp, workStatusLabel } from './utils.js';
 
 function localDatePrefixFromMillis(ts: number): string {
   const d = new Date(ts);

package/src/{chaoxing.ts → clis/chaoxing/utils.ts}

@@ -6,7 +6,7 @@
  * course pages loaded as iframes.
  */
 
-import type { IPage } from './types.js';
+import type { IPage } from '../../types.js';
 
 // ── Utilities ────────────────────────────────────────────────────────
 
@@ -96,7 +96,6 @@ export async function getCourses(page: IPage): Promise<ChaoxingCourse[]> {
 /** Navigate to the interaction page to establish a Chaoxing session. */
 export async function initSession(page: IPage): Promise<void> {
   await page.goto('https://mooc2-ans.chaoxing.com/mooc2-ans/visit/interaction');
-  await page.wait(3);
 }
 
 /**
@@ -108,7 +107,6 @@ export async function enterCourse(page: IPage, course: ChaoxingCourse): Promise<
     `https://mooc1.chaoxing.com/visit/stucoursemiddle` +
     `?courseid=${course.courseId}&clazzid=${course.classId}&cpi=${course.cpi}&ismooc2=1&v=2`;
   await page.goto(url);
-  await page.wait(3);
 }
 
 /**

package/src/clis/chatgpt/README.zh-CN.md

@@ -14,7 +14,7 @@
 - `opencli chatgpt status`：检查 ChatGPT 应用是否在运行。
 - `opencli chatgpt new`：激活 ChatGPT 并按 `Cmd+N` 开始新对话。
 - `opencli chatgpt send "消息"`：将消息复制到剪贴板，激活 ChatGPT，粘贴并提交。
-- `opencli chatgpt read`：通过 `Cmd+Shift+C` 复制最后一条 AI 回复并返回文本。
+- `opencli chatgpt read`：通过当前聚焦 ChatGPT 窗口的辅助功能树读取最后一条可见消息并返回文本。
 
 ## 方式二：CDP（高级，Electron 调试模式）
 
@@ -34,11 +34,11 @@ export OPENCLI_CDP_ENDPOINT="http://127.0.0.1:9224"
 
 ## 工作原理
 
-- **AppleScript 模式**：使用 `osascript` 和 `pbcopy`/`pbpaste` 进行剪贴板文本传输，无需远程调试端口。
+- **AppleScript 模式**：使用 `osascript` 控制 ChatGPT，发送消息时借助 `pbcopy`/`pbpaste` 粘贴文本，读取消息时通过 macOS 辅助功能树获取当前可见聊天内容。
 - **CDP 模式**：通过 Chrome DevTools Protocol 连接到 Electron 渲染进程，直接操作 DOM。
 
 ## 限制
 
 - 仅支持 macOS（AppleScript 依赖）
 - AppleScript 模式需要辅助功能权限
-- `read` 命令复制最后一条回复，更早的消息需手动滚动
+- `read` 返回的是当前聚焦 ChatGPT 窗口里的最后一条可见消息；如果目标消息不在可见区域，需先手动滚动

package/src/clis/chatgpt/read.ts

@@ -6,7 +6,7 @@ import { getVisibleChatMessages } from './ax.js';
 export const readCommand = cli({
   site: 'chatgpt',
   name: 'read',
-  description: 'Copy the most recent ChatGPT Desktop App response to clipboard and read it',
+  description: 'Read the last visible message from the focused ChatGPT Desktop window',
   domain: 'localhost',
   strategy: Strategy.PUBLIC,
   browser: false,

package/src/clis/chatwise/export.ts

@@ -10,7 +10,7 @@ export const exportCommand = cli({
   strategy: Strategy.UI,
   browser: true,
   args: [
-    { name: 'output', required: false, positional: true, help: 'Output file (default: /tmp/chatwise-export.md)' },
+    { name: 'output', required: false,  help: 'Output file (default: /tmp/chatwise-export.md)' },
   ],
   columns: ['Status', 'File', 'Messages'],
   func: async (page: IPage, kwargs: any) => {

package/src/clis/chatwise/model.ts

@@ -9,11 +9,11 @@ export const modelCommand = cli({
   strategy: Strategy.UI,
   browser: true,
   args: [
-    { name: 'model_name', required: false, positional: true, help: 'Model to switch to (e.g. gpt-4, claude-3)' },
+    { name: 'model-name', required: false, positional: true, help: 'Model to switch to (e.g. gpt-4, claude-3)' },
   ],
   columns: ['Status', 'Model'],
   func: async (page: IPage, kwargs: any) => {
-    const desiredModel = kwargs.model_name as string | undefined;
+    const desiredModel = kwargs['model-name'] as string | undefined;
 
     if (!desiredModel) {
       // Read current model

package/src/clis/chatwise/screenshot.ts

@@ -10,7 +10,7 @@ export const screenshotCommand = cli({
   strategy: Strategy.UI,
   browser: true,
   args: [
-    { name: 'output', required: false, positional: true, help: 'Output file path (default: /tmp/chatwise-snapshot)' },
+    { name: 'output', required: false,  help: 'Output file path (default: /tmp/chatwise-snapshot)' },
   ],
   columns: ['Status', 'File'],
   func: async (page: IPage, kwargs: any) => {

package/src/clis/codex/export.ts

@@ -10,7 +10,7 @@ export const exportCommand = cli({
   strategy: Strategy.UI,
   browser: true,
   args: [
-    { name: 'output', required: false, positional: true, help: 'Output file (default: /tmp/codex-export.md)' },
+    { name: 'output', required: false,  help: 'Output file (default: /tmp/codex-export.md)' },
   ],
   columns: ['Status', 'File', 'Messages'],
   func: async (page: IPage, kwargs: any) => {