@jackwener/opencli 1.7.22 → 1.8.1

package/clis/twitter/utils.js

@@ -19,6 +19,8 @@ export const SUPPORTED_IMAGE_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.gi
 
 /** 20 MB hard cap. Twitter allows ~5MB images / 15MB GIFs; 20MB is a safety net. */
 export const MAX_IMAGE_SIZE_BYTES = 20 * 1024 * 1024;
+const MEDIA_UPLOAD_POLL_MS = 500;
+const MEDIA_UPLOAD_TIMEOUT_MS = 30_000;
 
 const CONTENT_TYPE_TO_EXTENSION = {
     'image/jpeg': '.jpg',
@@ -133,7 +135,7 @@ export async function attachComposerImage(page, absImagePath, fileInputSelector
             uploaded = true;
         } catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            if (!msg.includes('Unknown action') && !msg.includes('not supported')) {
+            if (!isRecoverableFileInputError(msg)) {
                 throw new Error(`Image upload failed: ${msg}`);
             }
             // setFileInput not supported by extension — fall through to base64 fallback.
@@ -167,7 +169,21 @@ export async function attachComposerImage(page, absImagePath, fileInputSelector
         const blob = new Blob([bytes], { type: ${JSON.stringify(mimeType)} });
         dt.items.add(new File([blob], ${JSON.stringify(path.basename(absImagePath))}, { type: ${JSON.stringify(mimeType)} }));
 
-        Object.defineProperty(input, 'files', { value: dt.files, writable: false });
+        let assigned = false;
+        try {
+          Object.defineProperty(input, 'files', { value: dt.files, writable: false, configurable: true });
+          assigned = input.files && input.files.length > 0;
+        } catch(e) {
+          // files property not redefinable — use nativeInputValueSetter trick
+          try {
+            const nativeInputFileSetter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'files');
+            if (nativeInputFileSetter && nativeInputFileSetter.set) {
+              nativeInputFileSetter.set.call(input, dt.files);
+              assigned = input.files && input.files.length > 0;
+            }
+          } catch(e2) { /* ignore */ }
+        }
+        if (!assigned) return { ok: false, error: 'Could not assign files to input' };
         input.dispatchEvent(new Event('change', { bubbles: true }));
         input.dispatchEvent(new Event('input', { bubbles: true }));
         return { ok: true };
@@ -177,23 +193,42 @@ export async function attachComposerImage(page, absImagePath, fileInputSelector
             throw new Error(`Image upload failed: ${upload?.error ?? 'unknown error'}`);
         }
     }
-    await page.wait(2);
-    const uploadState = await page.evaluate(`
-    (() => {
-      const previewCount = document.querySelectorAll(
-        '[data-testid="attachments"] img, [data-testid="attachments"] video, [data-testid="tweetPhoto"]'
-      ).length;
-      const hasMedia = previewCount > 0
-        || !!document.querySelector('[data-testid="attachments"]')
-        || !!Array.from(document.querySelectorAll('button,[role="button"]')).find((el) =>
-          /remove media|remove image|remove/i.test((el.getAttribute('aria-label') || '') + ' ' + (el.textContent || ''))
+    const uploadState = await waitForComposerMediaReady(page, 1);
+    if (!uploadState?.ok) {
+        throw new Error(uploadState?.message ?? 'Image upload failed: preview did not appear.');
+    }
+}
+
+export function isRecoverableFileInputError(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return /unknown action|not supported|not[-\s]?allowed|notallowederror/i.test(msg);
+}
+
+export async function waitForComposerMediaReady(page, expectedCount = 1) {
+    const iterations = Math.ceil(MEDIA_UPLOAD_TIMEOUT_MS / MEDIA_UPLOAD_POLL_MS);
+    return page.evaluate(`
+    (async () => {
+      const expected = ${JSON.stringify(expectedCount)};
+      for (let i = 0; i < ${JSON.stringify(iterations)}; i++) {
+        await new Promise(r => setTimeout(r, ${JSON.stringify(MEDIA_UPLOAD_POLL_MS)}));
+        const previewCount = document.querySelectorAll(
+          '[data-testid="attachments"] img, [data-testid="attachments"] video, [data-testid="attachments"] [role="group"], [data-testid="tweetPhoto"]'
+        ).length;
+        const blobCount = document.querySelectorAll('img[src^="blob:"], video[src^="blob:"]').length;
+        const removeButtonCount = Array.from(document.querySelectorAll('button,[role="button"]')).filter((el) =>
+          /remove media|remove image|remove|编辑/i.test((el.getAttribute('aria-label') || '') + ' ' + (el.textContent || ''))
+        ).length;
+        const explicitPreviewCount = Math.max(
+          previewCount,
+          blobCount,
+          removeButtonCount,
+          document.querySelectorAll('[data-testid="media-upload-preview"], [data-testid="card.layoutLarge.media"]').length
         );
-      return { ok: hasMedia, previewCount };
+        if (explicitPreviewCount >= expected) return { ok: true, previewCount: explicitPreviewCount };
+      }
+      return { ok: false, message: 'Image upload timed out (${MEDIA_UPLOAD_TIMEOUT_MS / 1000}s).' };
     })()
   `);
-    if (!uploadState?.ok) {
-        throw new Error('Image upload failed: preview did not appear.');
-    }
 }
 
 // ── Engagement scoring (P3) ────────────────────────────────────────────
@@ -280,6 +315,8 @@ export const __test__ = {
     resolveImageExtension,
     downloadRemoteImage,
     attachComposerImage,
+    isRecoverableFileInputError,
+    waitForComposerMediaReady,
     computeEngagementScore,
     applyTopByEngagement,
     ENGAGEMENT_WEIGHTS,

package/clis/upwork/detail.js

@@ -0,0 +1,132 @@
+/**
+ * Upwork job detail.
+ *
+ * Reads the full job posting (title, description, budget, experience
+ * level, workload, client stats, applicant count) for a given
+ * ciphertext id (the `~02…` form surfaced by `upwork search` /
+ * `upwork feed`). Unlike search/feed, the job-detail page does not
+ * populate `window.__NUXT__.state` for the job — it rehydrates into
+ * the Vuex store at `window.$nuxt.$store.state.jobDetails.{job, buyer,
+ * applicants, …}`. We read straight from that store.
+ */
+
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    CommandExecutionError,
+    EmptyResultError,
+    AuthRequiredError,
+} from '@jackwener/opencli/errors';
+import {
+    DETAIL_COLUMNS,
+    buildJobUrl,
+    decodeExperienceLevel,
+    decodeWorkload,
+    formatBudgetFromDetail,
+    formatSkills,
+    isPlainObject,
+    jobType,
+    requireCiphertext,
+    stripHighlight,
+    unwrapBrowserResult,
+} from './utils.js';
+
+cli({
+    site: 'upwork',
+    name: 'detail',
+    aliases: ['job', 'view'],
+    access: 'read',
+    description: 'Read the full Upwork job posting by ciphertext id (e.g. ~022054964136512093518)',
+    domain: 'www.upwork.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'Job ciphertext id (~01… / ~02…) or full /jobs/~02… URL' },
+    ],
+    columns: DETAIL_COLUMNS,
+    func: async (page, kwargs) => {
+        const id = requireCiphertext(kwargs.id);
+        const url = buildJobUrl(id);
+        await page.goto(url);
+        await page.wait(5);
+
+        let payload;
+        try {
+            payload = unwrapBrowserResult(await page.evaluate(`(async () => {
+                const haveStore = () => !!(window.$nuxt && window.$nuxt.$store && window.$nuxt.$store.state && window.$nuxt.$store.state.jobDetails && window.$nuxt.$store.state.jobDetails.job);
+                let ready = haveStore();
+                for (let i = 0; i < 30; i++) {
+                    if (ready) break;
+                    await new Promise(r => setTimeout(r, 500));
+                    ready = haveStore();
+                }
+                const onLogin = /\\/(ab\\/account-security\\/login|nx\\/login)/.test(location.pathname);
+                const challenge = (document.title || '').toLowerCase().includes('just a moment') || !!document.querySelector('[id^="cf-"]');
+                if (!ready) {
+                    return { ready, onLogin, challenge, job: null, buyer: null };
+                }
+                const s = window.$nuxt.$store.state.jobDetails;
+                return {
+                    ready,
+                    onLogin,
+                    challenge,
+                    job: s.job ? JSON.parse(JSON.stringify(s.job)) : null,
+                    buyer: s.buyer ? JSON.parse(JSON.stringify(s.buyer)) : null,
+                };
+            })()`));
+        }
+        catch (e) {
+            throw new CommandExecutionError(`Failed to read Upwork job-detail store: ${e?.message ?? e}`, 'The Vuex store was not reachable; try again after opening Upwork in the connected browser.');
+        }
+
+        if (payload?.onLogin) {
+            throw new AuthRequiredError('upwork.com', 'Upwork redirected to login. Open https://www.upwork.com in the connected browser and sign in, then retry.');
+        }
+        if (payload?.challenge) {
+            throw new CommandExecutionError('Upwork served a Cloudflare challenge page', 'Open https://www.upwork.com in the connected browser and clear the challenge, then retry.');
+        }
+        if (!isPlainObject(payload)) {
+            throw new CommandExecutionError('Upwork detail returned an unexpected Browser Bridge payload shape');
+        }
+        if (!payload?.ready || !payload.job) {
+            throw new EmptyResultError('upwork detail', `No Upwork job posting found for id "${id}" (may be closed, expired, or private)`);
+        }
+        if (!isPlainObject(payload.job)) {
+            throw new CommandExecutionError('Upwork job-detail store had an unexpected job shape; expected an object.');
+        }
+
+        const job = payload.job;
+        const returnedCiphertext = String(job?.ciphertext ?? '').trim();
+        if (returnedCiphertext && returnedCiphertext !== id) {
+            throw new CommandExecutionError(`Upwork job-detail store returned ciphertext "${returnedCiphertext}" while reading "${id}".`);
+        }
+        const buyer = payload.buyer || {};
+        const stats = buyer?.stats || {};
+        const location = buyer?.location || {};
+        const category = job?.category?.name || '';
+        const skills = formatSkills(job);
+        const totalSpent = Number(stats?.totalCharges?.amount);
+        const totalHires = Number(stats?.totalJobsWithHires);
+        const score = Number(stats?.score);
+        const totalApplicants = Number(job?.clientActivity?.totalApplicants);
+
+        return [{
+            id,
+            title: stripHighlight(job?.title),
+            type: jobType(job?.type),
+            budget: formatBudgetFromDetail(job),
+            experienceLevel: decodeExperienceLevel(job?.contractorTier),
+            workload: decodeWorkload(job?.workload),
+            category,
+            skills,
+            description: String(job?.description ?? '').trim(),
+            clientCountry: location?.country || '',
+            clientSpent: Number.isFinite(totalSpent) && totalSpent > 0 ? totalSpent : null,
+            clientHires: Number.isFinite(totalHires) ? totalHires : null,
+            clientRating: Number.isFinite(score) && score > 0 ? score : null,
+            proposalsCount: Number.isFinite(totalApplicants) ? totalApplicants : null,
+            publishedOn: job?.publishTime || job?.postedOn || job?.createdOn || '',
+            url,
+        }];
+    },
+});

package/clis/upwork/feed.js

@@ -0,0 +1,109 @@
+/**
+ * Upwork personalized feed (Best Matches / Most Recent).
+ *
+ * Reads the logged-in user's recommended-jobs feed. Two tabs are
+ * supported: `best-matches` (default, Upwork's relevance-ranked feed)
+ * and `most-recent` (chronological). Both surface the full job list in
+ * `window.__NUXT__.state.feed{BestMatch,MostRecent}.{jobs, paging}`.
+ *
+ * Login is required — bare visitors get redirected through the
+ * onboarding flow and never see the feed state.
+ */
+
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    CommandExecutionError,
+    EmptyResultError,
+    AuthRequiredError,
+} from '@jackwener/opencli/errors';
+import {
+    buildFeedUrl,
+    feedStateKey,
+    isPlainObject,
+    jobsToListRows,
+    LIST_COLUMNS,
+    requireBoundedInt,
+    requireFeedTab,
+    unwrapBrowserResult,
+} from './utils.js';
+
+cli({
+    site: 'upwork',
+    name: 'feed',
+    aliases: ['best-matches'],
+    access: 'read',
+    description: 'Upwork personalized jobs feed (best-matches | most-recent) — requires login',
+    domain: 'www.upwork.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'tab', positional: true, required: false, default: 'best-matches', help: 'Feed tab: best-matches | most-recent' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max rows to return (1-50, capped at one page)' },
+    ],
+    columns: LIST_COLUMNS,
+    func: async (page, kwargs) => {
+        const tab = requireFeedTab(kwargs.tab);
+        const limit = requireBoundedInt(kwargs.limit, 20, 1, 50, 'limit');
+        const stateKey = feedStateKey(tab);
+        const url = buildFeedUrl(tab);
+
+        await page.goto(url);
+        await page.wait(5);
+
+        let payload;
+        try {
+            payload = unwrapBrowserResult(await page.evaluate(`(async () => {
+                const key = ${JSON.stringify(stateKey)};
+                const haveState = () => !!(window.__NUXT__ && window.__NUXT__.state && window.__NUXT__.state[key]);
+                let ready = haveState();
+                for (let i = 0; i < 30; i++) {
+                    if (ready) break;
+                    await new Promise(r => setTimeout(r, 500));
+                    ready = haveState();
+                }
+                const onLogin = /\\/(ab\\/account-security\\/login|nx\\/login)/.test(location.pathname);
+                const challenge = (document.title || '').toLowerCase().includes('just a moment') || !!document.querySelector('[id^="cf-"]');
+                const state = window.__NUXT__ && window.__NUXT__.state && window.__NUXT__.state[key];
+                return {
+                    ready,
+                    onLogin,
+                    challenge,
+                    jobsPresent: !!(state && Object.prototype.hasOwnProperty.call(state, 'jobs')),
+                    jobs: state ? state.jobs : undefined,
+                    paging: state && state.paging ? state.paging : null,
+                };
+            })()`));
+        }
+        catch (e) {
+            throw new CommandExecutionError(`Failed to read Upwork feed state: ${e?.message ?? e}`, 'The Nuxt state global was not reachable; try again after opening Upwork in the connected browser.');
+        }
+
+        if (payload?.onLogin) {
+            throw new AuthRequiredError('upwork.com', 'Upwork redirected to login. Open https://www.upwork.com in the connected browser and sign in, then retry.');
+        }
+        if (payload?.challenge) {
+            throw new CommandExecutionError('Upwork served a Cloudflare challenge page', 'Open https://www.upwork.com in the connected browser and clear the challenge, then retry.');
+        }
+        if (!payload?.ready) {
+            throw new CommandExecutionError(`Upwork feed state (window.__NUXT__.state.${stateKey}) was not present within 15s`, 'The page may not have finished hydrating, or the SSR state shape may have changed.');
+        }
+        if (!isPlainObject(payload)) {
+            throw new CommandExecutionError('Upwork feed returned an unexpected Browser Bridge payload shape');
+        }
+        if (!payload.jobsPresent || !Array.isArray(payload.jobs)) {
+            throw new CommandExecutionError(`Upwork feed state had an unexpected jobs shape; expected window.__NUXT__.state.${stateKey}.jobs to be an array.`);
+        }
+
+        const jobs = payload.jobs;
+        if (jobs.length === 0) {
+            throw new EmptyResultError(`upwork feed ${tab}`, `Upwork ${tab} feed is empty for the current account`);
+        }
+
+        const rows = jobsToListRows(jobs, { limit });
+        if (rows.length === 0) {
+            throw new CommandExecutionError('Upwork feed results did not include any job with a valid ciphertext id; cannot produce round-trippable detail rows.');
+        }
+        return rows;
+    },
+});

package/clis/upwork/search.js

@@ -0,0 +1,115 @@
+/**
+ * Upwork job search.
+ *
+ * Drives the public `/nx/search/jobs/?q=` page through a real browser
+ * session. The full search payload is embedded in `window.__NUXT__.state.
+ * jobsSearch.{jobs, paging}` after Nuxt SSR — we read straight from that
+ * global rather than DOM-scraping cards, because Upwork's card classes
+ * change frequently while the state shape has been stable.
+ */
+
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    CommandExecutionError,
+    EmptyResultError,
+    AuthRequiredError,
+} from '@jackwener/opencli/errors';
+import {
+    buildSearchUrl,
+    isPlainObject,
+    jobsToListRows,
+    LIST_COLUMNS,
+    requireBoundedInt,
+    requirePositiveInt,
+    requireQuery,
+    requireSort,
+    unwrapBrowserResult,
+} from './utils.js';
+
+cli({
+    site: 'upwork',
+    name: 'search',
+    access: 'read',
+    description: 'Upwork keyword job search (logged-in browser session, US site)',
+    domain: 'www.upwork.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Job keyword (skill / title / company)' },
+        { name: 'location', type: 'string', default: '', help: 'Country/city filter (e.g. "United States", "Remote")' },
+        { name: 'category', type: 'string', default: '', help: 'Category uid filter (advanced; from job detail `category` slug)' },
+        { name: 'sort', type: 'string', default: 'recency', help: 'Sort: recency | relevance | client_total_charge | client_total_reviews' },
+        { name: 'page', type: 'int', default: 1, help: 'Page number (1-based)' },
+        { name: 'per_page', type: 'int', default: 10, help: 'Rows per page (10-50, capped at one page)' },
+    ],
+    columns: LIST_COLUMNS,
+    func: async (page, kwargs) => {
+        const query = requireQuery(kwargs.query);
+        const location = String(kwargs.location ?? '').trim();
+        const category = String(kwargs.category ?? '').trim();
+        const sort = requireSort(kwargs.sort);
+        const pageNum = requirePositiveInt(kwargs.page, 1, 'page');
+        const perPage = requireBoundedInt(kwargs.per_page, 10, 10, 50, 'per_page');
+
+        const url = buildSearchUrl({ query, location, category, sort, page: pageNum, perPage });
+        await page.goto(url);
+        await page.wait(4);
+
+        let payload;
+        try {
+            payload = unwrapBrowserResult(await page.evaluate(`(async () => {
+                const haveState = () => !!(window.__NUXT__ && window.__NUXT__.state && window.__NUXT__.state.jobsSearch);
+                let ready = haveState();
+                for (let i = 0; i < 30; i++) {
+                    if (ready) break;
+                    await new Promise(r => setTimeout(r, 500));
+                    ready = haveState();
+                }
+                const onLogin = /\\/(ab\\/account-security\\/login|nx\\/login)/.test(location.pathname);
+                const challenge = (document.title || '').toLowerCase().includes('just a moment') || !!document.querySelector('[id^="cf-"]');
+                const state = window.__NUXT__ && window.__NUXT__.state && window.__NUXT__.state.jobsSearch;
+                return {
+                    ready,
+                    onLogin,
+                    challenge,
+                    jobsPresent: !!(state && Object.prototype.hasOwnProperty.call(state, 'jobs')),
+                    jobs: state ? state.jobs : undefined,
+                    paging: state && state.paging ? state.paging : null,
+                    status: state ? state.status : null,
+                };
+            })()`));
+        }
+        catch (e) {
+            throw new CommandExecutionError(`Failed to read Upwork search state: ${e?.message ?? e}`, 'The Nuxt state global was not reachable; try again after opening Upwork in the connected browser.');
+        }
+
+        if (payload?.onLogin) {
+            throw new AuthRequiredError('upwork.com', 'Upwork redirected to login. Open https://www.upwork.com in the connected browser and sign in, then retry.');
+        }
+        if (payload?.challenge) {
+            throw new CommandExecutionError('Upwork served a Cloudflare challenge page', 'Open https://www.upwork.com in the connected browser and clear the challenge, then retry.');
+        }
+        if (!payload?.ready) {
+            throw new CommandExecutionError('Upwork search state (window.__NUXT__.state.jobsSearch) was not present within 15s', 'The page may not have finished hydrating, or the SSR state shape may have changed.');
+        }
+        if (!isPlainObject(payload)) {
+            throw new CommandExecutionError('Upwork search returned an unexpected Browser Bridge payload shape');
+        }
+        if (!payload.jobsPresent || !Array.isArray(payload.jobs)) {
+            throw new CommandExecutionError('Upwork search state had an unexpected jobs shape; expected window.__NUXT__.state.jobsSearch.jobs to be an array.');
+        }
+
+        const jobs = payload.jobs;
+        if (jobs.length === 0) {
+            throw new EmptyResultError('upwork search', `No Upwork jobs matched "${query}"${location ? ` in ${location}` : ''}`);
+        }
+
+        const offset = (pageNum - 1) * perPage;
+        const rows = jobsToListRows(jobs, { offset, limit: perPage });
+        if (rows.length === 0) {
+            throw new CommandExecutionError('Upwork search results did not include any job with a valid ciphertext id; cannot produce round-trippable detail rows.');
+        }
+        return rows;
+    },
+});