@jackwener/opencli 1.7.21 → 1.8.0

package/clis/flomo/memos.js

@@ -0,0 +1,228 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+  ArgumentError,
+  AuthRequiredError,
+  CommandExecutionError,
+  EmptyResultError,
+} from '@jackwener/opencli/errors';
+import { createHash } from 'node:crypto';
+
+const FLOMO_APP_DOMAIN = 'v.flomoapp.com';
+const FLOMO_API_DOMAIN = 'flomoapp.com';
+const MAX_LIMIT = 200;
+
+function unwrapBrowserResult(value) {
+  if (value && typeof value === 'object' && 'session' in value && 'data' in value) {
+    return value.data;
+  }
+  return value;
+}
+
+function parsePositiveIntArg(value, name, fallback, max) {
+  if (value === undefined || value === null || value === '') {
+    return fallback;
+  }
+  const text = String(value).trim();
+  if (!/^\d+$/.test(text)) {
+    throw new ArgumentError(`flomo memos --${name} must be a positive integer`);
+  }
+  const parsed = Number(text);
+  if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > max) {
+    throw new ArgumentError(`flomo memos --${name} must be between 1 and ${max}`);
+  }
+  return parsed;
+}
+
+function parseSinceArg(value) {
+  if (value === undefined || value === null || value === '') {
+    return 0;
+  }
+  const text = String(value).trim();
+  if (!/^\d+$/.test(text)) {
+    throw new ArgumentError('flomo memos --since must be a non-negative Unix timestamp in seconds');
+  }
+  const parsed = Number(text);
+  if (!Number.isSafeInteger(parsed)) {
+    throw new ArgumentError('flomo memos --since must be a safe integer Unix timestamp in seconds');
+  }
+  return parsed;
+}
+
+function parseSlugArg(value) {
+  if (value === undefined || value === null || value === '') {
+    return '';
+  }
+  const slug = String(value).trim();
+  if (!/^[A-Za-z0-9_-]{1,256}$/.test(slug)) {
+    throw new ArgumentError('flomo memos --slug must be an opaque memo cursor containing only letters, numbers, _ or -');
+  }
+  return slug;
+}
+
+function buildSignedUrl(limit, since, slug) {
+  const params = {
+    limit: String(limit),
+    latest_updated_at: String(since),
+    tz: '8:0',
+    timestamp: String(Math.floor(Date.now() / 1000)),
+    api_key: 'flomo_web',
+    app_version: '4.0',
+    platform: 'web',
+    webp: '1',
+  };
+  if (slug) params.latest_slug = slug;
+  const keys = Object.keys(params).sort();
+  const signBase = keys.map((key) => `${key}=${params[key]}`).join('&');
+  params.sign = createHash('md5').update(signBase + 'dbbc3dd73364b4084c3a69346e0ce2b2').digest('hex');
+  return 'https://flomoapp.com/api/v1/memo/updated/?' + new URLSearchParams(params).toString();
+}
+
+function buildGetTokenJs() {
+  return `
+    (() => {
+      try {
+        const raw = localStorage.getItem('me');
+        if (!raw) return null;
+        const me = JSON.parse(raw);
+        const token = me?.access_token || me?.data?.access_token || '';
+        return typeof token === 'string' && token.trim() ? token.trim() : null;
+      } catch {
+        return null;
+      }
+    })()
+  `;
+}
+
+function isAuthFailureMessage(message) {
+  return /auth|unauth|login|token|permission|forbidden|unauthorized|登录|登陆|鉴权|权限/i.test(String(message || ''));
+}
+
+function normalizeTags(tags) {
+  if (!Array.isArray(tags)) return '';
+  return tags
+    .map((tag) => {
+      if (typeof tag === 'string') return tag;
+      return tag?.name || tag?.tag || tag?.content || '';
+    })
+    .map((tag) => String(tag).trim())
+    .filter(Boolean)
+    .join(', ');
+}
+
+function normalizeImages(files) {
+  if (!Array.isArray(files)) return '';
+  return files
+    .map((file) => file?.thumbnail_url || file?.url || '')
+    .map((url) => String(url).trim())
+    .filter(Boolean)
+    .join(' | ');
+}
+
+function memoUrl(slug) {
+  return slug ? `https://${FLOMO_APP_DOMAIN}/mine/?memo_id=${encodeURIComponent(slug)}` : '';
+}
+
+function normalizeMemo(memo) {
+  if (!memo || typeof memo !== 'object' || Array.isArray(memo)) {
+    throw new CommandExecutionError('Flomo API returned a malformed memo entry');
+  }
+  const slug = String(memo.slug || memo.id || '').trim();
+  if (!slug) {
+    throw new CommandExecutionError('Flomo API returned a memo without slug/id');
+  }
+  return {
+    id: slug,
+    url: memoUrl(slug),
+    content: String(memo.content || '').trim(),
+    slug,
+    tags: normalizeTags(memo.tags),
+    images: normalizeImages(memo.files),
+    created_at: String(memo.created_at || ''),
+    updated_at: String(memo.updated_at || ''),
+  };
+}
+
+async function fetchFlomoJson(url, token) {
+  let resp;
+  try {
+    resp = await fetch(url, {
+      headers: {
+        Authorization: 'Bearer ' + token,
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        Accept: 'application/json',
+      },
+    });
+  } catch (err) {
+    throw new CommandExecutionError(`Failed to fetch Flomo memos: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (resp.status === 401 || resp.status === 403) {
+    throw new AuthRequiredError(FLOMO_API_DOMAIN, `Flomo API returned HTTP ${resp.status}; please refresh your Flomo login session`);
+  }
+  if (!resp.ok) {
+    throw new CommandExecutionError(`Flomo API returned HTTP ${resp.status}`);
+  }
+  try {
+    return await resp.json();
+  } catch (err) {
+    throw new CommandExecutionError(`Flomo API returned malformed JSON: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
+async function readAccessToken(page) {
+  const token = unwrapBrowserResult(await page.evaluate(buildGetTokenJs()));
+  if (typeof token !== 'string' || !token.trim()) {
+    throw new AuthRequiredError(FLOMO_API_DOMAIN, 'Flomo memos requires an active signed-in Flomo browser session');
+  }
+  return token.trim();
+}
+
+const command = cli({
+  site: 'flomo',
+  name: 'memos',
+  access: 'read',
+  description: 'List your Flomo memos',
+  domain: FLOMO_API_DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: `https://${FLOMO_APP_DOMAIN}/`,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Number of memos to fetch (1-200)' },
+    { name: 'since', type: 'int', help: 'Only memos updated after this Unix timestamp in seconds' },
+    { name: 'slug', help: 'Pagination cursor from a previous memo page' },
+  ],
+  columns: ['id', 'url', 'content', 'slug', 'tags', 'images', 'created_at', 'updated_at'],
+  func: async (page, kwargs) => {
+    const limit = parsePositiveIntArg(kwargs.limit, 'limit', 20, MAX_LIMIT);
+    const since = parseSinceArg(kwargs.since);
+    const slug = parseSlugArg(kwargs.slug);
+    await page.wait(3).catch(() => {});
+    const token = await readAccessToken(page);
+    const body = await fetchFlomoJson(buildSignedUrl(limit, since, slug), token);
+    if (!body || typeof body !== 'object' || Array.isArray(body)) {
+      throw new CommandExecutionError('Flomo API returned a malformed response');
+    }
+    if (body.code !== 0) {
+      const message = body.message || `Flomo API error code ${body.code}`;
+      if (isAuthFailureMessage(message)) {
+        throw new AuthRequiredError(FLOMO_API_DOMAIN, message);
+      }
+      throw new CommandExecutionError(message);
+    }
+    if (!Array.isArray(body.data)) {
+      throw new CommandExecutionError('Flomo API returned malformed memo data');
+    }
+    if (body.data.length === 0) {
+      throw new EmptyResultError('flomo memos', 'No Flomo memos matched the requested filters.');
+    }
+    return body.data.map(normalizeMemo);
+  },
+});
+
+export const __test__ = {
+  buildSignedUrl,
+  command,
+  normalizeMemo,
+  parsePositiveIntArg,
+  parseSinceArg,
+  parseSlugArg,
+};

package/clis/flomo/memos.test.js

@@ -0,0 +1,144 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  ArgumentError,
+  AuthRequiredError,
+  CommandExecutionError,
+  EmptyResultError,
+} from '@jackwener/opencli/errors';
+
+const { __test__ } = await import('./memos.js');
+const { command, normalizeMemo, parsePositiveIntArg, parseSinceArg, parseSlugArg } = __test__;
+
+function createPage(token = 'token-123') {
+  return {
+    wait: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue({ session: 'browser:default', data: token }),
+  };
+}
+
+function mockFetchJson(body, status = 200) {
+  vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+    ok: status >= 200 && status < 300,
+    status,
+    json: vi.fn().mockResolvedValue(body),
+  }));
+}
+
+describe('flomo memos registration', () => {
+  it('registers as a browser cookie read command with stable columns', () => {
+    expect(command.site).toBe('flomo');
+    expect(command.name).toBe('memos');
+    expect(command.access).toBe('read');
+    expect(command.browser).toBe(true);
+    expect(command.strategy).toBe('cookie');
+    expect(command.columns).toEqual(['id', 'url', 'content', 'slug', 'tags', 'images', 'created_at', 'updated_at']);
+  });
+});
+
+describe('flomo memos argument validation', () => {
+  it('rejects invalid limits instead of silently clamping', () => {
+    expect(() => parsePositiveIntArg('0', 'limit', 20, 200)).toThrow(ArgumentError);
+    expect(() => parsePositiveIntArg('201', 'limit', 20, 200)).toThrow(ArgumentError);
+    expect(() => parsePositiveIntArg('10.5', 'limit', 20, 200)).toThrow(ArgumentError);
+    expect(() => parsePositiveIntArg('abc', 'limit', 20, 200)).toThrow(ArgumentError);
+    expect(parsePositiveIntArg(undefined, 'limit', 20, 200)).toBe(20);
+    expect(parsePositiveIntArg('200', 'limit', 20, 200)).toBe(200);
+  });
+
+  it('rejects invalid since and slug arguments', () => {
+    expect(parseSinceArg(undefined)).toBe(0);
+    expect(parseSinceArg('1735689600')).toBe(1735689600);
+    expect(() => parseSinceArg('-1')).toThrow(ArgumentError);
+    expect(() => parseSinceArg('1.5')).toThrow(ArgumentError);
+    expect(parseSlugArg(undefined)).toBe('');
+    expect(parseSlugArg('abc_DEF-123')).toBe('abc_DEF-123');
+    expect(() => parseSlugArg('bad/slash')).toThrow(ArgumentError);
+    expect(() => parseSlugArg('bad space')).toThrow(ArgumentError);
+  });
+});
+
+describe('flomo memo normalization', () => {
+  it('emits string-safe id/url fields and normalizes tags/images', () => {
+    expect(normalizeMemo({
+      slug: 'memo_12345678901234567890',
+      content: ' <p>Hello</p> ',
+      tags: [{ name: 'work' }, 'idea'],
+      files: [{ thumbnail_url: 'https://img/thumb.jpg' }, { url: 'https://img/full.jpg' }],
+      created_at: '2026-01-01T00:00:00+08:00',
+      updated_at: '2026-01-02T00:00:00+08:00',
+    })).toEqual({
+      id: 'memo_12345678901234567890',
+      url: 'https://v.flomoapp.com/mine/?memo_id=memo_12345678901234567890',
+      content: '<p>Hello</p>',
+      slug: 'memo_12345678901234567890',
+      tags: 'work, idea',
+      images: 'https://img/thumb.jpg | https://img/full.jpg',
+      created_at: '2026-01-01T00:00:00+08:00',
+      updated_at: '2026-01-02T00:00:00+08:00',
+    });
+  });
+
+  it('fails typed on malformed memo entries', () => {
+    expect(() => normalizeMemo(null)).toThrow(CommandExecutionError);
+    expect(() => normalizeMemo({ content: 'missing slug' })).toThrow(CommandExecutionError);
+  });
+});
+
+describe('flomo memos command', () => {
+  beforeEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('reads token from Browser Bridge envelope and returns memo rows', async () => {
+    mockFetchJson({
+      code: 0,
+      data: [{
+        slug: 'memo_1',
+        content: 'hello',
+        tags: ['tag'],
+        files: [],
+        created_at: '2026-01-01',
+        updated_at: '2026-01-02',
+      }],
+    });
+
+    const rows = await command.func(createPage(), { limit: '1' });
+
+    expect(globalThis.fetch).toHaveBeenCalledWith(expect.stringContaining('limit=1'), expect.objectContaining({
+      headers: expect.objectContaining({ Authorization: 'Bearer token-123' }),
+    }));
+    expect(rows).toEqual([{
+      id: 'memo_1',
+      url: 'https://v.flomoapp.com/mine/?memo_id=memo_1',
+      content: 'hello',
+      slug: 'memo_1',
+      tags: 'tag',
+      images: '',
+      created_at: '2026-01-01',
+      updated_at: '2026-01-02',
+    }]);
+  });
+
+  it('throws AuthRequiredError when the browser session has no token', async () => {
+    await expect(command.func(createPage(null), {})).rejects.toBeInstanceOf(AuthRequiredError);
+  });
+
+  it('maps Flomo auth failures to AuthRequiredError', async () => {
+    mockFetchJson({ code: 401, message: 'unauthorized' });
+    await expect(command.func(createPage(), {})).rejects.toBeInstanceOf(AuthRequiredError);
+  });
+
+  it('maps HTTP, malformed JSON, malformed data, and empty results to typed errors', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: false, status: 500, json: vi.fn() }));
+    await expect(command.func(createPage(), {})).rejects.toBeInstanceOf(CommandExecutionError);
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true, status: 200, json: vi.fn().mockRejectedValue(new Error('bad json')) }));
+    await expect(command.func(createPage(), {})).rejects.toBeInstanceOf(CommandExecutionError);
+
+    mockFetchJson({ code: 0, data: {} });
+    await expect(command.func(createPage(), {})).rejects.toBeInstanceOf(CommandExecutionError);
+
+    mockFetchJson({ code: 0, data: [] });
+    await expect(command.func(createPage(), {})).rejects.toBeInstanceOf(EmptyResultError);
+  });
+});

package/clis/gitee/search.js

@@ -123,8 +123,8 @@ cli({
             rows.push({
                 rank: rows.length + 1,
                 name,
-                language: normalizeText(getFirstText(fields.langs)) || '-',
-                description: normalizeText(getFirstText(fields.description)) || '-',
+                language: normalizeText(getFirstText(fields.langs)) || '',
+                description: normalizeText(getFirstText(fields.description)) || '',
                 stars: normalizeStars(fields['count.star']),
                 url: repoUrl,
             });

package/clis/gitee/search.test.js

@@ -0,0 +1,65 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './search.js';
+
+function mockGiteeResponse(hits) {
+    return {
+        ok: true,
+        json: () => Promise.resolve({ hits: { hits } }),
+    };
+}
+
+function makePage() {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+    };
+}
+
+describe('gitee search', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+
+    it('emits empty-string for missing language / description instead of a sentinel', async () => {
+        const cmd = getRegistry().get('gitee/search');
+        expect(cmd?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn().mockResolvedValue(mockGiteeResponse([
+            {
+                fields: {
+                    title: 'someuser/no-meta-repo',
+                    url: 'https://gitee.com/someuser/no-meta-repo',
+                },
+            },
+        ]));
+        vi.stubGlobal('fetch', fetchMock);
+        const rows = await cmd.func(makePage(), { keyword: 'test', limit: 10 });
+        expect(rows).toHaveLength(1);
+        expect(rows[0].name).toBe('someuser/no-meta-repo');
+        expect(rows[0].language).toBe('');
+        expect(rows[0].description).toBe('');
+    });
+
+    it('passes through populated language / description verbatim', async () => {
+        const cmd = getRegistry().get('gitee/search');
+        const fetchMock = vi.fn().mockResolvedValue(mockGiteeResponse([
+            {
+                fields: {
+                    title: 'org/repo-a',
+                    url: 'https://gitee.com/org/repo-a',
+                    langs: 'TypeScript',
+                    description: 'A test repo',
+                    'count.star': '42',
+                },
+            },
+        ]));
+        vi.stubGlobal('fetch', fetchMock);
+        const rows = await cmd.func(makePage(), { keyword: 'test', limit: 10 });
+        expect(rows[0].language).toBe('TypeScript');
+        expect(rows[0].description).toBe('A test repo');
+        expect(rows[0].stars).toBe('42');
+    });
+});

package/clis/jike/post.js

@@ -1,4 +1,5 @@
 import { cli } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
 cli({
     site: 'jike',
     name: 'post',
@@ -16,16 +17,16 @@ cli({
         },
     ],
     columns: ['type', 'author', 'content', 'likes', 'time'],
-    pipeline: [
-        { navigate: 'https://m.okjike.com/originalPosts/${{ args.id }}' },
-        { evaluate: `(() => {
+    func: async (page, args) => {
+        await page.goto(`https://m.okjike.com/originalPosts/${args.id}`);
+        const data = await page.evaluate(`(() => {
+  const el = document.querySelector('script[type="application/json"]');
+  if (!el) return { ok: false, reason: 'missing-data-script' };
   try {
-    const el = document.querySelector('script[type="application/json"]');
-    if (!el) return [];
-    const data = JSON.parse(el.textContent);
+    const data = JSON.parse(el.textContent || '{}');
     const pageProps = data?.props?.pageProps || {};
     const post = pageProps.post || {};
-    const comments = pageProps.comments || [];
+    const comments = Array.isArray(pageProps.comments) ? pageProps.comments : [];
 
     const result = [{
       type: 'post',
@@ -47,16 +48,25 @@ cli({
 
     return result;
   } catch (e) {
-    return [];
+    return { ok: false, reason: 'parse-error', message: e?.message || String(e) };
   }
 })()
-` },
-        { map: {
-                type: '${{ item.type }}',
-                author: '${{ item.author }}',
-                content: '${{ item.content }}',
-                likes: '${{ item.likes }}',
-                time: '${{ item.time }}',
-            } },
-    ],
+`);
+        if (Array.isArray(data)) {
+            return data.map((item) => ({
+                type: item.type ?? '',
+                author: item.author ?? '',
+                content: item.content ?? '',
+                likes: item.likes ?? 0,
+                time: item.time ?? '',
+            }));
+        }
+        if (data?.reason === 'missing-data-script') {
+            throw new CommandExecutionError('Jike post page did not expose the expected data script');
+        }
+        if (data?.reason === 'parse-error') {
+            throw new CommandExecutionError(`Failed to parse Jike post data: ${data.message || 'unknown error'}`);
+        }
+        throw new CommandExecutionError('Jike post returned an unreadable payload');
+    },
 });

package/clis/jike/read.test.js

@@ -0,0 +1,86 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './post.js';
+import './topic.js';
+import './user.js';
+
+function makePage(evaluateResult) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(evaluateResult),
+    };
+}
+
+describe('jike read commands', () => {
+    it('maps post rows from the browser-side extractor', async () => {
+        const command = getRegistry().get('jike/post');
+        const page = makePage([
+            { type: 'post', author: 'alice', content: 'hello', likes: 3, time: '2026-05-16' },
+            { type: 'comment', author: 'bob', content: 'nice', likes: 1, time: '2026-05-16' },
+        ]);
+
+        await expect(command.func(page, { id: 'post-1' })).resolves.toEqual([
+            { type: 'post', author: 'alice', content: 'hello', likes: 3, time: '2026-05-16' },
+            { type: 'comment', author: 'bob', content: 'nice', likes: 1, time: '2026-05-16' },
+        ]);
+        expect(page.goto).toHaveBeenCalledWith('https://m.okjike.com/originalPosts/post-1');
+    });
+
+    it('maps topic rows and applies limit on the Node side', async () => {
+        const command = getRegistry().get('jike/topic');
+        const page = makePage([
+            { id: 'a', content: 'one', author: 'alice', likes: 1, comments: 2, time: 't1' },
+            { id: 'b', content: 'two', author: 'bob', likes: 3, comments: 4, time: 't2' },
+        ]);
+
+        await expect(command.func(page, { id: 'topic-1', limit: 1 })).resolves.toEqual([
+            {
+                content: 'one',
+                author: 'alice',
+                likes: 1,
+                comments: 2,
+                time: 't1',
+                url: 'https://web.okjike.com/originalPost/a',
+            },
+        ]);
+        expect(page.goto).toHaveBeenCalledWith('https://m.okjike.com/topics/topic-1');
+    });
+
+    it('maps user rows and applies limit on the Node side', async () => {
+        const command = getRegistry().get('jike/user');
+        const page = makePage([
+            { id: 'a', content: 'one', type: 'post', likes: 1, comments: 2, time: 't1' },
+            { id: 'b', content: 'two', type: 'repost', likes: 3, comments: 4, time: 't2' },
+        ]);
+
+        await expect(command.func(page, { username: 'alice', limit: 1 })).resolves.toEqual([
+            {
+                id: 'a',
+                content: 'one',
+                type: 'post',
+                likes: 1,
+                comments: 2,
+                time: 't1',
+                url: 'https://web.okjike.com/originalPost/a',
+            },
+        ]);
+        expect(page.goto).toHaveBeenCalledWith('https://m.okjike.com/users/alice');
+    });
+
+    it('throws CommandExecutionError for malformed browser-side payloads', async () => {
+        await expect(getRegistry().get('jike/post').func(makePage({ reason: 'missing-data-script' }), { id: 'post-1' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+        await expect(getRegistry().get('jike/topic').func(makePage({ reason: 'parse-error', message: 'bad json' }), { id: 'topic-1' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+        await expect(getRegistry().get('jike/user').func(makePage(null), { username: 'alice' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws EmptyResultError when topic or user extractors return no posts', async () => {
+        await expect(getRegistry().get('jike/topic').func(makePage([]), { id: 'topic-1' }))
+            .rejects.toBeInstanceOf(EmptyResultError);
+        await expect(getRegistry().get('jike/user').func(makePage([]), { username: 'alice' }))
+            .rejects.toBeInstanceOf(EmptyResultError);
+    });
+});

package/clis/jike/topic.js

@@ -1,4 +1,5 @@
 import { cli } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
 cli({
     site: 'jike',
     name: 'topic',
@@ -17,15 +18,16 @@ cli({
         { name: 'limit', type: 'int', default: 20, help: 'Number of posts' },
     ],
     columns: ['content', 'author', 'likes', 'comments', 'time', 'url'],
-    pipeline: [
-        { navigate: 'https://m.okjike.com/topics/${{ args.id }}' },
-        { evaluate: `(() => {
+    func: async (page, args) => {
+        await page.goto(`https://m.okjike.com/topics/${args.id}`);
+        const limit = Number(args.limit) || 20;
+        const data = await page.evaluate(`(() => {
+  const el = document.querySelector('script[type="application/json"]');
+  if (!el) return { ok: false, reason: 'missing-data-script' };
   try {
-    const el = document.querySelector('script[type="application/json"]');
-    if (!el) return [];
-    const data = JSON.parse(el.textContent);
+    const data = JSON.parse(el.textContent || '{}');
     const pageProps = data?.props?.pageProps || {};
-    const posts = pageProps.posts || [];
+    const posts = Array.isArray(pageProps.posts) ? pageProps.posts : [];
     return posts.map(p => ({
       content: (p.content || '').replace(/\\n/g, ' ').slice(0, 80),
       author: p.user?.screenName || '',
@@ -35,18 +37,29 @@ cli({
       id: p.id || '',
     }));
   } catch (e) {
-    return [];
+    return { ok: false, reason: 'parse-error', message: e?.message || String(e) };
   }
 })()
-` },
-        { map: {
-                content: '${{ item.content }}',
-                author: '${{ item.author }}',
-                likes: '${{ item.likes }}',
-                comments: '${{ item.comments }}',
-                time: '${{ item.time }}',
-                url: 'https://web.okjike.com/originalPost/${{ item.id }}',
-            } },
-        { limit: '${{ args.limit }}' },
-    ],
+`);
+        if (Array.isArray(data)) {
+            if (data.length === 0) {
+                throw new EmptyResultError('jike topic', `No posts were returned for topic ${args.id}. Confirm the topic ID and login state.`);
+            }
+            return data.slice(0, limit).map((item) => ({
+                content: item.content ?? '',
+                author: item.author ?? '',
+                likes: item.likes ?? 0,
+                comments: item.comments ?? 0,
+                time: item.time ?? '',
+                url: `https://web.okjike.com/originalPost/${item.id ?? ''}`,
+            }));
+        }
+        if (data?.reason === 'missing-data-script') {
+            throw new CommandExecutionError('Jike topic page did not expose the expected data script');
+        }
+        if (data?.reason === 'parse-error') {
+            throw new CommandExecutionError(`Failed to parse Jike topic data: ${data.message || 'unknown error'}`);
+        }
+        throw new CommandExecutionError('Jike topic returned an unreadable payload');
+    },
 });