publishport-opencli 1.8.4-pp.1

package/clis/qoder/ui.js

@@ -0,0 +1,332 @@
+// Global UI commands for Qoder.
+//
+//   sidebar-toggle  — Collapse Quest List (⌘B)
+//   open-panel      — Open Panel (⌥⌘B) — bottom panel
+//   search          — Search (⌘P) palette
+//   settings        — Settings
+//   knowledge       — open Knowledge view
+//   marketplace     — open Marketplace
+//   credits         — Credits Usage
+//   view-all        — View all quests
+//   add-workspace   — Add Workspace
+//   account         — read user info (the "leo"-style button at bottom)
+//   more-actions    — open More Actions menu + list items
+
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    ArgumentError,
+    CommandExecutionError,
+    EmptyResultError,
+} from '@jackwener/opencli/errors';
+import { IS_VISIBLE_JS, clickByTextScript, clickFirstScript, evaluateQoder, parsePositiveInt, requireArrayResult } from './_utils.js';
+
+// -------- sidebar-toggle --------
+cli({
+    site: 'qoder',
+    name: 'sidebar-toggle',
+    access: 'write',
+    description: 'Collapse / Expand the Qoder Quest List sidebar (⌘B).',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        const res = await evaluateQoder(page, clickByTextScript(['Collapse Quest List', 'Expand Quest List']));
+        if (!res?.ok) throw new CommandExecutionError(res?.reason || 'sidebar-toggle failed', '');
+        return [{ Status: `clicked: ${res.matched}` }];
+    },
+});
+
+// -------- open-panel --------
+cli({
+    site: 'qoder',
+    name: 'open-panel',
+    access: 'write',
+    description: 'Open / close the Qoder bottom panel (Output / Terminal / Debug Console). ⌥⌘B equivalent.',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        const res = await evaluateQoder(page, clickByTextScript(['Open Panel', 'Close Panel']));
+        if (!res?.ok) throw new CommandExecutionError(res?.reason || 'open-panel failed', '');
+        return [{ Status: `clicked: ${res.matched}` }];
+    },
+});
+
+// -------- search --------
+cli({
+    site: 'qoder',
+    name: 'search',
+    access: 'read',
+    description: 'Open Qoder Search palette (⌘P), type a query, return matched options.',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search text' },
+        { name: 'limit', type: 'int', required: false, default: 20 },
+    ],
+    columns: ['Index', 'Item'],
+    func: async (page, kwargs) => {
+        const query = String(kwargs?.query || '').trim();
+        if (!query) throw new ArgumentError('query', 'is required');
+        const limit = parsePositiveInt(kwargs?.limit, 20, '--limit');
+        const openRes = await evaluateQoder(page, clickByTextScript(['Search']));
+        if (!openRes?.ok) throw new CommandExecutionError(openRes?.reason || 'search open failed', '');
+        await page.wait(0.5);
+        // Type into the visible input (usually the most-recently mounted one).
+        const fillRes = await evaluateQoder(page, `(() => {
+      ${IS_VISIBLE_JS}
+      const inputs = Array.from(document.querySelectorAll('input[type="text"], input[type="search"], input:not([type])')).filter(isVisible);
+      const input = inputs[inputs.length - 1];
+      if (!input) return { ok: false, reason: 'No input visible.' };
+      const setter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value').set;
+      setter.call(input, ${JSON.stringify(query)});
+      input.dispatchEvent(new Event('input', { bubbles: true }));
+      input.dispatchEvent(new Event('change', { bubbles: true }));
+      return { ok: true };
+    })()`);
+        if (!fillRes?.ok) throw new CommandExecutionError(fillRes?.reason || 'search type failed', '');
+        await page.wait(0.8);
+        const items = requireArrayResult(await evaluateQoder(page, `(() => {
+      ${IS_VISIBLE_JS}
+      // Search palette results: prefer [role=option], else any clickable row in the modal.
+      const opts = Array.from(document.querySelectorAll('[role="option"], [role="menuitem"]')).filter(isVisible);
+      const titles = opts.map((o) => {
+        // Codex-style fix: text may be in per-char spans; use textContent.
+        const titleEl = o.querySelector('.truncate, [class*="title"i]') || o;
+        return (titleEl.textContent || '').trim().replace(/\\s+/g, ' ').slice(0, 200);
+      }).filter(Boolean);
+      return [...new Set(titles)];
+    })()`), 'qoder search');
+        try { await page.evaluate(`document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));`); } catch {}
+        if (!items.length) {
+            throw new EmptyResultError('qoder search', `No items matched "${query}".`);
+        }
+        return items.slice(0, limit).map((t, i) => ({ Index: i + 1, Item: t }));
+    },
+});
+
+// -------- settings --------
+cli({
+    site: 'qoder',
+    name: 'settings',
+    access: 'write',
+    description: 'Click the Settings button in the Qoder sidebar.',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        const res = await evaluateQoder(page, clickByTextScript(['Settings']));
+        if (!res?.ok) {
+            // Fallback: try aria-label.
+            const ariaRes = await evaluateQoder(page, clickFirstScript(['button[aria-label="Settings"]']));
+            if (!ariaRes?.ok) throw new CommandExecutionError('Settings button not found', '');
+        }
+        await page.wait(0.5);
+        return [{ Status: 'clicked' }];
+    },
+});
+
+// -------- knowledge --------
+cli({
+    site: 'qoder',
+    name: 'knowledge',
+    access: 'write',
+    description: 'Open the Knowledge view (Qoder\'s personal/team knowledge base).',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        const res = await evaluateQoder(page, clickByTextScript(['Knowledge']));
+        if (!res?.ok) throw new CommandExecutionError(res?.reason || 'Knowledge button not found', '');
+        return [{ Status: 'clicked' }];
+    },
+});
+
+// -------- marketplace --------
+cli({
+    site: 'qoder',
+    name: 'marketplace',
+    access: 'write',
+    description: 'Open the Qoder Marketplace.',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        const res = await evaluateQoder(page, clickByTextScript(['Marketplace']));
+        if (!res?.ok) throw new CommandExecutionError(res?.reason || 'Marketplace button not found', '');
+        return [{ Status: 'clicked' }];
+    },
+});
+
+// -------- credits --------
+cli({
+    site: 'qoder',
+    name: 'credits',
+    access: 'read',
+    description: 'Click "Credits Usage" and return the credits-usage display text.',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Field', 'Value'],
+    func: async (page) => {
+        const res = await evaluateQoder(page, clickByTextScript(['Credits Usage']));
+        if (!res?.ok) throw new CommandExecutionError(res?.reason || 'Credits Usage not visible', '');
+        await page.wait(0.5);
+        // Try to read whatever appears.
+        const info = await evaluateQoder(page, `(() => {
+      ${IS_VISIBLE_JS}
+      // Find any dialog/popover that appeared.
+      const popovers = Array.from(document.querySelectorAll('[role="dialog"], [class*="popover"i], [class*="popup"i]')).filter(isVisible);
+      if (!popovers.length) return null;
+      const pop = popovers[popovers.length - 1];
+      return (pop.innerText || pop.textContent || '').trim().replace(/\\s+/g, ' ').slice(0, 600);
+    })()`);
+        try { await page.evaluate(`document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));`); } catch {}
+        return [
+            { Field: 'Status', Value: 'clicked' },
+            { Field: 'Info', Value: info || '(no popover detected after click)' },
+        ];
+    },
+});
+
+// -------- view-all --------
+cli({
+    site: 'qoder',
+    name: 'view-all',
+    access: 'write',
+    description: 'Click "View all" to show all Quests.',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        const res = await evaluateQoder(page, clickByTextScript(['View all']));
+        if (!res?.ok) throw new CommandExecutionError(res?.reason || 'View all button not visible', '');
+        return [{ Status: 'clicked' }];
+    },
+});
+
+// -------- add-workspace --------
+cli({
+    site: 'qoder',
+    name: 'add-workspace',
+    access: 'write',
+    description: 'Click "Add Workspace" — opens the folder picker. Note: this opens a system file-picker dialog that Qoder controls; the actual folder selection must be done in the UI by the user.',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        const res = await evaluateQoder(page, clickByTextScript(['Add Workspace']));
+        if (!res?.ok) throw new CommandExecutionError(res?.reason || 'Add Workspace button not found', '');
+        return [{ Status: 'clicked — folder picker opened (manual selection required)' }];
+    },
+});
+
+// -------- account --------
+cli({
+    site: 'qoder',
+    name: 'account',
+    access: 'read',
+    description: 'Click the account button (username) in the Qoder sidebar and return the visible account dropdown items.',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'username', required: false, help: 'Username text shown in the sidebar (default: tries common short labels)' },
+    ],
+    columns: ['Field', 'Value'],
+    func: async (page, kwargs) => {
+        // The account button label is the user's display name. We try a few
+        // common patterns: if --username is passed we use it, else we look
+        // for any short button text that doesn't match other known controls.
+        let label = String(kwargs?.username || '').trim();
+        if (!label) {
+            // Heuristic discovery.
+            label = await evaluateQoder(page, `(() => {
+        ${IS_VISIBLE_JS}
+        const btns = Array.from(document.querySelectorAll('button')).filter(isVisible);
+        const known = new Set(['Pin', 'Copy', 'New Quest', 'Search', 'Settings', 'View all', 'Knowledge', 'Marketplace', 'Credits Usage', 'Open Editor', 'Add Workspace', 'More Actions', 'Send message', 'Prompt Enhance', 'Voice input', 'button']);
+        const candidate = btns.find((b) => {
+          const tx = (b.innerText || '').trim();
+          if (!tx || tx.length > 30 || tx.includes('⌘') || known.has(tx)) return false;
+          if (/^(New|Open|Add|Save|Edit|Cancel|OK|Close)/.test(tx)) return false;
+          return true;
+        });
+        return candidate ? (candidate.innerText || '').trim() : '';
+      })()`);
+        }
+        if (!label) {
+            throw new CommandExecutionError('No account button detected. Pass --username <name> explicitly.', '');
+        }
+        // Click the username button
+        const clickRes = await evaluateQoder(page, clickByTextScript([label], { exact: true, maxLen: 60 }));
+        if (!clickRes?.ok) throw new CommandExecutionError(`Click on account button "${label}" failed`, '');
+        await page.wait(0.5);
+        const items = requireArrayResult(await evaluateQoder(page, `(() => {
+      ${IS_VISIBLE_JS}
+      const popovers = Array.from(document.querySelectorAll('[role="menu"], [role="dialog"], [class*="popover"i], [class*="dropdown"i]')).filter(isVisible)
+        .filter((el) => { const r = el.getBoundingClientRect(); return r.width < 500 && r.height < 600; });
+      if (!popovers.length) return [];
+      const pop = popovers[popovers.length - 1];
+      return Array.from(pop.querySelectorAll('button, [role="menuitem"], a'))
+        .filter(isVisible)
+        .map((b) => (b.innerText || b.textContent || '').trim().replace(/\\s+/g, ' '))
+        .filter(Boolean);
+    })()`), 'qoder account');
+        try { await page.evaluate(`document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));`); } catch {}
+        const rows = [{ Field: 'Username', Value: label }];
+        (items || []).slice(0, 20).forEach((item, i) => {
+            rows.push({ Field: `Item[${i + 1}]`, Value: item });
+        });
+        return rows;
+    },
+});
+
+// -------- more-actions --------
+cli({
+    site: 'qoder',
+    name: 'more-actions',
+    access: 'read',
+    description: 'Click the "More Actions" button and list its menu items.',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Index', 'Item'],
+    func: async (page) => {
+        const res = await evaluateQoder(page, clickByTextScript(['More Actions']));
+        if (!res?.ok) throw new CommandExecutionError(res?.reason || 'More Actions button not found', '');
+        await page.wait(0.4);
+        const items = requireArrayResult(await evaluateQoder(page, `(() => {
+      ${IS_VISIBLE_JS}
+      const popovers = Array.from(document.querySelectorAll('[role="menu"], [role="dialog"], [class*="popover"i], [class*="menu"i]')).filter(isVisible)
+        .filter((el) => { const r = el.getBoundingClientRect(); return r.width < 500 && r.height < 600; });
+      if (!popovers.length) return [];
+      const pop = popovers[popovers.length - 1];
+      return Array.from(pop.querySelectorAll('[role="menuitem"], button'))
+        .filter(isVisible)
+        .map((b) => (b.innerText || b.textContent || '').trim().replace(/\\s+/g, ' '))
+        .filter(Boolean);
+    })()`), 'qoder more-actions');
+        try { await page.evaluate(`document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));`); } catch {}
+        if (!items.length) {
+            throw new EmptyResultError('qoder more-actions', 'Menu opened but no items detected.');
+        }
+        return items.map((it, i) => ({ Index: i + 1, Item: it }));
+    },
+});

package/clis/quark/auth.js

@@ -0,0 +1,47 @@
+import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { registerSiteAuthCommands } from '../_shared/site-auth.js';
+
+// Quark's auth cookies (__pus / __kp / __puus) are httpOnly. The account/info
+// endpoint returns HTTP 200 with an empty `data` array when anonymous and a
+// populated object once logged in, so the poll uses a no-nav probe of it.
+const WHOAMI_PROBE = `(async () => {
+  try {
+    const r = await fetch('https://pan.quark.cn/account/info?fr=pc&platform=pc', { credentials: 'include', headers: { Accept: 'application/json' } });
+    if (r.status === 401 || r.status === 403) return { kind: 'auth', detail: 'Quark account/info HTTP ' + r.status };
+    if (!r.ok) return { kind: 'http', httpStatus: r.status };
+    const d = await r.json();
+    const data = d && d.data;
+    const isEmpty = !data || Array.isArray(data) || Object.keys(data).length === 0;
+    if (isEmpty) return { kind: 'auth', detail: 'Quark account/info returned empty data — anonymous' };
+    const nickname = String(data.nickname || data.nick_name || data.name || '');
+    if (!nickname) return { kind: 'render-error', detail: 'Quark account/info populated but no nickname field — response shape drift' };
+    return { ok: true, nickname };
+  } catch (e) {
+    return { kind: 'exception', detail: String(e && e.message || e) };
+  }
+})()`;
+
+async function verifyQuarkIdentity(page) {
+  await page.goto('https://pan.quark.cn/');
+  await page.wait(2);
+  const probe = await page.evaluate(WHOAMI_PROBE);
+  if (probe?.kind === 'auth') throw new AuthRequiredError('quark.cn', probe.detail);
+  if (probe?.kind === 'http') throw new CommandExecutionError(`HTTP ${probe.httpStatus} from Quark account/info`);
+  if (probe?.kind === 'render-error') throw new CommandExecutionError(probe.detail);
+  if (probe?.kind === 'exception') throw new CommandExecutionError(`Quark whoami failed: ${probe.detail}`);
+  if (!probe?.ok) throw new CommandExecutionError(`Unexpected Quark probe: ${JSON.stringify(probe)}`);
+  return { nickname: probe.nickname };
+}
+
+registerSiteAuthCommands({
+  site: 'quark',
+  domain: 'quark.cn',
+  loginUrl: 'https://pan.quark.cn/',
+  columns: ['nickname'],
+  verify: verifyQuarkIdentity,
+  poll: async (page) => {
+    const probe = await page.evaluate(WHOAMI_PROBE);
+    if (!probe?.ok) throw new AuthRequiredError('quark.cn', 'Waiting for Quark login');
+    return { nickname: probe.nickname };
+  },
+});

package/clis/quark/ls.js

@@ -0,0 +1,64 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { findFolder, formatSize, listMyDrive, } from './utils.js';
+async function buildTree(page, pdirFid, parentPath, depth, maxDepth, dirsOnly) {
+    if (depth > maxDepth)
+        return [];
+    const files = await listMyDrive(page, pdirFid);
+    const nodes = [];
+    for (const file of files) {
+        if (dirsOnly && !file.dir)
+            continue;
+        const path = parentPath ? `${parentPath}/${file.file_name}` : file.file_name;
+        const node = {
+            name: file.file_name,
+            fid: file.fid,
+            is_dir: file.dir,
+            size: formatSize(file.size),
+            path,
+        };
+        if (file.dir && depth < maxDepth) {
+            node.children = await buildTree(page, file.fid, path, depth + 1, maxDepth, dirsOnly);
+        }
+        nodes.push(node);
+    }
+    return nodes;
+}
+function flattenTree(nodes, level = 0) {
+    const result = [];
+    const indent = '  '.repeat(level);
+    for (const node of nodes) {
+        result.push({
+            name: `${indent}${node.name}`,
+            fid: node.fid,
+            is_dir: node.is_dir,
+            size: node.size,
+            path: node.path,
+        });
+        if (node.children) {
+            result.push(...flattenTree(node.children, level + 1));
+        }
+    }
+    return result;
+}
+cli({
+    site: 'quark',
+    name: 'ls',
+    access: 'read',
+    description: 'List files in your Quark Drive',
+    domain: 'pan.quark.cn',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'path', positional: true, default: '', help: 'Folder path to list (empty for root)' },
+        { name: 'depth', type: 'int', default: 0, help: 'Max depth to traverse' },
+        { name: 'dirs-only', type: 'boolean', default: false, help: 'Show directories only' },
+    ],
+    columns: ['name', 'is_dir', 'size', 'fid', 'path'],
+    func: async (page, kwargs) => {
+        const path = kwargs.path ?? '';
+        const depth = Math.max(0, kwargs.depth ?? 0);
+        const dirsOnly = kwargs['dirs-only'] ?? false;
+        const rootFid = path ? await findFolder(page, path) : '0';
+        const tree = await buildTree(page, rootFid, path, 0, depth, dirsOnly);
+        return flattenTree(tree);
+    },
+});

package/clis/quark/mkdir.js

@@ -0,0 +1,37 @@
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { DRIVE_API, apiPost, findFolder } from './utils.js';
+cli({
+    site: 'quark',
+    name: 'mkdir',
+    access: 'write',
+    description: 'Create a folder in your Quark Drive',
+    domain: 'pan.quark.cn',
+    strategy: Strategy.COOKIE,
+    defaultFormat: 'json',
+    args: [
+        { name: 'name', required: true, positional: true, help: 'Folder name' },
+        { name: 'parent', help: 'Parent folder path (resolved by name)' },
+        { name: 'parent-fid', help: 'Parent folder fid (use directly)' },
+    ],
+    func: async (page, kwargs) => {
+        const name = kwargs.name;
+        if (!name.trim())
+            throw new ArgumentError('Folder name cannot be empty');
+        if (kwargs.parent && kwargs['parent-fid']) {
+            throw new ArgumentError('Cannot use both --parent and --parent-fid');
+        }
+        const parentFid = kwargs['parent-fid']
+            ? kwargs['parent-fid']
+            : kwargs.parent
+                ? await findFolder(page, kwargs.parent)
+                : '0';
+        const data = await apiPost(page, `${DRIVE_API}?pr=ucpro&fr=pc`, {
+            pdir_fid: parentFid,
+            file_name: name,
+            dir_path: '',
+            dir_init_lock: false,
+        });
+        return { status: 'ok', fid: data.fid, name };
+    },
+});

package/clis/quark/mv.js

@@ -0,0 +1,54 @@
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { DRIVE_API, apiPost, findFolder, pollTask } from './utils.js';
+cli({
+    site: 'quark',
+    name: 'mv',
+    access: 'write',
+    description: 'Move files to a folder in your Quark Drive',
+    domain: 'pan.quark.cn',
+    strategy: Strategy.COOKIE,
+    defaultFormat: 'json',
+    args: [
+        { name: 'fids', required: true, positional: true, help: 'File IDs to move (comma-separated)' },
+        { name: 'to', default: '', help: 'Destination folder path (required unless --to-fid is set)' },
+        { name: 'to-fid', default: '', help: 'Destination folder ID (overrides --to)' },
+        { name: 'timeout', type: 'int', required: false, default: 120, help: 'Max seconds for the overall command (default: 120)' },
+    ],
+    func: async (page, kwargs) => {
+        const to = kwargs.to;
+        const toFid = kwargs['to-fid'];
+        const fids = kwargs.fids;
+        const fidList = [...new Set(fids.split(',').map(id => id.trim()).filter(Boolean))];
+        if (fidList.length === 0)
+            throw new ArgumentError('No fids provided');
+        if (!to && !toFid)
+            throw new ArgumentError('Either --to or --to-fid is required');
+        if (to && toFid)
+            throw new ArgumentError('Cannot use both --to and --to-fid');
+        const targetFid = toFid || await findFolder(page, to);
+        const data = await apiPost(page, `${DRIVE_API}/move?pr=ucpro&fr=pc`, {
+            filelist: fidList,
+            to_pdir_fid: targetFid,
+        });
+        const result = {
+            status: 'pending',
+            count: fidList.length,
+            destination: to || toFid,
+            task_id: data.task_id,
+            completed: false,
+        };
+        if (data.task_id) {
+            const completed = await pollTask(page, data.task_id);
+            result.completed = completed;
+            result.status = completed ? 'ok' : 'error';
+            if (!completed)
+                throw new CommandExecutionError('quark: Move task timed out');
+        }
+        else {
+            result.status = 'ok';
+            result.completed = true;
+        }
+        return result;
+    },
+});

package/clis/quark/rename.js

@@ -0,0 +1,27 @@
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { DRIVE_API, apiPost } from './utils.js';
+cli({
+    site: 'quark',
+    name: 'rename',
+    access: 'write',
+    description: 'Rename a file in your Quark Drive',
+    domain: 'pan.quark.cn',
+    strategy: Strategy.COOKIE,
+    defaultFormat: 'json',
+    args: [
+        { name: 'fid', required: true, positional: true, help: 'File ID to rename' },
+        { name: 'name', required: true, help: 'New file name' },
+    ],
+    func: async (page, kwargs) => {
+        const fid = kwargs.fid;
+        const name = kwargs.name;
+        if (!name.trim())
+            throw new ArgumentError('New name cannot be empty');
+        await apiPost(page, `${DRIVE_API}/rename?pr=ucpro&fr=pc`, {
+            fid,
+            file_name: name,
+        });
+        return { status: 'ok', fid, new_name: name };
+    },
+});

package/clis/quark/rm.js

@@ -0,0 +1,25 @@
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { DRIVE_API, apiPost } from './utils.js';
+cli({
+    site: 'quark',
+    name: 'rm',
+    access: 'write',
+    description: 'Delete files from your Quark Drive',
+    domain: 'pan.quark.cn',
+    strategy: Strategy.COOKIE,
+    defaultFormat: 'json',
+    args: [
+        { name: 'fids', required: true, positional: true, help: 'File IDs to delete (comma-separated)' },
+    ],
+    func: async (page, kwargs) => {
+        const fids = kwargs.fids;
+        const fidList = [...new Set(fids.split(',').map(id => id.trim()).filter(Boolean))];
+        if (fidList.length === 0)
+            throw new ArgumentError('No fids provided');
+        await apiPost(page, `${DRIVE_API}/delete?pr=ucpro&fr=pc`, {
+            filelist: fidList,
+        });
+        return { status: 'ok', count: fidList.length, deleted_fids: fidList };
+    },
+});

package/clis/quark/save.js

@@ -0,0 +1,81 @@
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { SHARE_API, extractPwdId, apiPost, getToken, pollTask, findFolder, } from './utils.js';
+async function saveShare(page, pwdId, stoken, fidList, targetFid, saveAll) {
+    const data = await apiPost(page, `${SHARE_API}/save?pr=ucpro&fr=pc`, {
+        pwd_id: pwdId,
+        stoken,
+        pdir_fid: '0',
+        to_pdir_fid: targetFid,
+        fid_list: fidList,
+        pdir_save_all: saveAll,
+        scene: 'link',
+    });
+    return data.task_id;
+}
+cli({
+    site: 'quark',
+    name: 'save',
+    access: 'write',
+    description: 'Save shared files to your Quark Drive',
+    domain: 'pan.quark.cn',
+    strategy: Strategy.COOKIE,
+    defaultFormat: 'json',
+    args: [
+        { name: 'url', required: true, positional: true, help: 'Quark share URL or pwd_id' },
+        { name: 'to', default: '', help: 'Destination folder path' },
+        { name: 'to-fid', default: '', help: 'Destination folder ID (overrides --to)' },
+        { name: 'fids', default: '', help: 'File IDs to save (comma-separated, from share-tree). Omit to save all.' },
+        { name: 'stoken', default: '', help: 'Share token (from share-tree output, required with --fids)' },
+        { name: 'passcode', default: '', help: 'Share passcode (if required)' },
+        { name: 'timeout', type: 'int', required: false, default: 120, help: 'Max seconds for the overall command (default: 120)' },
+    ],
+    func: async (page, kwargs) => {
+        const url = kwargs.url;
+        const to = kwargs.to;
+        const toFid = kwargs['to-fid'];
+        const fids = kwargs.fids;
+        const stokenArg = kwargs.stoken;
+        const passcode = kwargs.passcode;
+        if (!to && !toFid)
+            throw new ArgumentError('Either --to or --to-fid is required');
+        if (to && toFid)
+            throw new ArgumentError('Cannot use both --to and --to-fid');
+        const pwdId = extractPwdId(url);
+        const saveAll = !fids;
+        let stoken;
+        let fidList;
+        if (saveAll) {
+            stoken = stokenArg || await getToken(page, pwdId, passcode);
+            fidList = [];
+        }
+        else {
+            if (!stokenArg)
+                throw new ArgumentError('--stoken is required when using --fids');
+            stoken = stokenArg;
+            fidList = [...new Set(fids.split(',').map(id => id.trim()).filter(Boolean))];
+        }
+        const targetFid = toFid || await findFolder(page, to);
+        const taskId = await saveShare(page, pwdId, stoken, fidList, targetFid, saveAll);
+        const result = {
+            success: false,
+            task_id: taskId,
+            saved_to: to || toFid,
+            target_fid: targetFid,
+            ...(saveAll ? {} : { fids: fidList }),
+        };
+        if (taskId) {
+            const completed = await pollTask(page, taskId, (task) => {
+                result.save_count = task.save_as?.save_as_sum_num;
+            });
+            result.completed = completed;
+            result.success = completed;
+            if (!completed)
+                throw new CommandExecutionError('quark: Save task timed out');
+        }
+        else {
+            result.success = true;
+        }
+        return result;
+    },
+});