@jackwener/opencli 1.3.3 → 1.4.1

package/src/clis/douyin/publish.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './publish.js';
+
+describe('douyin publish registration', () => {
+  it('registers the publish command', () => {
+    const registry = getRegistry();
+    const cmds = [...registry.values()];
+    const cmd = cmds.find((c) => c.site === 'douyin' && c.name === 'publish');
+    expect(cmd).toBeDefined();
+    expect(cmd?.args.some((a) => a.name === 'video')).toBe(true);
+    expect(cmd?.args.some((a) => a.name === 'title')).toBe(true);
+    expect(cmd?.args.some((a) => a.name === 'schedule')).toBe(true);
+  });
+
+  it('has all expected args', () => {
+    const registry = getRegistry();
+    const cmd = [...registry.values()].find(
+      (c) => c.site === 'douyin' && c.name === 'publish',
+    );
+    const argNames = cmd?.args.map((a) => a.name) ?? [];
+    expect(argNames).toContain('video');
+    expect(argNames).toContain('title');
+    expect(argNames).toContain('schedule');
+    expect(argNames).toContain('caption');
+    expect(argNames).toContain('cover');
+    expect(argNames).toContain('visibility');
+    expect(argNames).toContain('allow_download');
+    expect(argNames).toContain('collection');
+    expect(argNames).toContain('activity');
+    expect(argNames).toContain('poi_id');
+    expect(argNames).toContain('poi_name');
+    expect(argNames).toContain('hotspot');
+    expect(argNames).toContain('no_safety_check');
+    expect(argNames).toContain('sync_toutiao');
+  });
+
+  it('uses COOKIE strategy', () => {
+    const registry = getRegistry();
+    const cmd = [...registry.values()].find(
+      (c) => c.site === 'douyin' && c.name === 'publish',
+    );
+    expect(cmd?.strategy).toBe('cookie');
+  });
+});

package/src/clis/douyin/publish.ts

@@ -0,0 +1,340 @@
+/**
+ * Douyin publish — 8-phase pipeline for scheduling video posts.
+ *
+ * Phases:
+ *   1. STS2 credentials
+ *   2. Apply TOS upload URL
+ *   3. TOS multipart upload
+ *   4. Cover upload (optional, via ImageX)
+ *   5. Enable video
+ *   6. Poll transcode
+ *   7. Content safety check
+ *   8. create_v2 publish
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '../../registry.js';
+import { ArgumentError, CommandExecutionError } from '../../errors.js';
+import type { IPage } from '../../types.js';
+import type { TosUploadInfo } from './_shared/types.js';
+import { getSts2Credentials } from './_shared/sts2.js';
+import { tosUpload } from './_shared/tos-upload.js';
+import { imagexUpload } from './_shared/imagex-upload.js';
+import { pollTranscode } from './_shared/transcode.js';
+import { browserFetch } from './_shared/browser-fetch.js';
+import { generateCreationId } from './_shared/creation-id.js';
+import { validateTiming, toUnixSeconds } from './_shared/timing.js';
+import { parseTextExtra, extractHashtagNames } from './_shared/text-extra.js';
+import type { HashtagInfo } from './_shared/text-extra.js';
+
+const VISIBILITY_MAP: Record<string, number> = {
+  public: 0,
+  friends: 1,
+  private: 2,
+};
+
+const IMAGEX_BASE = 'https://imagex.bytedanceapi.com';
+const IMAGEX_SERVICE_ID = '1147';
+
+const DEVICE_PARAMS =
+  'aid=1128&cookie_enabled=true&screen_width=1512&screen_height=982&browser_language=zh-CN&browser_platform=MacIntel&browser_name=Mozilla&browser_online=true&timezone_name=Asia%2FTokyo&support_h265=1';
+
+const DEFAULT_COVER_TOOLS_INFO = JSON.stringify({
+  video_cover_source: 2,
+  cover_timestamp: 0,
+  recommend_timestamp: 0,
+  is_cover_edit: 0,
+  is_cover_template: 0,
+  cover_template_id: '',
+  is_text_template: 0,
+  text_template_id: '',
+  text_template_content: '',
+  is_text: 0,
+  text_num: 0,
+  text_content: '',
+  is_use_sticker: 0,
+  sticker_id: '',
+  is_use_filter: 0,
+  filter_id: '',
+  is_cover_modify: 0,
+  to_status: 0,
+  cover_type: 0,
+  initial_cover_uri: '',
+  cut_coordinate: '',
+});
+
+cli({
+  site: 'douyin',
+  name: 'publish',
+  description: '定时发布视频到抖音（必须设置 2h ~ 14天后的发布时间）',
+  domain: 'creator.douyin.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'video', required: true, positional: true, help: '视频文件路径' },
+    { name: 'title', required: true, help: '视频标题（≤30字）' },
+    { name: 'schedule', required: true, help: '定时发布时间（ISO8601 或 Unix 秒，2h ~ 14天后）' },
+    { name: 'caption', default: '', help: '正文内容（≤1000字，支持 #话题）' },
+    { name: 'cover', default: '', help: '封面图片路径（不提供时使用视频截帧）' },
+    { name: 'visibility', default: 'public', choices: ['public', 'friends', 'private'] },
+    { name: 'allow_download', type: 'bool', default: false, help: '允许下载' },
+    { name: 'collection', default: '', help: '合集 ID' },
+    { name: 'activity', default: '', help: '活动 ID' },
+    { name: 'poi_id', default: '', help: '地理位置 ID' },
+    { name: 'poi_name', default: '', help: '地理位置名称' },
+    { name: 'hotspot', default: '', help: '关联热点词' },
+    { name: 'no_safety_check', type: 'bool', default: false, help: '跳过内容安全检测' },
+    { name: 'sync_toutiao', type: 'bool', default: false, help: '同步发布到头条' },
+  ],
+  columns: ['status', 'aweme_id', 'url', 'publish_time'],
+  func: async (page: IPage, kwargs) => {
+    // ── Fail-fast validation ────────────────────────────────────────────
+    const videoPath = path.resolve(kwargs.video as string);
+    if (!fs.existsSync(videoPath)) {
+      throw new ArgumentError(`视频文件不存在: ${videoPath}`);
+    }
+    const ext = path.extname(videoPath).toLowerCase();
+    if (!['.mp4', '.mov', '.avi', '.webm'].includes(ext)) {
+      throw new ArgumentError(`不支持的视频格式: ${ext}（支持 mp4/mov/avi/webm）`);
+    }
+    const fileSize = fs.statSync(videoPath).size;
+
+    const title = kwargs.title as string;
+    if (title.length > 30) {
+      throw new ArgumentError('标题不能超过 30 字');
+    }
+
+    const caption = (kwargs.caption as string) || '';
+    if (caption.length > 1000) {
+      throw new ArgumentError('正文不能超过 1000 字');
+    }
+
+    const timingTs = toUnixSeconds(kwargs.schedule as string | number);
+    validateTiming(timingTs);
+
+    const visibilityType = VISIBILITY_MAP[kwargs.visibility as string] ?? 0;
+
+    const coverPath = kwargs.cover as string;
+    if (coverPath) {
+      if (!fs.existsSync(path.resolve(coverPath))) {
+        throw new ArgumentError(`封面文件不存在: ${path.resolve(coverPath)}`);
+      }
+    }
+
+    // ── Phase 1: STS2 credentials ───────────────────────────────────────
+    const credentials = await getSts2Credentials(page);
+
+    // ── Phase 2: Apply TOS upload URL ───────────────────────────────────
+    const vodUrl = `https://vod.bytedanceapi.com/?Action=ApplyVideoUpload&ServiceId=1128&Version=2021-01-01&FileType=video&FileSize=${fileSize}`;
+    const vodJs = `fetch(${JSON.stringify(vodUrl)}, { credentials: 'include' }).then(r => r.json())`;
+    const vodRes = (await page.evaluate(vodJs)) as {
+      Result: {
+        UploadAddress: {
+          VideoId: string;
+          UploadHosts: string[];
+          StoreInfos: Array<{ Auth: string; StoreUri: string }>;
+        };
+      };
+    };
+    const { VideoId: videoId, UploadHosts, StoreInfos } = vodRes.Result.UploadAddress;
+    const tosUrl = `https://${UploadHosts[0]}/${StoreInfos[0].StoreUri}`;
+    const tosUploadInfo: TosUploadInfo = {
+      tos_upload_url: tosUrl,
+      auth: StoreInfos[0].Auth,
+      video_id: videoId,
+    };
+
+    // ── Phase 3: TOS upload ─────────────────────────────────────────────
+    await tosUpload({
+      filePath: videoPath,
+      uploadInfo: tosUploadInfo,
+      credentials,
+      onProgress: (uploaded, total) => {
+        const pct = Math.round((uploaded / total) * 100);
+        process.stderr.write(`\r  上传进度: ${pct}%`);
+      },
+    });
+    process.stderr.write('\n');
+
+    // ── Phase 4: Cover upload (optional) ────────────────────────────────
+    let coverUri = '';
+    let coverWidth = 720;
+    let coverHeight = 1280;
+
+    if (kwargs.cover) {
+      const resolvedCoverPath = path.resolve(kwargs.cover as string);
+
+      // 4A: Apply ImageX upload
+      const applyUrl = `${IMAGEX_BASE}/?Action=ApplyImageUpload&ServiceId=${IMAGEX_SERVICE_ID}&Version=2018-08-01&UploadNum=1`;
+      const applyJs = `fetch(${JSON.stringify(applyUrl)}, { credentials: 'include' }).then(r => r.json())`;
+      const applyRes = (await page.evaluate(applyJs)) as {
+        Result: {
+          UploadAddress: {
+            UploadHosts: string[];
+            StoreInfos: Array<{ Auth: string; StoreUri: string; UploadHost: string }>;
+          };
+        };
+      };
+      const { StoreInfos: imgStoreInfos } = applyRes.Result.UploadAddress;
+      const imgUploadUrl = `https://${imgStoreInfos[0].UploadHost}/${imgStoreInfos[0].StoreUri}`;
+
+      // 4B: Upload image
+      const coverStoreUri = await imagexUpload(resolvedCoverPath, {
+        upload_url: imgUploadUrl,
+        store_uri: imgStoreInfos[0].StoreUri,
+      });
+
+      // 4C: Commit ImageX upload
+      const commitUrl = `${IMAGEX_BASE}/?Action=CommitImageUpload&ServiceId=${IMAGEX_SERVICE_ID}&Version=2018-08-01`;
+      const commitBody = JSON.stringify({ SuccessObjKeys: [coverStoreUri] });
+      const commitJs = `
+        fetch(${JSON.stringify(commitUrl)}, {
+          method: 'POST',
+          credentials: 'include',
+          headers: { 'Content-Type': 'application/json' },
+          body: ${JSON.stringify(commitBody)}
+        }).then(r => r.json())
+      `;
+      await page.evaluate(commitJs);
+
+      coverUri = coverStoreUri;
+    }
+
+    // ── Phase 5: Enable video ───────────────────────────────────────────
+    const enableUrl = `https://creator.douyin.com/web/api/media/video/enable/?video_id=${videoId}&aid=1128`;
+    await browserFetch(page, 'GET', enableUrl);
+
+    // ── Phase 6: Poll transcode ─────────────────────────────────────────
+    const transResult = await pollTranscode(page, videoId);
+    coverWidth = transResult.width;
+    coverHeight = transResult.height;
+    if (!coverUri) {
+      coverUri = transResult.poster_uri;
+    }
+
+    // ── Phase 7: Content safety check ───────────────────────────────────
+    if (!kwargs.no_safety_check) {
+      const safetyUrl =
+        'https://creator.douyin.com/aweme/v1/post_assistant/fast_detect/pre_check';
+      const safetyBody = {
+        video_id: videoId,
+        title,
+        desc: caption,
+      };
+      await browserFetch(page, 'POST', safetyUrl, { body: safetyBody });
+
+      const pollUrl =
+        'https://creator.douyin.com/aweme/v1/post_assistant/fast_detect/poll';
+      const deadline = Date.now() + 30_000;
+      let safetyPassed = false;
+      while (Date.now() < deadline) {
+        const pollRes = (await browserFetch(page, 'POST', pollUrl, {
+          body: safetyBody,
+        })) as { status: number };
+        if (pollRes.status === 0) { safetyPassed = true; break; }
+        if (pollRes.status === 1) {
+          throw new CommandExecutionError(
+            '内容安全检测不通过，请修改后重试',
+            '使用 --no_safety_check 跳过',
+          );
+        }
+        await new Promise((r) => setTimeout(r, 2000));
+      }
+      if (!safetyPassed) {
+        throw new CommandExecutionError(
+          '内容安全检测超时（30s），请稍后重试',
+          '使用 --no_safety_check 跳过',
+        );
+      }
+    }
+
+    // ── Phase 8: create_v2 publish ──────────────────────────────────────
+    const hashtagNames = extractHashtagNames(caption);
+    const hashtags: HashtagInfo[] = [];
+    let searchFrom = 0;
+    for (const name of hashtagNames) {
+      const idx = caption.indexOf(`#${name}`, searchFrom);
+      if (idx === -1) continue;
+      hashtags.push({ name, id: 0, start: idx, end: idx + name.length + 1 });
+      searchFrom = idx + name.length + 1;
+    }
+    const textExtraArr = parseTextExtra(caption, hashtags);
+
+    const publishBody = {
+      item: {
+        common: {
+          text: caption,
+          caption: '',
+          item_title: title,
+          activity: JSON.stringify(kwargs.activity ? [kwargs.activity] : []),
+          text_extra: JSON.stringify(textExtraArr),
+          challenges: '[]',
+          mentions: '[]',
+          hashtag_source: '',
+          hot_sentence: (kwargs.hotspot as string) || '',
+          interaction_stickers: '[]',
+          visibility_type: visibilityType,
+          download: kwargs.allow_download ? 1 : 0,
+          timing: timingTs,
+          creation_id: generateCreationId(),
+          media_type: 4,
+          video_id: videoId,
+          music_source: 0,
+          music_id: null,
+          ...(kwargs.poi_id
+            ? { poi_id: kwargs.poi_id as string, poi_name: kwargs.poi_name as string }
+            : {}),
+        },
+        cover: {
+          poster: coverUri,
+          custom_cover_image_height: coverHeight,
+          custom_cover_image_width: coverWidth,
+          poster_delay: 0,
+          cover_tools_info: DEFAULT_COVER_TOOLS_INFO,
+          cover_tools_extend_info: '{}',
+        },
+        mix: kwargs.collection
+          ? { mix_id: kwargs.collection as string, mix_order: 0 }
+          : {},
+        chapter: {
+          chapter: JSON.stringify({
+            chapter_abstract: '',
+            chapter_details: [],
+            chapter_type: 0,
+          }),
+        },
+        anchor: {},
+        sync: {
+          should_sync: false,
+          sync_to_toutiao: kwargs.sync_toutiao ? 1 : 0,
+        },
+        open_platform: {},
+        assistant: { is_preview: 0, is_post_assistant: 1 },
+        declare: { user_declare_info: '{}' },
+      },
+    };
+
+    const publishUrl = `https://creator.douyin.com/web/api/media/aweme/create_v2/?read_aid=2906&${DEVICE_PARAMS}`;
+    const publishRes = (await browserFetch(page, 'POST', publishUrl, {
+      body: publishBody,
+    })) as { status_code: number; aweme_id: string };
+
+    const awemeId = publishRes.aweme_id;
+    if (!awemeId) {
+      throw new CommandExecutionError(`发布成功但未返回 aweme_id: ${JSON.stringify(publishRes)}`);
+    }
+    const url = `https://www.douyin.com/video/${awemeId}`;
+    const publishTimeStr = new Date(timingTs * 1000).toLocaleString('zh-CN', {
+      timeZone: 'Asia/Tokyo',
+    });
+
+    return [
+      {
+        status: '✅ 定时发布成功！',
+        aweme_id: awemeId,
+        url,
+        publish_time: publishTimeStr,
+      },
+    ];
+  },
+});

package/src/clis/douyin/stats.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './stats.js';
+
+describe('douyin stats registration', () => {
+  it('registers the stats command', () => {
+    const registry = getRegistry();
+    const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'stats');
+    expect(cmd).toBeDefined();
+    expect(cmd?.args.some(a => a.name === 'aweme_id')).toBe(true);
+  });
+
+  it('has expected columns', () => {
+    const registry = getRegistry();
+    const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'stats');
+    expect(cmd?.columns).toContain('metric');
+    expect(cmd?.columns).toContain('value');
+  });
+
+  it('uses COOKIE strategy', () => {
+    const registry = getRegistry();
+    const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'stats');
+    expect(cmd?.strategy).toBe('cookie');
+  });
+});

package/src/clis/douyin/stats.ts

@@ -0,0 +1,30 @@
+import { cli, Strategy } from '../../registry.js';
+import { browserFetch } from './_shared/browser-fetch.js';
+
+cli({
+  site: 'douyin',
+  name: 'stats',
+  description: '作品数据分析',
+  domain: 'creator.douyin.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'aweme_id', required: true, positional: true },
+  ],
+  columns: ['metric', 'value'],
+  func: async (page, kwargs) => {
+    const now = Math.floor(Date.now() / 1000);
+    const sevenDaysAgo = now - 7 * 86400;
+    const url = 'https://creator.douyin.com/janus/douyin/creator/data/item_analysis/metrics_trend';
+    const body = {
+      aweme_id: kwargs.aweme_id as string,
+      start_time: sevenDaysAgo,
+      end_time: now,
+      metrics: ['play_count', 'like_count', 'comment_count', 'share_count'],
+    };
+    const res = await browserFetch(page, 'POST', url, { body }) as {
+      data: Record<string, number>
+    };
+    const data = res.data ?? {};
+    return Object.entries(data).map(([metric, value]) => ({ metric, value }));
+  },
+});

package/src/clis/douyin/update.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './update.js';
+
+describe('douyin update registration', () => {
+  it('registers the update command', () => {
+    const registry = getRegistry();
+    const values = [...registry.values()];
+    const cmd = values.find(c => c.site === 'douyin' && c.name === 'update');
+    expect(cmd).toBeDefined();
+  });
+});

package/src/clis/douyin/update.ts

@@ -0,0 +1,43 @@
+import { cli, Strategy } from '../../registry.js';
+import { ArgumentError } from '../../errors.js';
+import { browserFetch } from './_shared/browser-fetch.js';
+import { toUnixSeconds, validateTiming } from './_shared/timing.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'douyin',
+  name: 'update',
+  description: '更新视频信息',
+  domain: 'creator.douyin.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'aweme_id', required: true, positional: true },
+    { name: 'reschedule', default: '', help: '新的发布时间（ISO8601 或 Unix 秒）' },
+    { name: 'caption', default: '', help: '新的正文内容' },
+  ],
+  columns: ['status'],
+  func: async (page: IPage, kwargs) => {
+    if (!kwargs.reschedule && !kwargs.caption) {
+      throw new ArgumentError('必须提供 --reschedule 或 --caption');
+    }
+    if (kwargs.reschedule) {
+      const newTime = toUnixSeconds(kwargs.reschedule as string | number);
+      validateTiming(newTime);
+      await browserFetch(
+        page,
+        'POST',
+        'https://creator.douyin.com/web/api/media/update/timer/?aid=1128',
+        { body: { aweme_id: kwargs.aweme_id, publish_time: newTime } },
+      );
+    }
+    if (kwargs.caption) {
+      await browserFetch(
+        page,
+        'POST',
+        'https://creator.douyin.com/web/api/media/update/desc/?aid=1128',
+        { body: { aweme_id: kwargs.aweme_id, desc: kwargs.caption } },
+      );
+    }
+    return [{ status: '✅ 更新成功' }];
+  },
+});

package/src/clis/douyin/videos.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './videos.js';
+
+describe('douyin videos registration', () => {
+  it('registers the videos command', () => {
+    const registry = getRegistry();
+    const values = [...registry.values()];
+    const cmd = values.find(c => c.site === 'douyin' && c.name === 'videos');
+    expect(cmd).toBeDefined();
+  });
+});

package/src/clis/douyin/videos.ts

@@ -0,0 +1,49 @@
+import { cli, Strategy } from '../../registry.js';
+import { browserFetch } from './_shared/browser-fetch.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'douyin',
+  name: 'videos',
+  description: '获取作品列表',
+  domain: 'creator.douyin.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: '每页数量' },
+    { name: 'page', type: 'int', default: 1, help: '页码' },
+    { name: 'status', default: 'all', choices: ['all', 'published', 'reviewing', 'scheduled'] },
+  ],
+  columns: ['aweme_id', 'title', 'status', 'play_count', 'digg_count', 'create_time'],
+  func: async (page: IPage, kwargs) => {
+    const statusMap: Record<string, number> = { all: 0, published: 1, reviewing: 3, scheduled: 0 };
+    const statusNum = statusMap[kwargs.status as string] ?? 0;
+    const url = `https://creator.douyin.com/janus/douyin/creator/pc/work_list?page_size=${kwargs.limit}&page_num=${kwargs.page}&status=${statusNum}`;
+    const res = (await browserFetch(page, 'GET', url)) as {
+      data: {
+        work_list: Array<{
+          aweme_id: string;
+          desc: string;
+          status: number;
+          public_time: number;
+          create_time: number;
+          statistics: { play_count: number; digg_count: number };
+        }>;
+      };
+    };
+    let items = res.data?.work_list ?? [];
+
+    // The API has a bug with status=16 for scheduled, so filter client-side
+    if (kwargs.status === 'scheduled') {
+      items = items.filter((v) => v.public_time > Date.now() / 1000);
+    }
+
+    return items.map((v) => ({
+      aweme_id: v.aweme_id,
+      title: v.desc,
+      status: v.status,
+      play_count: v.statistics?.play_count ?? 0,
+      digg_count: v.statistics?.digg_count ?? 0,
+      create_time: new Date(v.create_time * 1000).toLocaleString('zh-CN', { timeZone: 'Asia/Tokyo' }),
+    }));
+  },
+});

package/src/clis/grok/ask.test.ts

@@ -1,7 +1,32 @@
 import { describe, expect, it } from 'vitest';
+import type { IPage } from '../../types.js';
 import { __test__ } from './ask.js';
 
 describe('grok ask helpers', () => {
+  describe('isOnGrok', () => {
+    const fakePage = (url: string | Error): IPage =>
+      ({ evaluate: () => url instanceof Error ? Promise.reject(url) : Promise.resolve(url) }) as unknown as IPage;
+
+    it('returns true for grok.com URLs', async () => {
+      expect(await __test__.isOnGrok(fakePage('https://grok.com/'))).toBe(true);
+      expect(await __test__.isOnGrok(fakePage('https://grok.com/chat/abc123'))).toBe(true);
+    });
+
+    it('returns true for grok.com subdomains', async () => {
+      expect(await __test__.isOnGrok(fakePage('https://api.grok.com/v1'))).toBe(true);
+    });
+
+    it('returns false for non-grok domains', async () => {
+      expect(await __test__.isOnGrok(fakePage('https://fakegrok.com/'))).toBe(false);
+      expect(await __test__.isOnGrok(fakePage('https://example.com/?next=grok.com'))).toBe(false);
+      expect(await __test__.isOnGrok(fakePage('about:blank'))).toBe(false);
+    });
+
+    it('returns false when evaluate throws (detached tab)', async () => {
+      expect(await __test__.isOnGrok(fakePage(new Error('detached')))).toBe(false);
+    });
+  });
+
   it('normalizes boolean flags for explicit web routing', () => {
     expect(__test__.normalizeBooleanFlag(true)).toBe(true);
     expect(__test__.normalizeBooleanFlag('true')).toBe(true);

package/src/clis/grok/ask.ts

@@ -53,6 +53,19 @@ function updateStableState(previousText: string, stableCount: number, nextText:
   return { previousText: nextText, stableCount: 0 };
 }
 
+/** Check whether the tab is already on grok.com (any path). */
+async function isOnGrok(page: IPage): Promise<boolean> {
+  // catch handles blank tabs (about:blank) or detached pages
+  const url = await page.evaluate('window.location.href').catch(() => '');
+  if (typeof url !== 'string' || !url) return false;
+  try {
+    const hostname = new URL(url).hostname;
+    return hostname === 'grok.com' || hostname.endsWith('.grok.com');
+  } catch {
+    return false;
+  }
+}
+
 async function runDefaultAsk(
   page: IPage,
   prompt: string,
@@ -60,21 +73,17 @@ async function runDefaultAsk(
   newChat: boolean,
 ) {
   if (newChat) {
+    // Explicitly start a fresh conversation via the homepage
     await page.goto(GROK_URL);
     await page.wait(2);
-    await page.evaluate(`(() => {
-      const btn = [...document.querySelectorAll('a, button')].find(b => {
-        const t = (b.textContent || '').trim().toLowerCase();
-        return t.includes('new') || b.getAttribute('href') === '/';
-      });
-      if (btn) btn.click();
-    })()`);
+    await tryStartFreshChat(page);
     await page.wait(2);
+  } else if (!(await isOnGrok(page))) {
+    // First invocation or tab was recycled — navigate to Grok
+    await page.goto(GROK_URL);
+    await page.wait(3);
   }
 
-  await page.goto(GROK_URL);
-  await page.wait(3);
-
   const promptJson = JSON.stringify(prompt);
   const sendResult = await page.evaluate(`(async () => {
     try {
@@ -249,11 +258,14 @@ async function runExplicitWebAsk(
   timeoutMs: number,
   newChat: boolean,
 ) {
-  await page.goto(GROK_URL, { settleMs: 2000 });
-
   if (newChat) {
+    // Navigate to homepage and start a fresh conversation
+    await page.goto(GROK_URL, { settleMs: 2000 });
     await tryStartFreshChat(page);
     await page.wait(2);
+  } else if (!(await isOnGrok(page))) {
+    // First invocation or tab was recycled — navigate to Grok
+    await page.goto(GROK_URL, { settleMs: 2000 });
   }
 
   const baselineBubbles = await getBubbleTexts(page);
@@ -318,4 +330,5 @@ export const __test__ = {
   updateStableState,
   normalizeBooleanFlag,
   normalizeBubbleText,
+  isOnGrok,
 };

package/src/clis/hackernews/search.yaml

@@ -41,4 +41,4 @@ pipeline:
 
   - limit: ${{ args.limit }}
 
-columns: [rank, title, score, author, comments]
+columns: [rank, title, score, author, comments, url]