@jackwener/opencli 1.5.5 → 1.5.7

package/src/clis/zsxq/utils.ts

@@ -0,0 +1,351 @@
+import { ArgumentError, AuthRequiredError, CliError } from '../../errors.js';
+import type { IPage } from '../../types.js';
+
+export interface ZsxqUser {
+  user_id?: number;
+  name?: string;
+  avatar_url?: string;
+}
+
+export interface ZsxqGroup {
+  group_id?: number;
+  name?: string;
+  description?: string;
+  background_url?: string;
+  owner?: ZsxqUser;
+  statistics?: {
+    topics_count?: number;
+    answers_count?: number;
+    comments_count?: number;
+    likes_count?: number;
+    subscriptions_count?: number;
+  };
+  category?: {
+    title?: string;
+  };
+  user_specific?: {
+    join_time?: string;
+    validity?: {
+      end_time?: string;
+    };
+  };
+}
+
+export interface ZsxqComment {
+  comment_id?: number;
+  create_time?: string;
+  text?: string;
+  owner?: ZsxqUser;
+  likes_count?: number;
+  rewards_count?: number;
+  repliee?: ZsxqUser;
+}
+
+export interface ZsxqTopic {
+  topic_id?: number;
+  create_time?: string;
+  comments_count?: number;
+  likes_count?: number;
+  readers_count?: number;
+  reading_count?: number;
+  rewards_count?: number;
+  title?: string;
+  type?: string;
+  group?: ZsxqGroup;
+  owner?: ZsxqUser;
+  user_specific?: Record<string, unknown>;
+  talk?: {
+    owner?: ZsxqUser;
+    text?: string;
+  };
+  question?: {
+    owner?: ZsxqUser;
+    text?: string;
+  };
+  answer?: {
+    owner?: ZsxqUser;
+    text?: string;
+  };
+  task?: {
+    owner?: ZsxqUser;
+    text?: string;
+  };
+  solution?: {
+    owner?: ZsxqUser;
+    text?: string;
+  };
+  show_comments?: ZsxqComment[];
+  comments?: ZsxqComment[];
+}
+
+export interface BrowserFetchResult {
+  ok: boolean;
+  url?: string;
+  status?: number;
+  error?: string;
+  data?: unknown;
+}
+
+const SITE_DOMAIN = 'wx.zsxq.com';
+const SITE_URL = 'https://wx.zsxq.com';
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+function pickArray<T>(...values: unknown[]): T[] {
+  for (const value of values) {
+    if (Array.isArray(value)) {
+      return value as T[];
+    }
+  }
+  return [];
+}
+
+export async function ensureZsxqPage(page: IPage): Promise<void> {
+  await page.goto(SITE_URL);
+}
+
+export async function ensureZsxqAuth(page: IPage): Promise<void> {
+  // zsxq uses httpOnly cookies that may be on different subdomains.
+  // Verify auth by attempting a lightweight API call instead of checking cookies.
+  try {
+    const result = await page.evaluate(`
+      (async () => {
+        try {
+          const r = await new Promise((resolve, reject) => {
+            const xhr = new XMLHttpRequest();
+            xhr.open('GET', 'https://api.zsxq.com/v2/groups', true);
+            xhr.withCredentials = true;
+            xhr.setRequestHeader('accept', 'application/json');
+            xhr.onload = () => {
+              if (xhr.status >= 200 && xhr.status < 300) {
+                try { resolve(JSON.parse(xhr.responseText)); }
+                catch { resolve(null); }
+              } else { resolve(null); }
+            };
+            xhr.onerror = () => resolve(null);
+            xhr.send();
+          });
+          return r !== null;
+        } catch { return false; }
+      })()
+    `);
+    if (!result) {
+      throw new AuthRequiredError('zsxq.com');
+    }
+  } catch (err) {
+    if (err instanceof AuthRequiredError) throw err;
+    throw new AuthRequiredError('zsxq.com');
+  }
+}
+
+export async function getCookieValue(page: IPage, name: string): Promise<string | undefined> {
+  const cookies = await page.getCookies({ domain: SITE_DOMAIN });
+  return cookies.find(cookie => cookie.name === name)?.value;
+}
+
+export async function getActiveGroupId(page: IPage): Promise<string> {
+  const groupId = await page.evaluate(`
+    (() => {
+      const target = localStorage.getItem('target_group');
+      if (target) {
+        try {
+          const parsed = JSON.parse(target);
+          if (parsed.group_id) return String(parsed.group_id);
+        } catch {}
+      }
+      return null;
+    })()
+  `);
+  if (groupId) return groupId;
+
+  throw new ArgumentError(
+    'Cannot determine active group_id',
+    'Pass --group_id <id> or open the target 知识星球 page in Chrome first',
+  );
+}
+
+export async function browserJsonRequest(page: IPage, path: string): Promise<BrowserFetchResult> {
+  return await page.evaluate(`
+    (async () => {
+      const path = ${JSON.stringify(path)};
+
+      try {
+        return await new Promise((resolve) => {
+          const xhr = new XMLHttpRequest();
+          xhr.open('GET', path, true);
+          xhr.withCredentials = true;
+          xhr.setRequestHeader('accept', 'application/json, text/plain, */*');
+          xhr.onload = () => {
+            let parsed = null;
+            if (xhr.responseText) {
+              try { parsed = JSON.parse(xhr.responseText); }
+              catch {}
+            }
+
+            resolve({
+              ok: xhr.status >= 200 && xhr.status < 300,
+              url: path,
+              status: xhr.status,
+              data: parsed,
+              error: xhr.status >= 200 && xhr.status < 300 ? undefined : 'HTTP ' + xhr.status,
+            });
+          };
+          xhr.onerror = () => resolve({
+            ok: false,
+            url: path,
+            error: 'Network error',
+          });
+          xhr.send();
+        });
+      } catch (error) {
+        return {
+          ok: false,
+          url: path,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
+    })()
+  `) as BrowserFetchResult;
+}
+
+export async function fetchFirstJson(page: IPage, paths: string[]): Promise<BrowserFetchResult> {
+  let lastFailure: BrowserFetchResult | null = null;
+
+  for (const path of paths) {
+    const result = await browserJsonRequest(page, path);
+    if (result.ok) {
+      return result;
+    }
+    lastFailure = result;
+  }
+
+  if (!lastFailure) {
+    throw new CliError(
+      'FETCH_ERROR',
+      'No candidate endpoint returned JSON',
+      `Checked endpoints: ${paths.join(', ')}`,
+    );
+  }
+
+  throw new CliError(
+    'FETCH_ERROR',
+    lastFailure.error || 'Failed to fetch ZSXQ API',
+    `Checked endpoints: ${paths.join(', ')}`,
+  );
+}
+
+export function unwrapRespData<T>(payload: unknown): T {
+  const record = asRecord(payload);
+  if (!record) {
+    throw new CliError('PARSE_ERROR', 'Invalid ZSXQ API response');
+  }
+
+  if (record.succeeded === false) {
+    const code = typeof record.code === 'number' ? String(record.code) : 'API_ERROR';
+    const message = typeof record.info === 'string'
+      ? record.info
+      : typeof record.error === 'string'
+        ? record.error
+        : 'ZSXQ API returned an error';
+    throw new CliError(code, message);
+  }
+
+  return (record.resp_data ?? record.data ?? payload) as T;
+}
+
+export function getTopicsFromResponse(payload: unknown): ZsxqTopic[] {
+  const data = unwrapRespData<Record<string, unknown> | ZsxqTopic[]>(payload);
+  if (Array.isArray(data)) return data;
+  return pickArray<ZsxqTopic>(
+    data.topics,
+    data.list,
+    data.records,
+    data.items,
+    data.search_result,
+  );
+}
+
+export function getCommentsFromResponse(payload: unknown): ZsxqComment[] {
+  const data = unwrapRespData<Record<string, unknown> | ZsxqComment[]>(payload);
+  if (Array.isArray(data)) return data;
+  return pickArray<ZsxqComment>(data.comments, data.list, data.items);
+}
+
+export function getGroupsFromResponse(payload: unknown): ZsxqGroup[] {
+  const data = unwrapRespData<Record<string, unknown> | ZsxqGroup[]>(payload);
+  if (Array.isArray(data)) return data;
+  return pickArray<ZsxqGroup>(data.groups, data.list, data.items);
+}
+
+export function getTopicFromResponse(payload: unknown): ZsxqTopic | null {
+  const data = unwrapRespData<Record<string, unknown> | ZsxqTopic>(payload);
+  if (Array.isArray(data)) return data[0] ?? null;
+  if (typeof data.topic_id === 'number') return data;
+  const record = asRecord(data);
+  if (!record) return null;
+  const topic = record.topic;
+  return topic && typeof topic === 'object' ? topic as ZsxqTopic : null;
+}
+
+export function getTopicAuthor(topic: ZsxqTopic): string {
+  return (
+    topic.owner?.name ||
+    topic.talk?.owner?.name ||
+    topic.question?.owner?.name ||
+    topic.answer?.owner?.name ||
+    topic.task?.owner?.name ||
+    topic.solution?.owner?.name ||
+    ''
+  );
+}
+
+export function getTopicText(topic: ZsxqTopic): string {
+  const primary = [
+    topic.title,
+    topic.talk?.text,
+    topic.question?.text,
+    topic.answer?.text,
+    topic.task?.text,
+    topic.solution?.text,
+  ].find(value => typeof value === 'string' && value.trim());
+  return (primary || '').replace(/\s+/g, ' ').trim();
+}
+
+export function getTopicUrl(topicId: number | string | undefined): string {
+  return topicId ? `${SITE_URL}/topic/${topicId}` : SITE_URL;
+}
+
+export function summarizeComments(comments: ZsxqComment[], limit: number = 3): string {
+  return comments
+    .slice(0, limit)
+    .map((comment) => {
+      const author = comment.owner?.name || '匿名';
+      const target = comment.repliee?.name ? ` -> ${comment.repliee.name}` : '';
+      const text = (comment.text || '').replace(/\s+/g, ' ').trim();
+      return `${author}${target}: ${text}`;
+    })
+    .join(' | ');
+}
+
+export function toTopicRow(topic: ZsxqTopic): Record<string, unknown> {
+  const topicId = topic.topic_id ?? '';
+  const comments = pickArray<ZsxqComment>(topic.show_comments, topic.comments);
+  return {
+    topic_id: topicId,
+    type: topic.type || '',
+    group: topic.group?.name || '',
+    author: getTopicAuthor(topic),
+    title: getTopicText(topic).slice(0, 120),
+    content: getTopicText(topic),
+    comments: topic.comments_count ?? comments.length ?? 0,
+    likes: topic.likes_count ?? 0,
+    readers: topic.readers_count ?? topic.reading_count ?? 0,
+    time: topic.create_time || '',
+    comment_preview: summarizeComments(comments),
+    url: getTopicUrl(topicId),
+  };
+}

package/src/commanderAdapter.test.ts

@@ -76,3 +76,80 @@ describe('commanderAdapter arg passing', () => {
     expect(mockExecuteCommand).not.toHaveBeenCalled();
   });
 });
+
+describe('commanderAdapter boolean alias support', () => {
+  const cmd: CliCommand = {
+    site: 'reddit',
+    name: 'save',
+    description: 'Save a post',
+    browser: false,
+    args: [
+      { name: 'post-id', positional: true, required: true, help: 'Post ID' },
+      { name: 'undo', type: 'boolean', default: false, help: 'Unsave instead of save' },
+    ],
+    func: vi.fn(),
+  };
+
+  beforeEach(() => {
+    mockExecuteCommand.mockReset();
+    mockExecuteCommand.mockResolvedValue([]);
+    mockRenderOutput.mockReset();
+    delete process.env.OPENCLI_VERBOSE;
+    process.exitCode = undefined;
+  });
+
+  it('coerces default false for boolean args to a real boolean', async () => {
+    const program = new Command();
+    const siteCmd = program.command('reddit');
+    registerCommandToProgram(siteCmd, cmd);
+
+    await program.parseAsync(['node', 'opencli', 'reddit', 'save', 't3_abc123']);
+
+    expect(mockExecuteCommand).toHaveBeenCalled();
+    const kwargs = mockExecuteCommand.mock.calls[0][1];
+    expect(kwargs['post-id']).toBe('t3_abc123');
+    expect(kwargs.undo).toBe(false);
+  });
+
+  it('coerces explicit false for boolean args to a real boolean', async () => {
+    const program = new Command();
+    const siteCmd = program.command('reddit');
+    registerCommandToProgram(siteCmd, cmd);
+
+    await program.parseAsync(['node', 'opencli', 'reddit', 'save', 't3_abc123', '--undo', 'false']);
+
+    expect(mockExecuteCommand).toHaveBeenCalled();
+    const kwargs = mockExecuteCommand.mock.calls[0][1];
+    expect(kwargs.undo).toBe(false);
+  });
+});
+
+describe('commanderAdapter command aliases', () => {
+  const cmd: CliCommand = {
+    site: 'notebooklm',
+    name: 'get',
+    aliases: ['metadata'],
+    description: 'Get notebook metadata',
+    browser: false,
+    args: [],
+    func: vi.fn(),
+  };
+
+  beforeEach(() => {
+    mockExecuteCommand.mockReset();
+    mockExecuteCommand.mockResolvedValue([]);
+    mockRenderOutput.mockReset();
+    delete process.env.OPENCLI_VERBOSE;
+    process.exitCode = undefined;
+  });
+
+  it('registers aliases with Commander so compatibility names execute the same command', async () => {
+    const program = new Command();
+    const siteCmd = program.command('notebooklm');
+    registerCommandToProgram(siteCmd, cmd);
+
+    await program.parseAsync(['node', 'opencli', 'notebooklm', 'metadata']);
+
+    expect(mockExecuteCommand).toHaveBeenCalledWith(cmd, {}, false);
+  });
+});

package/src/commanderAdapter.ts

@@ -33,7 +33,7 @@ import {
 import { checkDaemonStatus } from './browser/discover.js';
 
 export function normalizeArgValue(argType: string | undefined, value: unknown, name: string): unknown {
-  if (argType !== 'bool') return value;
+  if (argType !== 'bool' && argType !== 'boolean') return value;
   if (typeof value === 'boolean') return value;
   if (value == null || value === '') return false;
 
@@ -52,6 +52,7 @@ export function registerCommandToProgram(siteCmd: Command, cmd: CliCommand): voi
 
   const deprecatedSuffix = cmd.deprecated ? ' [deprecated]' : '';
   const subCmd = siteCmd.command(cmd.name).description(`${cmd.description}${deprecatedSuffix}`);
+  if (cmd.aliases?.length) subCmd.aliases(cmd.aliases);
 
   // Register positional args first, then named options
   const positionalArgs: typeof cmd.args = [];
@@ -103,6 +104,9 @@ export function registerCommandToProgram(siteCmd: Command, cmd: CliCommand): voi
       }
 
       const result = await executeCommand(cmd, kwargs, verbose);
+      if (result === null || result === undefined) {
+        return;
+      }
 
       if (verbose && (!result || (Array.isArray(result) && result.length === 0))) {
         console.error(chalk.yellow('[Verbose] Warning: Command returned an empty result.'));
@@ -293,7 +297,10 @@ export function registerAllCommands(
   program: Command,
   siteGroups: Map<string, Command>,
 ): void {
+  const seen = new Set<CliCommand>();
   for (const [, cmd] of getRegistry()) {
+    if (seen.has(cmd)) continue;
+    seen.add(cmd);
     let siteCmd = siteGroups.get(cmd.site);
     if (!siteCmd) {
       siteCmd = program.command(cmd.site).description(`${cmd.site} commands`);

package/src/commands/daemon.test.ts

@@ -0,0 +1,238 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+vi.mock('chalk', () => ({
+  default: {
+    green: (s: string) => s,
+    yellow: (s: string) => s,
+    red: (s: string) => s,
+    dim: (s: string) => s,
+  },
+}));
+
+const mockConnect = vi.fn();
+vi.mock('../browser/mcp.js', () => ({
+  BrowserBridge: class {
+    connect = mockConnect;
+  },
+}));
+
+import { daemonStatus, daemonStop, daemonRestart } from './daemon.js';
+
+describe('daemon commands', () => {
+  let logSpy: ReturnType<typeof vi.spyOn>;
+  let errorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    mockConnect.mockReset();
+  });
+
+  describe('daemonStatus', () => {
+    it('shows "not running" when daemon is unreachable', async () => {
+      vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('ECONNREFUSED')));
+
+      await daemonStatus();
+
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
+    });
+
+    it('shows "not running" when daemon returns non-ok response', async () => {
+      vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: false }));
+
+      await daemonStatus();
+
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
+    });
+
+    it('shows daemon info when running', async () => {
+      const status = {
+        ok: true,
+        pid: 12345,
+        uptime: 3661,
+        extensionConnected: true,
+        pending: 0,
+        lastCliRequestTime: Date.now() - 30_000,
+        memoryMB: 64,
+        port: 19825,
+      };
+
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          ok: true,
+          json: () => Promise.resolve(status),
+        }),
+      );
+
+      await daemonStatus();
+
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('running'));
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('PID 12345'));
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('1h 1m'));
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('connected'));
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('64 MB'));
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('19825'));
+    });
+
+    it('shows disconnected when extension is not connected', async () => {
+      const status = {
+        ok: true,
+        pid: 99,
+        uptime: 120,
+        extensionConnected: false,
+        pending: 0,
+        lastCliRequestTime: Date.now() - 5000,
+        memoryMB: 32,
+        port: 19825,
+      };
+
+      vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+          ok: true,
+          json: () => Promise.resolve(status),
+        }),
+      );
+
+      await daemonStatus();
+
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('disconnected'));
+    });
+  });
+
+  describe('daemonStop', () => {
+    it('reports "not running" when daemon is unreachable', async () => {
+      vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('ECONNREFUSED')));
+
+      await daemonStop();
+
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('not running'));
+    });
+
+    it('sends shutdown and reports success', async () => {
+      const statusResponse = {
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            ok: true,
+            pid: 12345,
+            uptime: 100,
+            extensionConnected: true,
+            pending: 0,
+            lastCliRequestTime: Date.now(),
+            memoryMB: 50,
+            port: 19825,
+          }),
+      };
+      const shutdownResponse = { ok: true };
+
+      const mockFetch = vi.fn()
+        .mockResolvedValueOnce(statusResponse)
+        .mockResolvedValueOnce(shutdownResponse);
+      vi.stubGlobal('fetch', mockFetch);
+
+      await daemonStop();
+
+      // Verify shutdown was called with POST
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+      const shutdownCall = mockFetch.mock.calls[1];
+      expect(shutdownCall[0]).toContain('/shutdown');
+      expect(shutdownCall[1]).toMatchObject({ method: 'POST' });
+
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Daemon stopped'));
+    });
+
+    it('reports failure when shutdown request fails', async () => {
+      const statusResponse = {
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            ok: true,
+            pid: 12345,
+            uptime: 100,
+            extensionConnected: true,
+            pending: 0,
+            lastCliRequestTime: Date.now(),
+            memoryMB: 50,
+            port: 19825,
+          }),
+      };
+      const shutdownResponse = { ok: false };
+
+      const mockFetch = vi.fn()
+        .mockResolvedValueOnce(statusResponse)
+        .mockResolvedValueOnce(shutdownResponse);
+      vi.stubGlobal('fetch', mockFetch);
+
+      await daemonStop();
+
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon'));
+    });
+  });
+
+  describe('daemonRestart', () => {
+    const statusData = {
+      ok: true,
+      pid: 12345,
+      uptime: 100,
+      extensionConnected: true,
+      pending: 0,
+      lastCliRequestTime: Date.now(),
+      memoryMB: 50,
+      port: 19825,
+    };
+
+    it('starts daemon directly when not running', async () => {
+      vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('ECONNREFUSED')));
+      mockConnect.mockResolvedValue(undefined);
+
+      await daemonRestart();
+
+      expect(mockConnect).toHaveBeenCalledWith({ timeout: 10 });
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Daemon restarted'));
+    });
+
+    it('stops then starts when daemon is running', async () => {
+      const mockFetch = vi.fn()
+        // First call: fetchStatus in daemonRestart — daemon is running
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(statusData) })
+        // Second call: requestShutdown — success
+        .mockResolvedValueOnce({ ok: true })
+        // Subsequent calls: polling fetchStatus until unreachable
+        .mockRejectedValue(new Error('ECONNREFUSED'));
+
+      vi.stubGlobal('fetch', mockFetch);
+      mockConnect.mockResolvedValue(undefined);
+
+      await daemonRestart();
+
+      // Verify shutdown was called
+      const shutdownCall = mockFetch.mock.calls[1];
+      expect(shutdownCall[0]).toContain('/shutdown');
+      expect(shutdownCall[1]).toMatchObject({ method: 'POST' });
+
+      expect(mockConnect).toHaveBeenCalledWith({ timeout: 10 });
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Daemon restarted'));
+    });
+
+    it('aborts when shutdown fails', async () => {
+      const mockFetch = vi.fn()
+        // fetchStatus — daemon is running
+        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(statusData) })
+        // requestShutdown — failure
+        .mockResolvedValueOnce({ ok: false });
+
+      vi.stubGlobal('fetch', mockFetch);
+
+      await daemonRestart();
+
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to stop daemon'));
+      expect(mockConnect).not.toHaveBeenCalled();
+    });
+  });
+});