@jackwener/opencli 1.6.8 → 1.6.10

package/dist/clis/quark/share-tree.js

@@ -0,0 +1,45 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { extractPwdId, formatDate, getShareList, getToken, } from './utils.js';
+async function buildTree(page, pwdId, stoken, pdirFid, depth, maxDepth) {
+    if (depth > maxDepth)
+        return [];
+    const files = await getShareList(page, pwdId, stoken, pdirFid, { sort: 'file_type:asc,file_name:asc' });
+    const nodes = [];
+    for (const file of files) {
+        const node = {
+            fid: file.fid,
+            name: file.file_name,
+            size: file.size,
+            is_dir: file.dir,
+            created_at: formatDate(file.created_at),
+            updated_at: formatDate(file.updated_at),
+        };
+        if (file.dir && depth < maxDepth) {
+            node.children = await buildTree(page, pwdId, stoken, file.fid, depth + 1, maxDepth);
+        }
+        nodes.push(node);
+    }
+    return nodes;
+}
+cli({
+    site: 'quark',
+    name: 'share-tree',
+    description: 'Get directory tree from Quark Drive share link as nested JSON',
+    domain: 'pan.quark.cn',
+    strategy: Strategy.COOKIE,
+    defaultFormat: 'json',
+    args: [
+        { name: 'url', required: true, positional: true, help: 'Quark share URL or pwd_id' },
+        { name: 'passcode', default: '', help: 'Share passcode (if required)' },
+        { name: 'depth', type: 'int', default: 10, help: 'Max directory depth' },
+    ],
+    func: async (page, kwargs) => {
+        const url = kwargs.url;
+        const passcode = kwargs.passcode || '';
+        const depth = kwargs.depth ?? 10;
+        const pwdId = extractPwdId(url);
+        const stoken = await getToken(page, pwdId, passcode);
+        const tree = await buildTree(page, pwdId, stoken, '0', 0, depth);
+        return { pwd_id: pwdId, stoken, tree };
+    },
+});

package/dist/clis/quark/utils.d.ts

@@ -0,0 +1,50 @@
+import type { IPage } from '@jackwener/opencli/types';
+export declare const SHARE_API = "https://drive-h.quark.cn/1/clouddrive/share/sharepage";
+export declare const DRIVE_API = "https://drive-pc.quark.cn/1/clouddrive/file";
+export declare const TASK_API = "https://drive-pc.quark.cn/1/clouddrive/task";
+export interface ApiResponse<T = unknown> {
+    status: number;
+    code: number;
+    message: string;
+    data: T;
+    metadata?: {
+        _total?: number;
+    };
+}
+export interface ShareFile {
+    fid: string;
+    file_name: string;
+    size: number;
+    dir: boolean;
+    created_at: number;
+    updated_at: number;
+}
+export interface DriveFile {
+    fid: string;
+    file_name: string;
+    size: number;
+    dir: boolean;
+}
+export declare function extractPwdId(url: string): string;
+export declare function fetchJson<T = unknown>(page: IPage, url: string, options?: {
+    method?: string;
+    body?: object;
+}): Promise<ApiResponse<T>>;
+export declare function apiGet<T = unknown>(page: IPage, url: string): Promise<T>;
+export declare function apiPost<T = unknown>(page: IPage, url: string, body: object): Promise<T>;
+export declare function getToken(page: IPage, pwdId: string, passcode?: string): Promise<string>;
+export declare function getShareList(page: IPage, pwdId: string, stoken: string, pdirFid?: string, options?: {
+    sort?: string;
+}): Promise<ShareFile[]>;
+export declare function listMyDrive(page: IPage, pdirFid: string): Promise<DriveFile[]>;
+export declare function findFolder(page: IPage, path: string): Promise<string>;
+export declare function formatDate(ts: number): string;
+export declare function formatSize(bytes: number): string;
+export interface TaskStatus {
+    status: number;
+    save_as?: {
+        save_as_sum_num: number;
+    };
+}
+export declare function getTaskStatus(page: IPage, taskId: string): Promise<TaskStatus | null>;
+export declare function pollTask(page: IPage, taskId: string, onDone?: (task: TaskStatus) => void, maxAttempts?: number, intervalMs?: number): Promise<boolean>;

package/dist/clis/quark/utils.js

@@ -0,0 +1,146 @@
+import { ArgumentError, AuthRequiredError, CommandExecutionError, getErrorMessage } from '@jackwener/opencli/errors';
+export const SHARE_API = 'https://drive-h.quark.cn/1/clouddrive/share/sharepage';
+export const DRIVE_API = 'https://drive-pc.quark.cn/1/clouddrive/file';
+export const TASK_API = 'https://drive-pc.quark.cn/1/clouddrive/task';
+const QUARK_DOMAIN = 'pan.quark.cn';
+const AUTH_HINT = 'Quark Drive requires a logged-in browser session';
+function isAuthFailure(message, status) {
+    if (status === 401 || status === 403)
+        return true;
+    return /not logged in|login required|please log in|authentication required|unauthorized|forbidden|未登录|请先登录|需要登录|登录/.test(message.toLowerCase());
+}
+function getErrorStatus(error) {
+    if (!error || typeof error !== 'object' || !('status' in error))
+        return undefined;
+    const status = error.status;
+    return typeof status === 'number' ? status : undefined;
+}
+function unwrapApiData(resp, action) {
+    if (resp.status === 200)
+        return resp.data;
+    if (isAuthFailure(resp.message, resp.status)) {
+        throw new AuthRequiredError(QUARK_DOMAIN, AUTH_HINT);
+    }
+    throw new CommandExecutionError(`quark: ${action}: ${resp.message}`);
+}
+export function extractPwdId(url) {
+    const m = url.match(/\/s\/([a-zA-Z0-9]+)/);
+    if (m)
+        return m[1];
+    if (/^[a-zA-Z0-9]+$/.test(url))
+        return url;
+    throw new ArgumentError(`Invalid Quark share URL: ${url}`);
+}
+export async function fetchJson(page, url, options) {
+    const method = options?.method || 'GET';
+    const body = options?.body ? JSON.stringify(options.body) : undefined;
+    const js = `fetch(${JSON.stringify(url)}, {
+    method: ${JSON.stringify(method)},
+    headers: { 'Content-Type': 'application/json' },
+    credentials: 'include',
+    ${body ? `body: ${JSON.stringify(body)},` : ''}
+  }).then(async r => {
+    const ct = r.headers.get('content-type') || '';
+    if (!ct.includes('json')) {
+      const text = await r.text().catch(() => '');
+      throw Object.assign(new Error('Non-JSON response: ' + text.slice(0, 200)), { status: r.status });
+    }
+    return r.json();
+  })`;
+    try {
+        return await page.evaluate(js);
+    }
+    catch (error) {
+        if (isAuthFailure(getErrorMessage(error), getErrorStatus(error))) {
+            throw new AuthRequiredError(QUARK_DOMAIN, AUTH_HINT);
+        }
+        throw error;
+    }
+}
+export async function apiGet(page, url) {
+    const resp = await fetchJson(page, url);
+    return unwrapApiData(resp, 'API error');
+}
+export async function apiPost(page, url, body) {
+    const resp = await fetchJson(page, url, { method: 'POST', body });
+    return unwrapApiData(resp, 'API error');
+}
+export async function getToken(page, pwdId, passcode = '') {
+    const data = await fetchJson(page, `${SHARE_API}/token?pr=ucpro&fr=pc`, {
+        method: 'POST',
+        body: { pwd_id: pwdId, passcode, support_visit_limit_private_share: true },
+    });
+    return unwrapApiData(data, 'Failed to get token').stoken;
+}
+export async function getShareList(page, pwdId, stoken, pdirFid = '0', options) {
+    const allFiles = [];
+    let pageNum = 1;
+    let total = 0;
+    do {
+        const sortParam = options?.sort ? `&_sort=${options.sort}` : '';
+        const url = `${SHARE_API}/detail?pr=ucpro&fr=pc&ver=2&pwd_id=${pwdId}&stoken=${encodeURIComponent(stoken)}&pdir_fid=${pdirFid}&force=0&_page=${pageNum}&_size=200&_fetch_total=1${sortParam}`;
+        const data = await fetchJson(page, url);
+        const files = unwrapApiData(data, 'Failed to get share list')?.list || [];
+        allFiles.push(...files);
+        total = data.metadata?._total || 0;
+        pageNum++;
+    } while (allFiles.length < total);
+    return allFiles;
+}
+export async function listMyDrive(page, pdirFid) {
+    const allFiles = [];
+    let pageNum = 1;
+    let total = 0;
+    do {
+        const url = `${DRIVE_API}/sort?pr=ucpro&fr=pc&pdir_fid=${pdirFid}&_page=${pageNum}&_size=200&_fetch_total=1&_sort=file_type:asc,file_name:asc`;
+        const data = await fetchJson(page, url);
+        const files = unwrapApiData(data, 'Failed to list drive')?.list || [];
+        allFiles.push(...files);
+        total = data.metadata?._total || 0;
+        pageNum++;
+    } while (allFiles.length < total);
+    return allFiles;
+}
+export async function findFolder(page, path) {
+    const parts = path.split('/').filter(Boolean);
+    let currentFid = '0';
+    for (const part of parts) {
+        const files = await listMyDrive(page, currentFid);
+        const existing = files.find(f => f.dir && f.file_name === part);
+        if (existing) {
+            currentFid = existing.fid;
+        }
+        else {
+            throw new CommandExecutionError(`quark: Folder "${part}" not found in "${path}"`);
+        }
+    }
+    return currentFid;
+}
+export function formatDate(ts) {
+    if (!ts)
+        return '';
+    const d = new Date(ts);
+    return d.toISOString().replace('T', ' ').slice(0, 19);
+}
+export function formatSize(bytes) {
+    if (bytes <= 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${units[i]}`;
+}
+export async function getTaskStatus(page, taskId) {
+    const url = `${TASK_API}?pr=ucpro&fr=pc&task_id=${taskId}&retry_index=0`;
+    return apiGet(page, url);
+}
+export async function pollTask(page, taskId, onDone, maxAttempts = 30, intervalMs = 500) {
+    for (let i = 0; i < maxAttempts; i++) {
+        await new Promise(r => setTimeout(r, intervalMs));
+        const task = await getTaskStatus(page, taskId);
+        if (task?.status === 2) {
+            onDone?.(task);
+            return true;
+        }
+    }
+    return false;
+}

package/dist/clis/quark/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/quark/utils.test.js

@@ -0,0 +1,58 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { apiGet, apiPost, extractPwdId, getShareList, getToken } from './utils.js';
+function makePage(evaluateImpl) {
+    return {
+        evaluate: vi.fn(evaluateImpl),
+    };
+}
+describe('quark utils', () => {
+    it('extractPwdId accepts share URLs and raw ids', () => {
+        expect(extractPwdId('https://pan.quark.cn/s/abc123')).toBe('abc123');
+        expect(extractPwdId('abc123')).toBe('abc123');
+    });
+    it('maps JSON auth failures to AuthRequiredError', async () => {
+        const page = makePage(async () => ({
+            status: 401,
+            code: 401,
+            message: '未登录',
+            data: null,
+        }));
+        await expect(apiGet(page, 'https://drive-pc.quark.cn/test')).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+    it('maps non-JSON auth pages to AuthRequiredError', async () => {
+        const page = makePage(async () => {
+            const error = Object.assign(new Error('Non-JSON response: <html><title>登录</title></html>'), { status: 401 });
+            throw error;
+        });
+        await expect(apiPost(page, 'https://drive-pc.quark.cn/test', {})).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+    it('keeps generic API failures as CommandExecutionError', async () => {
+        const page = makePage(async () => ({
+            status: 500,
+            code: 500,
+            message: 'server busy',
+            data: null,
+        }));
+        await expect(apiGet(page, 'https://drive-pc.quark.cn/test')).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+    it('unwraps successful token responses', async () => {
+        const page = makePage(async () => ({
+            status: 200,
+            code: 0,
+            message: 'ok',
+            data: { stoken: 'token123' },
+        }));
+        await expect(getToken(page, 'abc123')).resolves.toBe('token123');
+    });
+    it('maps share-tree detail auth failures to AuthRequiredError', async () => {
+        const page = makePage(async () => ({
+            status: 401,
+            code: 401,
+            message: '请先登录',
+            data: null,
+            metadata: { _total: 0 },
+        }));
+        await expect(getShareList(page, 'abc123', 'token123')).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+});

package/dist/clis/reddit/frontpage.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/reddit/frontpage.js

@@ -0,0 +1,31 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'reddit',
+    name: 'frontpage',
+    description: 'Reddit Frontpage / r/all',
+    domain: 'reddit.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: 15 },
+    ],
+    columns: ['title', 'subreddit', 'author', 'upvotes', 'comments', 'url'],
+    pipeline: [
+        { navigate: 'https://www.reddit.com' },
+        { evaluate: `(async () => {
+  const res = await fetch('/r/all.json?limit=\${{ args.limit }}', { credentials: 'include' });
+  const j = await res.json();
+  return j?.data?.children || [];
+})()
+` },
+        { map: {
+                title: '${{ item.data.title }}',
+                subreddit: '${{ item.data.subreddit_name_prefixed }}',
+                author: '${{ item.data.author }}',
+                upvotes: '${{ item.data.score }}',
+                comments: '${{ item.data.num_comments }}',
+                url: 'https://www.reddit.com${{ item.data.permalink }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/clis/reddit/hot.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/reddit/hot.js

@@ -0,0 +1,45 @@
+import { cli } from '@jackwener/opencli/registry';
+cli({
+    site: 'reddit',
+    name: 'hot',
+    description: 'Reddit 热门帖子',
+    domain: 'www.reddit.com',
+    args: [
+        {
+            name: 'subreddit',
+            default: '',
+            help: 'Subreddit name (e.g. programming). Empty for frontpage',
+        },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of posts' },
+    ],
+    columns: ['rank', 'title', 'subreddit', 'score', 'comments'],
+    pipeline: [
+        { navigate: 'https://www.reddit.com' },
+        { evaluate: `(async () => {
+  const sub = \${{ args.subreddit | json }};
+  const path = sub ? '/r/' + sub + '/hot.json' : '/hot.json';
+  const limit = \${{ args.limit }};
+  const res = await fetch(path + '?limit=' + limit + '&raw_json=1', {
+    credentials: 'include'
+  });
+  const d = await res.json();
+  return (d?.data?.children || []).map(c => ({
+    title: c.data.title,
+    subreddit: c.data.subreddit_name_prefixed,
+    score: c.data.score,
+    comments: c.data.num_comments,
+    author: c.data.author,
+    url: 'https://www.reddit.com' + c.data.permalink,
+  }));
+})()
+` },
+        { map: {
+                rank: '${{ index + 1 }}',
+                title: '${{ item.title }}',
+                subreddit: '${{ item.subreddit }}',
+                score: '${{ item.score }}',
+                comments: '${{ item.comments }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/clis/reddit/popular.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/reddit/popular.js

@@ -0,0 +1,41 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'reddit',
+    name: 'popular',
+    description: 'Reddit Popular posts (/r/popular)',
+    domain: 'reddit.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: 20 },
+    ],
+    columns: ['rank', 'title', 'subreddit', 'score', 'comments', 'url'],
+    pipeline: [
+        { navigate: 'https://www.reddit.com' },
+        { evaluate: `(async () => {
+  const limit = \${{ args.limit }};
+  const res = await fetch('/r/popular.json?limit=' + limit + '&raw_json=1', {
+    credentials: 'include'
+  });
+  const d = await res.json();
+  return (d?.data?.children || []).map(c => ({
+    title: c.data.title,
+    subreddit: c.data.subreddit_name_prefixed,
+    score: c.data.score,
+    comments: c.data.num_comments,
+    author: c.data.author,
+    url: 'https://www.reddit.com' + c.data.permalink,
+  }));
+})()
+` },
+        { map: {
+                rank: '${{ index + 1 }}',
+                title: '${{ item.title }}',
+                subreddit: '${{ item.subreddit }}',
+                score: '${{ item.score }}',
+                comments: '${{ item.comments }}',
+                url: '${{ item.url }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/clis/reddit/search.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/reddit/search.js

@@ -0,0 +1,65 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'reddit',
+    name: 'search',
+    description: 'Search Reddit Posts',
+    domain: 'reddit.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'query', type: 'string', required: true, positional: true },
+        {
+            name: 'subreddit',
+            type: 'string',
+            default: '',
+            help: 'Search within a specific subreddit',
+        },
+        {
+            name: 'sort',
+            type: 'string',
+            default: 'relevance',
+            help: 'Sort order: relevance, hot, top, new, comments',
+        },
+        {
+            name: 'time',
+            type: 'string',
+            default: 'all',
+            help: 'Time filter: hour, day, week, month, year, all',
+        },
+        { name: 'limit', type: 'int', default: 15 },
+    ],
+    columns: ['title', 'subreddit', 'author', 'score', 'comments', 'url'],
+    pipeline: [
+        { navigate: 'https://www.reddit.com' },
+        { evaluate: `(async () => {
+  const q = encodeURIComponent(\${{ args.query | json }});
+  const sub = \${{ args.subreddit | json }};
+  const sort = \${{ args.sort | json }};
+  const time = \${{ args.time | json }};
+  const limit = \${{ args.limit }};
+  const basePath = sub ? '/r/' + sub + '/search.json' : '/search.json';
+  const params = 'q=' + q + '&sort=' + sort + '&t=' + time + '&limit=' + limit
+    + '&restrict_sr=' + (sub ? 'on' : 'off') + '&raw_json=1';
+  const res = await fetch(basePath + '?' + params, { credentials: 'include' });
+  const d = await res.json();
+  return (d?.data?.children || []).map(c => ({
+    title: c.data.title,
+    subreddit: c.data.subreddit_name_prefixed,
+    author: c.data.author,
+    score: c.data.score,
+    comments: c.data.num_comments,
+    url: 'https://www.reddit.com' + c.data.permalink,
+  }));
+})()
+` },
+        { map: {
+                title: '${{ item.title }}',
+                subreddit: '${{ item.subreddit }}',
+                author: '${{ item.author }}',
+                score: '${{ item.score }}',
+                comments: '${{ item.comments }}',
+                url: '${{ item.url }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/clis/reddit/subreddit.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/reddit/subreddit.js

@@ -0,0 +1,52 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'reddit',
+    name: 'subreddit',
+    description: 'Get posts from a specific Subreddit',
+    domain: 'reddit.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'name', type: 'string', required: true, positional: true },
+        {
+            name: 'sort',
+            type: 'string',
+            default: 'hot',
+            help: 'Sorting method: hot, new, top, rising, controversial',
+        },
+        {
+            name: 'time',
+            type: 'string',
+            default: 'all',
+            help: 'Time filter for top/controversial: hour, day, week, month, year, all',
+        },
+        { name: 'limit', type: 'int', default: 15 },
+    ],
+    columns: ['title', 'author', 'upvotes', 'comments', 'url'],
+    pipeline: [
+        { navigate: 'https://www.reddit.com' },
+        { evaluate: `(async () => {
+  let sub = \${{ args.name | json }};
+  if (sub.startsWith('r/')) sub = sub.slice(2);
+  const sort = \${{ args.sort | json }};
+  const time = \${{ args.time | json }};
+  const limit = \${{ args.limit }};
+  let url = '/r/' + sub + '/' + sort + '.json?limit=' + limit + '&raw_json=1';
+  if ((sort === 'top' || sort === 'controversial') && time) {
+    url += '&t=' + time;
+  }
+  const res = await fetch(url, { credentials: 'include' });
+  const j = await res.json();
+  return j?.data?.children || [];
+})()
+` },
+        { map: {
+                title: '${{ item.data.title }}',
+                author: '${{ item.data.author }}',
+                upvotes: '${{ item.data.score }}',
+                comments: '${{ item.data.num_comments }}',
+                url: 'https://www.reddit.com${{ item.data.permalink }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/clis/reddit/user-comments.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/reddit/user-comments.js

@@ -0,0 +1,44 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'reddit',
+    name: 'user-comments',
+    description: `View a Reddit user's comment history`,
+    domain: 'reddit.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'username', type: 'string', required: true, positional: true },
+        { name: 'limit', type: 'int', default: 15 },
+    ],
+    columns: ['subreddit', 'score', 'body', 'url'],
+    pipeline: [
+        { navigate: 'https://www.reddit.com' },
+        { evaluate: `(async () => {
+  const username = \${{ args.username | json }};
+  const name = username.startsWith('u/') ? username.slice(2) : username;
+  const limit = \${{ args.limit }};
+  const res = await fetch('/user/' + name + '/comments.json?limit=' + limit + '&raw_json=1', {
+    credentials: 'include'
+  });
+  const d = await res.json();
+  return (d?.data?.children || []).map(c => {
+    let body = c.data.body || '';
+    if (body.length > 300) body = body.slice(0, 300) + '...';
+    return {
+      subreddit: c.data.subreddit_name_prefixed,
+      score: c.data.score,
+      body: body,
+      url: 'https://www.reddit.com' + c.data.permalink,
+    };
+  });
+})()
+` },
+        { map: {
+                subreddit: '${{ item.subreddit }}',
+                score: '${{ item.score }}',
+                body: '${{ item.body }}',
+                url: '${{ item.url }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/clis/reddit/user-posts.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/reddit/user-posts.js

@@ -0,0 +1,42 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'reddit',
+    name: 'user-posts',
+    description: `View a Reddit user's submitted posts`,
+    domain: 'reddit.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'username', type: 'string', required: true, positional: true },
+        { name: 'limit', type: 'int', default: 15 },
+    ],
+    columns: ['title', 'subreddit', 'score', 'comments', 'url'],
+    pipeline: [
+        { navigate: 'https://www.reddit.com' },
+        { evaluate: `(async () => {
+  const username = \${{ args.username | json }};
+  const name = username.startsWith('u/') ? username.slice(2) : username;
+  const limit = \${{ args.limit }};
+  const res = await fetch('/user/' + name + '/submitted.json?limit=' + limit + '&raw_json=1', {
+    credentials: 'include'
+  });
+  const d = await res.json();
+  return (d?.data?.children || []).map(c => ({
+    title: c.data.title,
+    subreddit: c.data.subreddit_name_prefixed,
+    score: c.data.score,
+    comments: c.data.num_comments,
+    url: 'https://www.reddit.com' + c.data.permalink,
+  }));
+})()
+` },
+        { map: {
+                title: '${{ item.title }}',
+                subreddit: '${{ item.subreddit }}',
+                score: '${{ item.score }}',
+                comments: '${{ item.comments }}',
+                url: '${{ item.url }}',
+            } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/clis/reddit/user.d.ts

@@ -0,0 +1 @@
+export {};