@jackwener/opencli 1.7.17 → 1.7.19

package/clis/twitter/shared.js

@@ -1,8 +1,28 @@
 import { ArgumentError } from '@jackwener/opencli/errors';
 
 const QUERY_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+const SCREEN_NAME_PATTERN = /^[A-Za-z0-9_]{1,15}$/;
 const TWEET_PATH_PATTERN = /^\/(?:[^/]+|i)\/status\/(\d+)\/?$/;
 const TWEET_HOSTS = new Set(['x.com', 'twitter.com']);
+const SCREEN_NAME_HOSTS = new Set(['x.com', 'twitter.com', 'mobile.twitter.com']);
+const RESERVED_SCREEN_NAME_PATHS = new Set([
+    'compose',
+    'explore',
+    'help',
+    'home',
+    'i',
+    'intent',
+    'jobs',
+    'login',
+    'logout',
+    'messages',
+    'notifications',
+    'privacy',
+    'search',
+    'settings',
+    'signup',
+    'tos',
+]);
 
 function isTwitterHost(hostname) {
     return TWEET_HOSTS.has(hostname)
@@ -81,9 +101,138 @@ export function buildTwitterArticleScopeSource(tweetId) {
 export function sanitizeQueryId(resolved, fallbackId) {
     return typeof resolved === 'string' && QUERY_ID_PATTERN.test(resolved) ? resolved : fallbackId;
 }
-export async function resolveTwitterQueryId(page, operationName, fallbackId) {
+
+export function normalizeTwitterScreenName(value) {
+    const raw = String(value ?? '').trim();
+    if (!raw) return '';
+    let candidate = '';
+    try {
+        const url = raw.startsWith('/') ? new URL(raw, 'https://x.com') : new URL(raw);
+        if (
+            url.protocol !== 'https:' ||
+            url.username ||
+            url.password ||
+            url.port ||
+            !SCREEN_NAME_HOSTS.has(url.hostname)
+        ) {
+            return '';
+        }
+        const segments = url.pathname.split('/').filter(Boolean);
+        if (segments.length !== 1) return '';
+        candidate = segments[0];
+    } catch {
+        if (raw.includes('/') || raw.includes('?') || raw.includes('#')) return '';
+        candidate = raw.replace(/^@+/, '');
+    }
+    if (!SCREEN_NAME_PATTERN.test(candidate)) return '';
+    if (RESERVED_SCREEN_NAME_PATHS.has(candidate.toLowerCase())) return '';
+    return candidate;
+}
+
+function keysToFlags(keys) {
+    if (!Array.isArray(keys)) return {};
+    return Object.fromEntries(keys.filter((key) => typeof key === 'string' && key).map((key) => [key, true]));
+}
+
+function normalizeOperationFallback(fallback) {
+    if (typeof fallback === 'string') return { queryId: fallback, features: {}, fieldToggles: {} };
+    return {
+        queryId: fallback?.queryId || null,
+        features: fallback?.features || {},
+        fieldToggles: fallback?.fieldToggles || {},
+    };
+}
+
+export function unwrapBrowserResult(value) {
+    if (
+        value
+        && typeof value === 'object'
+        && typeof value.session === 'string'
+        && Object.prototype.hasOwnProperty.call(value, 'data')
+    ) {
+        return value.data;
+    }
+    return value;
+}
+
+export function normalizeTwitterGraphqlPayload(value) {
+    const unwrapped = unwrapBrowserResult(value);
+    if (unwrapped?.data && typeof unwrapped.data === 'object') return unwrapped;
+    if (
+        unwrapped
+        && typeof unwrapped === 'object'
+        && (
+            Object.prototype.hasOwnProperty.call(unwrapped, 'user')
+            || Object.prototype.hasOwnProperty.call(unwrapped, 'search_by_raw_query')
+        )
+    ) {
+        return { data: unwrapped };
+    }
+    return unwrapped;
+}
+
+export function sanitizeTwitterOperationMetadata(resolved, fallback) {
+    const value = unwrapBrowserResult(resolved);
+    const normalizedFallback = normalizeOperationFallback(fallback);
+    // Empty resolved features / fieldToggles must defer to the baked fallback.
+    // The bundle parser can find a queryId but miss `featureSwitches:[...]` (e.g.
+    // a minification change, or the 2500-char snippet window truncating before
+    // the array). When that happens, keysToFlags(undefined) returns {}; if we
+    // kept it, Twitter would receive an empty `features` map and respond 400,
+    // surfacing a misleading "queryId expired" error.
+    return {
+        queryId: sanitizeQueryId(value?.queryId, normalizedFallback.queryId),
+        features: value?.features
+            && typeof value.features === 'object'
+            && Object.keys(value.features).length > 0
+            ? value.features
+            : normalizedFallback.features,
+        fieldToggles: value?.fieldToggles
+            && typeof value.fieldToggles === 'object'
+            && Object.keys(value.fieldToggles).length > 0
+            ? value.fieldToggles
+            : normalizedFallback.fieldToggles,
+    };
+}
+
+export async function resolveTwitterOperationMetadata(page, operationName, fallback) {
     const resolved = await page.evaluate(`async () => {
     const operationName = ${JSON.stringify(operationName)};
+    const keysToFlags = (keys) => Object.fromEntries((keys || []).map((key) => [key, true]));
+    const quotedKeys = (source) => source
+      ? Array.from(source.matchAll(/"([^"]+)"/g)).map((match) => match[1])
+      : [];
+    const parseOperation = (text) => {
+      const marker = 'operationName:"' + operationName + '"';
+      const index = text.indexOf(marker);
+      if (index < 0) return null;
+      const start = Math.max(0, text.lastIndexOf('e.exports=', index));
+      const endMarker = text.indexOf('}}}', index);
+      const snippet = text.slice(start, endMarker > index ? endMarker + 3 : index + 2500);
+      const queryId = snippet.match(/queryId:"([A-Za-z0-9_-]+)"/)?.[1] || null;
+      if (!queryId) return null;
+      return {
+        queryId,
+        features: keysToFlags(quotedKeys(snippet.match(/featureSwitches:\\[([^\\]]*)\\]/)?.[1])),
+        fieldToggles: keysToFlags(quotedKeys(snippet.match(/fieldToggles:\\[([^\\]]*)\\]/)?.[1])),
+      };
+    };
+    try {
+      const scripts = Array.from(document.scripts)
+        .map(s => s.src)
+        .filter(Boolean)
+        .concat(performance.getEntriesByType('resource')
+          .map(r => r.name)
+          .filter(r => r.includes('client-web') && r.endsWith('.js')));
+      const uniqueScripts = Array.from(new Set(scripts));
+      for (const scriptUrl of uniqueScripts.slice(-30)) {
+        try {
+          const text = await (await fetch(scriptUrl)).text();
+          const operation = parseOperation(text);
+          if (operation) return operation;
+        } catch {}
+      }
+    } catch {}
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 5000);
     try {
@@ -92,27 +241,25 @@ export async function resolveTwitterQueryId(page, operationName, fallbackId) {
       if (ghResp.ok) {
         const data = await ghResp.json();
         const entry = data?.[operationName];
-        if (entry && entry.queryId) return entry.queryId;
+        if (entry && entry.queryId) {
+          return {
+            queryId: entry.queryId,
+            features: keysToFlags(entry.featureSwitches),
+            fieldToggles: keysToFlags(entry.fieldToggles),
+          };
+        }
       }
     } catch {
       clearTimeout(timeout);
     }
-    try {
-      const scripts = performance.getEntriesByType('resource')
-        .filter(r => r.name.includes('client-web') && r.name.endsWith('.js'))
-        .map(r => r.name);
-      for (const scriptUrl of scripts.slice(0, 15)) {
-        try {
-          const text = await (await fetch(scriptUrl)).text();
-          const re = new RegExp('queryId:"([A-Za-z0-9_-]+)"[^}]{0,200}operationName:"' + operationName + '"');
-          const match = text.match(re);
-          if (match) return match[1];
-        } catch {}
-      }
-    } catch {}
     return null;
   }`);
-    return sanitizeQueryId(resolved, fallbackId);
+    return sanitizeTwitterOperationMetadata(resolved, fallback);
+}
+
+export async function resolveTwitterQueryId(page, operationName, fallbackId) {
+    const operation = await resolveTwitterOperationMetadata(page, operationName, fallbackId);
+    return operation.queryId;
 }
 /**
  * Extract media flags and URLs from a tweet's `legacy` object.
@@ -143,6 +290,10 @@ export function extractMedia(legacy) {
 }
 export const __test__ = {
     sanitizeQueryId,
+    sanitizeTwitterOperationMetadata,
+    unwrapBrowserResult,
+    normalizeTwitterGraphqlPayload,
+    normalizeTwitterScreenName,
     extractMedia,
     parseTweetUrl,
     buildTwitterArticleScopeSource,

package/clis/twitter/shared.test.js

@@ -3,7 +3,108 @@ import { JSDOM } from 'jsdom';
 import { __test__ } from './shared.js';
 import { ArgumentError } from '@jackwener/opencli/errors';
 
-const { extractMedia, parseTweetUrl, buildTwitterArticleScopeSource } = __test__;
+const { extractMedia, parseTweetUrl, buildTwitterArticleScopeSource, unwrapBrowserResult, normalizeTwitterGraphqlPayload, normalizeTwitterScreenName, sanitizeTwitterOperationMetadata } = __test__;
+
+describe('twitter browser result helpers', () => {
+    it('unwraps Browser Bridge exec envelopes', () => {
+        expect(unwrapBrowserResult({ session: 'site:twitter', data: '123' })).toBe('123');
+        expect(unwrapBrowserResult({ data: { user: true } })).toEqual({ data: { user: true } });
+    });
+
+    it('sanitizes operation metadata after unwrapping Browser Bridge envelopes', () => {
+        const result = sanitizeTwitterOperationMetadata({
+            session: 'site:twitter',
+            data: {
+                queryId: 'abc_123',
+                features: { feature: true },
+                fieldToggles: { field: true },
+            },
+        }, { queryId: 'fallback', features: {}, fieldToggles: {} });
+        expect(result).toEqual({
+            queryId: 'abc_123',
+            features: { feature: true },
+            fieldToggles: { field: true },
+        });
+    });
+
+    it('falls back to baked features / fieldToggles when the bundle parser returns empty maps', () => {
+        // Regression guard: resolveTwitterOperationMetadata's bundle parser can
+        // find a queryId but miss `featureSwitches:[...]` (e.g. minification
+        // change, or the 2500-char snippet window truncating before the array).
+        // In that case keysToFlags(undefined) returns {}; if sanitize kept the
+        // empty map, Twitter would receive a request with no features and reply
+        // 400, surfacing a misleading "queryId expired" error.
+        const result = sanitizeTwitterOperationMetadata({
+            queryId: 'newQueryId',
+            features: {},
+            fieldToggles: {},
+        }, {
+            queryId: 'fallback',
+            features: { fallback_feature: true },
+            fieldToggles: { fallback_field: true },
+        });
+        expect(result).toEqual({
+            queryId: 'newQueryId',
+            features: { fallback_feature: true },
+            fieldToggles: { fallback_field: true },
+        });
+    });
+
+    it('falls back when resolved features are non-object falsy values', () => {
+        const result = sanitizeTwitterOperationMetadata({
+            queryId: 'newQueryId',
+            features: null,
+            fieldToggles: undefined,
+        }, {
+            queryId: 'fallback',
+            features: { fallback_feature: true },
+            fieldToggles: { fallback_field: true },
+        });
+        expect(result.features).toEqual({ fallback_feature: true });
+        expect(result.fieldToggles).toEqual({ fallback_field: true });
+    });
+
+    it('normalizes GraphQL payloads when the bridge strips the top-level data key', () => {
+        expect(normalizeTwitterGraphqlPayload({ user: { result: {} } })).toEqual({
+            data: { user: { result: {} } },
+        });
+        expect(normalizeTwitterGraphqlPayload({ search_by_raw_query: { search_timeline: {} } })).toEqual({
+            data: { search_by_raw_query: { search_timeline: {} } },
+        });
+        expect(normalizeTwitterGraphqlPayload({ data: { user: {} } })).toEqual({ data: { user: {} } });
+    });
+});
+
+describe('twitter normalizeTwitterScreenName', () => {
+    it('accepts exact handles and exact Twitter/X profile URLs', () => {
+        expect(normalizeTwitterScreenName('@viewer')).toBe('viewer');
+        expect(normalizeTwitterScreenName('/viewer')).toBe('viewer');
+        expect(normalizeTwitterScreenName('https://x.com/viewer')).toBe('viewer');
+        expect(normalizeTwitterScreenName('https://twitter.com/viewer?lang=en')).toBe('viewer');
+        expect(normalizeTwitterScreenName('https://mobile.twitter.com/viewer')).toBe('viewer');
+    });
+
+    it('rejects route collisions, malformed handles, and non-exact profile URLs', () => {
+        const invalid = [
+            '/home',
+            '/viewer/extra',
+            'viewer/extra',
+            'viewer?tab=posts',
+            'https://x.com/home',
+            'https://x.com/viewer/status/1',
+            'http://x.com/viewer',
+            'https://evil.com/viewer',
+            'https://x.com.evil.com/viewer',
+            'https://x.com:444/viewer',
+            'https://user:pass@x.com/viewer',
+            'bad-handle',
+            'abcdefghijklmnop',
+        ];
+        for (const value of invalid) {
+            expect(normalizeTwitterScreenName(value)).toBe('');
+        }
+    });
+});
 
 describe('twitter parseTweetUrl', () => {
     it('accepts exact Twitter/X tweet URLs and preserves query parameters', () => {

package/clis/twitter/timeline.js

@@ -5,6 +5,7 @@ import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
 // ── Twitter GraphQL constants ──────────────────────────────────────────
 const HOME_TIMELINE_QUERY_ID = 'c-CzHF1LboFilMpsx4ZCrQ';
 const HOME_LATEST_TIMELINE_QUERY_ID = 'BKB7oi212Fi7kQtCBGE4zA';
+const MAX_PAGINATION_PAGES = 100;
 // Endpoint config: for-you uses GET HomeTimeline, following uses POST HomeLatestTimeline
 const TIMELINE_ENDPOINTS = {
     'for-you': { endpoint: 'HomeTimeline', method: 'GET', fallbackQueryId: HOME_TIMELINE_QUERY_ID },
@@ -176,7 +177,8 @@ cli({
         const allTweets = [];
         const seen = new Set();
         let cursor = null;
-        for (let i = 0; i < 5 && allTweets.length < limit; i++) {
+        // Runaway guard only; --limit and cursor exhaustion control normal pagination.
+        for (let i = 0; i < MAX_PAGINATION_PAGES && allTweets.length < limit; i++) {
             const fetchCount = Math.min(40, limit - allTweets.length + 5); // over-fetch slightly for promoted filtering
             const variables = buildTimelineVariables(timelineType, fetchCount, cursor);
             const apiUrl = buildHomeTimelineUrl(queryId, endpoint, variables);

package/clis/twitter/tweets.js

@@ -1,15 +1,19 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
-import { resolveTwitterQueryId, sanitizeQueryId, extractMedia } from './shared.js';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { resolveTwitterOperationMetadata, sanitizeQueryId, extractMedia, normalizeTwitterGraphqlPayload, unwrapBrowserResult } from './shared.js';
+import { normalizeTwitterScreenName } from './shared.js';
 import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
 
-const USER_TWEETS_QUERY_ID = '6fWQaBPK51aGyC_VC7t9GQ';
+const USER_TWEETS_QUERY_ID = 'lrMzG9qPQHpqJdP3AbM-bQ';
 const USER_BY_SCREEN_NAME_QUERY_ID = 'IGgvgiOx4QZndDHuD3x9TQ';
+const MAX_PAGINATION_PAGES = 100;
 
 const USER_TWEETS_FEATURES = {
-    rweb_video_screen_enabled: false,
+    rweb_video_screen_enabled: true,
+    rweb_cashtags_enabled: true,
     payments_enabled: false,
     profile_label_improvements_pcf_label_in_post_enabled: true,
+    responsive_web_profile_redirect_enabled: true,
     rweb_tipjar_consumption_enabled: true,
     verified_phone_label_enabled: false,
     creator_subscriptions_tweet_preview_api_enabled: true,
@@ -20,6 +24,7 @@ const USER_TWEETS_FEATURES = {
     c9s_tweet_anatomy_moderator_badge_enabled: true,
     responsive_web_grok_analyze_button_fetch_trends_enabled: false,
     responsive_web_grok_analyze_post_followups_enabled: true,
+    rweb_cashtags_composer_attachment_enabled: true,
     responsive_web_jetfuel_frame: true,
     responsive_web_grok_share_attachment_enabled: true,
     responsive_web_grok_annotations_enabled: true,
@@ -46,8 +51,21 @@ const USER_TWEETS_FEATURES = {
     responsive_web_enhance_cards_enabled: false,
 };
 
+const USER_TWEETS_FIELD_TOGGLES = {
+    withPayments: true,
+    withAuxiliaryUserLabels: true,
+    withArticleRichContentState: true,
+    withArticlePlainText: true,
+    withArticleSummaryText: true,
+    withArticleVoiceOver: true,
+    withGrokAnalyze: true,
+    withDisallowedReplyControls: true,
+};
+
 const USER_BY_SCREEN_NAME_FEATURES = {
     hidden_profile_subscriptions_enabled: true,
+    profile_label_improvements_pcf_label_in_post_enabled: true,
+    responsive_web_profile_redirect_enabled: true,
     rweb_tipjar_consumption_enabled: true,
     responsive_web_graphql_exclude_directive_enabled: true,
     verified_phone_label_enabled: false,
@@ -61,7 +79,59 @@ const USER_BY_SCREEN_NAME_FEATURES = {
     responsive_web_graphql_timeline_navigation_enabled: true,
 };
 
-function buildUserTweetsUrl(queryId, userId, count, cursor) {
+const USER_BY_SCREEN_NAME_FIELD_TOGGLES = {
+    withPayments: true,
+    withAuxiliaryUserLabels: true,
+};
+
+const USER_TWEETS_OPERATION = {
+    queryId: USER_TWEETS_QUERY_ID,
+    features: USER_TWEETS_FEATURES,
+    fieldToggles: USER_TWEETS_FIELD_TOGGLES,
+};
+
+const USER_BY_SCREEN_NAME_OPERATION = {
+    queryId: USER_BY_SCREEN_NAME_QUERY_ID,
+    features: USER_BY_SCREEN_NAME_FEATURES,
+    fieldToggles: USER_BY_SCREEN_NAME_FIELD_TOGGLES,
+};
+
+function normalizeUserTweetsOperation(operation) {
+    if (typeof operation === 'string') {
+        return { queryId: operation, features: USER_TWEETS_FEATURES, fieldToggles: USER_TWEETS_FIELD_TOGGLES };
+    }
+    return {
+        queryId: operation?.queryId || USER_TWEETS_QUERY_ID,
+        features: operation?.features || USER_TWEETS_FEATURES,
+        fieldToggles: operation?.fieldToggles || USER_TWEETS_FIELD_TOGGLES,
+    };
+}
+
+function normalizeUserByScreenNameOperation(operation) {
+    if (typeof operation === 'string') {
+        return { queryId: operation, features: USER_BY_SCREEN_NAME_FEATURES, fieldToggles: USER_BY_SCREEN_NAME_FIELD_TOGGLES };
+    }
+    return {
+        queryId: operation?.queryId || USER_BY_SCREEN_NAME_QUERY_ID,
+        features: operation?.features || USER_BY_SCREEN_NAME_FEATURES,
+        fieldToggles: operation?.fieldToggles || USER_BY_SCREEN_NAME_FIELD_TOGGLES,
+    };
+}
+
+function appendGraphqlParams(path, variables, operation) {
+    const fieldToggles = operation.fieldToggles || {};
+    const params = [
+        `variables=${encodeURIComponent(JSON.stringify(variables))}`,
+        `features=${encodeURIComponent(JSON.stringify(operation.features || {}))}`,
+    ];
+    if (Object.keys(fieldToggles).length > 0) {
+        params.push(`fieldToggles=${encodeURIComponent(JSON.stringify(fieldToggles))}`);
+    }
+    return `${path}?${params.join('&')}`;
+}
+
+function buildUserTweetsUrl(operation, userId, count, cursor) {
+    const normalized = normalizeUserTweetsOperation(operation);
     const vars = {
         userId,
         count,
@@ -70,21 +140,20 @@ function buildUserTweetsUrl(queryId, userId, count, cursor) {
         withVoice: true,
     };
     if (cursor) vars.cursor = cursor;
-    return `/i/api/graphql/${queryId}/UserTweets`
-        + `?variables=${encodeURIComponent(JSON.stringify(vars))}`
-        + `&features=${encodeURIComponent(JSON.stringify(USER_TWEETS_FEATURES))}`;
+    return appendGraphqlParams(`/i/api/graphql/${normalized.queryId}/UserTweets`, vars, normalized);
 }
 
-function buildUserByScreenNameUrl(queryId, screenName) {
+function buildUserByScreenNameUrl(operation, screenName) {
+    const normalized = normalizeUserByScreenNameOperation(operation);
     const vars = { screen_name: screenName, withSafetyModeUserFields: true };
-    return `/i/api/graphql/${queryId}/UserByScreenName`
-        + `?variables=${encodeURIComponent(JSON.stringify(vars))}`
-        + `&features=${encodeURIComponent(JSON.stringify(USER_BY_SCREEN_NAME_FEATURES))}`;
+    return appendGraphqlParams(`/i/api/graphql/${normalized.queryId}/UserByScreenName`, vars, normalized);
 }
 
 function extractTweet(result, seen) {
     if (!result) return null;
-    const tw = result.tweet || result;
+    const tw = result.__typename === 'TweetWithVisibilityResults' && result.tweet
+        ? result.tweet
+        : (result.tweet || result);
     const legacy = tw.legacy || {};
     if (!tw.rest_id || seen.has(tw.rest_id)) return null;
     seen.add(tw.rest_id);
@@ -112,32 +181,35 @@ function extractTweet(result, seen) {
 function parseUserTweets(data, seen) {
     const tweets = [];
     let nextCursor = null;
-    const instructions = data?.data?.user?.result?.timeline_v2?.timeline?.instructions
-        || data?.data?.user?.result?.timeline?.timeline?.instructions
-        || [];
-    for (const inst of instructions) {
-        if (inst.type === 'TimelinePinEntry') continue;
-        for (const entry of inst.entries || []) {
-            const content = entry.content;
-            if (content?.entryType === 'TimelineTimelineCursor' || content?.__typename === 'TimelineTimelineCursor') {
-                if (content.cursorType === 'Bottom' || content.cursorType === 'ShowMore') nextCursor = content.value;
-                continue;
-            }
-            if (entry.entryId?.startsWith('cursor-bottom-') || entry.entryId?.startsWith('cursor-showMore-')) {
-                nextCursor = content?.value || content?.itemContent?.value || nextCursor;
-                continue;
-            }
-            const direct = extractTweet(content?.itemContent?.tweet_results?.result, seen);
-            if (direct) {
-                tweets.push(direct);
-                continue;
-            }
-            for (const item of content?.items || []) {
-                const nested = extractTweet(item.item?.itemContent?.tweet_results?.result, seen);
-                if (nested) tweets.push(nested);
-            }
+    const result = data?.data?.user?.result || {};
+    const instructionSets = [
+        result.timeline_v2?.timeline?.instructions,
+        result.timeline?.timeline?.instructions,
+    ].filter(Array.isArray);
+    const instructions = instructionSets.flat();
+    const visit = (value) => {
+        if (!value || typeof value !== 'object') return;
+        if (value.type === 'TimelinePinEntry') return;
+        if (value.tweet_results?.result) {
+            const tweet = extractTweet(value.tweet_results.result, seen);
+            if (tweet) tweets.push(tweet);
         }
-    }
+        if (
+            (value.entryType === 'TimelineTimelineCursor' || value.__typename === 'TimelineTimelineCursor')
+            && (value.cursorType === 'Bottom' || value.cursorType === 'ShowMore')
+            && value.value
+        ) {
+            nextCursor = value.value;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) visit(item);
+            return;
+        }
+        for (const child of Object.values(value)) {
+            if (child && typeof child === 'object') visit(child);
+        }
+    };
+    visit(instructions);
     return { tweets, nextCursor };
 }
 
@@ -145,28 +217,51 @@ cli({
     site: 'twitter',
     name: 'tweets',
     access: 'read',
-    description: "Fetch a Twitter user's most recent tweets (chronological, excludes pinned)",
+    description: "Fetch a Twitter user's most recent tweets (chronological, excludes pinned; defaults to the logged-in user when no username is given)",
     domain: 'x.com',
     strategy: Strategy.COOKIE,
     browser: true,
     siteSession: 'persistent',
     args: [
-        { name: 'username', type: 'string', positional: true, required: true, help: 'Twitter screen name (with or without @)' },
+        { name: 'username', type: 'string', positional: true, help: 'Twitter screen name (with or without @). Defaults to the logged-in user when omitted.' },
         { name: 'limit', type: 'int', default: 20, help: 'Max tweets to return' },
         { name: 'top-by-engagement', type: 'int', default: 0, help: 'When set to N>0, re-rank the tweets by weighted engagement (likes×1 + retweets×3 + replies×2 + bookmarks×5 + log10(views+1)×0.5) and return the top N. Default 0 keeps the chronological ordering.' },
     ],
     columns: ['id', 'author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls'],
     func: async (page, kwargs) => {
         const limit = Math.max(1, Math.min(200, kwargs.limit || 20));
-        const username = String(kwargs.username || '').replace(/^@/, '').trim();
-        if (!username) throw new CommandExecutionError('username is required');
+        const rawUsername = String(kwargs.username ?? '').trim();
+        let username = normalizeTwitterScreenName(rawUsername);
+        if (rawUsername && !username) {
+            throw new ArgumentError('twitter tweets username must be a valid Twitter/X handle', 'Example: opencli twitter tweets @jack --limit 20');
+        }
+        // When no username is given, detect the logged-in user (own tweets).
+        // Mirrors the self-detection pattern used by twitter/profile and
+        // twitter/likes so agents can pull own-account data without having
+        // to know their own screen name up front.
+        if (!username) {
+            await page.goto('https://x.com/home');
+            await page.wait({ selector: '[data-testid="primaryColumn"]' });
+            // Bridge wraps primitive page.evaluate returns as { session, data:<value> }.
+            // unwrapBrowserResult drops that envelope so the href string is usable.
+            const href = unwrapBrowserResult(await page.evaluate(`() => {
+        const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
+        return link ? link.getAttribute('href') : null;
+      }`));
+            if (!href || typeof href !== 'string')
+                throw new AuthRequiredError('x.com', 'Could not detect logged-in user. Are you logged in?');
+            username = normalizeTwitterScreenName(href);
+            if (!username) {
+                throw new AuthRequiredError('x.com', 'Could not detect logged-in user. Are you logged in?');
+            }
+        }
 
         const cookies = await page.getCookies({ url: 'https://x.com' });
         const ct0 = cookies.find((c) => c.name === 'ct0')?.value || null;
         if (!ct0) throw new AuthRequiredError('x.com', 'Not logged into x.com (no ct0 cookie)');
 
-        const userTweetsQueryId = await resolveTwitterQueryId(page, 'UserTweets', USER_TWEETS_QUERY_ID);
-        const userByScreenNameQueryId = await resolveTwitterQueryId(page, 'UserByScreenName', USER_BY_SCREEN_NAME_QUERY_ID);
+        const userTweetsOperation = await resolveTwitterOperationMetadata(page, 'UserTweets', USER_TWEETS_OPERATION);
+        const userByScreenNameOperation = await resolveTwitterOperationMetadata(page, 'UserByScreenName', USER_BY_SCREEN_NAME_OPERATION);
 
         const headers = JSON.stringify({
             'Authorization': `Bearer ${decodeURIComponent(TWITTER_BEARER_TOKEN)}`,
@@ -175,25 +270,26 @@ cli({
             'X-Twitter-Active-User': 'yes',
         });
 
-        const ubsUrl = buildUserByScreenNameUrl(userByScreenNameQueryId, username);
-        const userId = await page.evaluate(`async () => {
+        const ubsUrl = buildUserByScreenNameUrl(userByScreenNameOperation, username);
+        const userId = unwrapBrowserResult(await page.evaluate(`async () => {
       const resp = await fetch("${ubsUrl}", { headers: ${headers}, credentials: 'include' });
       if (!resp.ok) return null;
       const d = await resp.json();
       return d?.data?.user?.result?.rest_id || null;
-    }`);
+    }`));
         if (!userId) throw new CommandExecutionError(`Could not resolve @${username}`);
 
         const seen = new Set();
         const all = [];
         let cursor = null;
-        for (let i = 0; i < 5 && all.length < limit; i++) {
+        // Runaway guard only; --limit and cursor exhaustion control normal pagination.
+        for (let i = 0; i < MAX_PAGINATION_PAGES && all.length < limit; i++) {
             const fetchCount = Math.min(100, limit - all.length + 10);
-            const url = buildUserTweetsUrl(userTweetsQueryId, userId, fetchCount, cursor);
-            const data = await page.evaluate(`async () => {
+            const url = buildUserTweetsUrl(userTweetsOperation, userId, fetchCount, cursor);
+            const data = normalizeTwitterGraphqlPayload(await page.evaluate(`async () => {
         const r = await fetch("${url}", { headers: ${headers}, credentials: 'include' });
         return r.ok ? await r.json() : { error: r.status };
-      }`);
+      }`));
             if (data?.error) {
                 if (all.length === 0) throw new CommandExecutionError(`HTTP ${data.error}: UserTweets fetch failed — queryId may have expired`);
                 break;