@jackwener/opencli 1.7.22 → 1.8.1

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/geogebra/add-circle.js

@@ -0,0 +1,46 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { ensureApplet, ggbEval, normalizeLabel, normalizeNumber, requireGgbSuccess } from './utils.js';
+
+cli({
+  site: 'geogebra',
+  name: 'add-circle',
+  access: 'write',
+  description: 'Create a circle by center+radius or center+point',
+  domain: 'www.geogebra.org',
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  navigateBefore: false,
+  example: 'opencli geogebra add-circle --center A --radius 3',
+  args: [
+    { name: 'center', required: true, help: 'Center point label (e.g. A)' },
+    { name: 'radius', required: false, help: 'Radius value (number) or a point label on the circle' },
+    { name: 'point', required: false, help: 'Alternative: a point label on the circle (use instead of --radius for Circle(center,point))' },
+  ],
+  columns: ['label', 'center', 'radius'],
+  func: async (page, kwargs) => {
+    const center = normalizeLabel(kwargs.center, 'center');
+    if (kwargs.point && kwargs.radius !== undefined) {
+      throw new ArgumentError('Use either --point or --radius, not both');
+    }
+    const pointOnCircle = kwargs.point ? normalizeLabel(kwargs.point, 'point') : '';
+    const radiusValue = kwargs.radius;
+
+    let cmd;
+    if (pointOnCircle) {
+      cmd = `Circle(${center},${pointOnCircle})`;
+    } else if (radiusValue !== undefined) {
+      const raw = String(radiusValue).trim();
+      const num = Number(raw);
+      cmd = Number.isFinite(num)
+        ? `Circle(${center},${normalizeNumber(raw, 'radius', { positive: true })})`
+        : `Circle(${center},${normalizeLabel(raw, 'radius point')})`;
+    } else {
+      throw new ArgumentError('Provide --radius (number or point label) or --point (point on circle)');
+    }
+
+    await ensureApplet(page);
+    const result = requireGgbSuccess(await ggbEval(page, cmd), `Failed to create circle: ${cmd}`);
+    return [{ label: result.label, center, radius: pointOnCircle || radiusValue }];
+  },
+});

package/clis/geogebra/add-line.js

@@ -0,0 +1,35 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { ensureApplet, ggbEval, normalizeLabelList, requireGgbSuccess } from './utils.js';
+
+cli({
+  site: 'geogebra',
+  name: 'add-line',
+  access: 'write',
+  description: 'Create a line through two points or a segment between two points',
+  domain: 'www.geogebra.org',
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  navigateBefore: false,
+  example: 'opencli geogebra add-line --points A,B --type segment',
+  args: [
+    { name: 'points', required: true, help: 'Two point labels separated by comma (e.g. "A,B")' },
+    { name: 'type', required: false, choices: ['line', 'segment', 'ray'], default: 'line', help: 'Type: line, segment, or ray (default: line)' },
+  ],
+  columns: ['label', 'type', 'points'],
+  func: async (page, kwargs) => {
+    const [a, b] = normalizeLabelList(kwargs.points, 'points', 2, 2);
+    const type = kwargs.type || 'line';
+    const geogebraCmd = {
+      line: `Line(${a},${b})`,
+      segment: `Segment(${a},${b})`,
+      ray: `Ray(${a},${b})`,
+    }[type];
+    if (!geogebraCmd) {
+      throw new ArgumentError('type must be one of: line, segment, ray');
+    }
+    await ensureApplet(page);
+    const result = requireGgbSuccess(await ggbEval(page, geogebraCmd), `Failed to create ${type}: ${geogebraCmd}`);
+    return [{ label: result.label, type, points: `${a},${b}` }];
+  },
+});

package/clis/geogebra/add-point.js

@@ -0,0 +1,27 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ensureApplet, ggbEval, normalizeCoords, normalizeLabel, requireGgbSuccess } from './utils.js';
+
+cli({
+  site: 'geogebra',
+  name: 'add-point',
+  access: 'write',
+  description: 'Create a point with given label and coordinates',
+  domain: 'www.geogebra.org',
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  navigateBefore: false,
+  example: 'opencli geogebra add-point --name A --coords 1,2',
+  args: [
+    { name: 'name', required: true, help: 'Point label (e.g. A, B, P1)' },
+    { name: 'coords', required: true, help: 'Coordinates as x,y (e.g. "1,2")' },
+  ],
+  columns: ['name', 'x', 'y'],
+  func: async (page, kwargs) => {
+    const name = normalizeLabel(kwargs.name, 'name');
+    const [x, y] = normalizeCoords(kwargs.coords);
+    const cmd = `${name}=(${x},${y})`;
+    await ensureApplet(page);
+    const result = requireGgbSuccess(await ggbEval(page, cmd), `Failed to create point: ${cmd}`);
+    return [{ name, x, y }];
+  },
+});

package/clis/geogebra/add-polygon.js

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ensureApplet, ggbEval, normalizeLabelList, requireGgbSuccess } from './utils.js';
+
+cli({
+  site: 'geogebra',
+  name: 'add-polygon',
+  access: 'write',
+  description: 'Create a polygon from a list of point labels',
+  domain: 'www.geogebra.org',
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  navigateBefore: false,
+  example: 'opencli geogebra add-polygon --points A,B,C',
+  args: [
+    { name: 'points', required: true, help: 'Comma-separated point labels (e.g. "A,B,C" or "A,B,C,D")' },
+  ],
+  columns: ['label', 'vertices'],
+  func: async (page, kwargs) => {
+    const points = normalizeLabelList(kwargs.points, 'points', 3, 50);
+    const cmd = `Polygon(${points.join(',')})`;
+    await ensureApplet(page);
+    const result = requireGgbSuccess(await ggbEval(page, cmd), `Failed to create polygon: ${cmd}`);
+    return [{ label: result.label, vertices: points.join(',') }];
+  },
+});

package/clis/geogebra/eval.js

@@ -0,0 +1,35 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { ensureApplet, ggbEval, requireGgbSuccess } from './utils.js';
+
+cli({
+  site: 'geogebra',
+  name: 'eval',
+  access: 'write',
+  description: 'Execute one or more GeoGebra command strings (semicolon-separated)',
+  domain: 'www.geogebra.org',
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  navigateBefore: false,
+  example: 'opencli geogebra eval "A=(0,0);B=(4,0);c=Circle(A,B);d=Circle(B,A);C=Intersect(c,d,1);Polygon(A,B,C)"',
+  args: [
+    { name: 'command', positional: true, required: true, help: 'GeoGebra command string (use ; to chain multiple commands)' },
+  ],
+  columns: ['command', 'result'],
+  func: async (page, kwargs) => {
+    const commands = String(kwargs.command).split(';').map(s => s.trim()).filter(Boolean);
+    if (commands.length === 0) {
+      throw new ArgumentError('command must contain at least one GeoGebra command');
+    }
+    await ensureApplet(page);
+    const results = [];
+    for (const command of commands) {
+      const result = requireGgbSuccess(await ggbEval(page, command), `Failed to execute GeoGebra command: ${command}`);
+      results.push({
+        command,
+        result: `ok (${result.label || 'no label'})`,
+      });
+    }
+    return results;
+  },
+});