xtrm-tools 0.7.2 → 0.7.4

package/.xtrm/skills/default/last30days/scripts/lib/vendor/bird-search/lib/runtime-query-ids.js

@@ -0,0 +1,264 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+const DEFAULT_CACHE_FILENAME = 'query-ids-cache.json';
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const DISCOVERY_PAGES = [
+    'https://x.com/?lang=en',
+    'https://x.com/explore',
+    'https://x.com/notifications',
+    'https://x.com/settings/profile',
+];
+const BUNDLE_URL_REGEX = /https:\/\/abs\.twimg\.com\/responsive-web\/client-web(?:-legacy)?\/[A-Za-z0-9.-]+\.js/g;
+const QUERY_ID_REGEX = /^[a-zA-Z0-9_-]+$/;
+const OPERATION_PATTERNS = [
+    {
+        regex: /e\.exports=\{queryId\s*:\s*["']([^"']+)["']\s*,\s*operationName\s*:\s*["']([^"']+)["']/gs,
+        operationGroup: 2,
+        queryIdGroup: 1,
+    },
+    {
+        regex: /e\.exports=\{operationName\s*:\s*["']([^"']+)["']\s*,\s*queryId\s*:\s*["']([^"']+)["']/gs,
+        operationGroup: 1,
+        queryIdGroup: 2,
+    },
+    {
+        regex: /operationName\s*[:=]\s*["']([^"']+)["'](.{0,4000}?)queryId\s*[:=]\s*["']([^"']+)["']/gs,
+        operationGroup: 1,
+        queryIdGroup: 3,
+    },
+    {
+        regex: /queryId\s*[:=]\s*["']([^"']+)["'](.{0,4000}?)operationName\s*[:=]\s*["']([^"']+)["']/gs,
+        operationGroup: 3,
+        queryIdGroup: 1,
+    },
+];
+const HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36',
+    Accept: 'text/html,application/json;q=0.9,*/*;q=0.8',
+    'Accept-Language': 'en-US,en;q=0.9',
+};
+async function fetchText(fetchImpl, url) {
+    const response = await fetchImpl(url, { headers: HEADERS });
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(`HTTP ${response.status} for ${url}: ${body.slice(0, 120)}`);
+    }
+    return response.text();
+}
+function resolveDefaultCachePath() {
+    const override = process.env.BIRD_QUERY_IDS_CACHE;
+    if (override && override.trim().length > 0) {
+        return path.resolve(override.trim());
+    }
+    return path.join(homedir(), '.config', 'bird', DEFAULT_CACHE_FILENAME);
+}
+function parseSnapshot(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return null;
+    }
+    const record = raw;
+    const fetchedAt = typeof record.fetchedAt === 'string' ? record.fetchedAt : null;
+    const ttlMs = typeof record.ttlMs === 'number' && Number.isFinite(record.ttlMs) ? record.ttlMs : null;
+    const ids = record.ids && typeof record.ids === 'object' ? record.ids : null;
+    const discovery = record.discovery && typeof record.discovery === 'object' ? record.discovery : null;
+    if (!fetchedAt || !ttlMs || !ids || !discovery) {
+        return null;
+    }
+    const pages = Array.isArray(discovery.pages) ? discovery.pages : null;
+    const bundles = Array.isArray(discovery.bundles) ? discovery.bundles : null;
+    if (!pages || !bundles) {
+        return null;
+    }
+    const normalizedIds = {};
+    for (const [key, value] of Object.entries(ids)) {
+        if (typeof value === 'string' && value.trim().length > 0) {
+            normalizedIds[key] = value.trim();
+        }
+    }
+    return {
+        fetchedAt,
+        ttlMs,
+        ids: normalizedIds,
+        discovery: {
+            pages: pages.filter((p) => typeof p === 'string'),
+            bundles: bundles.filter((b) => typeof b === 'string'),
+        },
+    };
+}
+async function readSnapshotFromDisk(cachePath) {
+    try {
+        const raw = await readFile(cachePath, 'utf8');
+        return parseSnapshot(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+async function writeSnapshotToDisk(cachePath, snapshot) {
+    await mkdir(path.dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, `${JSON.stringify(snapshot, null, 2)}\n`, 'utf8');
+}
+async function discoverBundles(fetchImpl) {
+    const bundles = new Set();
+    for (const page of DISCOVERY_PAGES) {
+        try {
+            const html = await fetchText(fetchImpl, page);
+            for (const match of html.matchAll(BUNDLE_URL_REGEX)) {
+                bundles.add(match[0]);
+            }
+        }
+        catch {
+            // ignore discovery page failures; other pages often work
+        }
+    }
+    const discovered = [...bundles];
+    if (discovered.length === 0) {
+        throw new Error('No client bundles discovered; x.com layout may have changed.');
+    }
+    return discovered;
+}
+function extractOperations(bundleContents, bundleLabel, targets, discovered) {
+    for (const pattern of OPERATION_PATTERNS) {
+        pattern.regex.lastIndex = 0;
+        while (true) {
+            const match = pattern.regex.exec(bundleContents);
+            if (match === null) {
+                break;
+            }
+            const operationName = match[pattern.operationGroup];
+            const queryId = match[pattern.queryIdGroup];
+            if (!operationName || !queryId) {
+                continue;
+            }
+            if (!targets.has(operationName)) {
+                continue;
+            }
+            if (!QUERY_ID_REGEX.test(queryId)) {
+                continue;
+            }
+            if (discovered.has(operationName)) {
+                continue;
+            }
+            discovered.set(operationName, { queryId, bundle: bundleLabel });
+            if (discovered.size === targets.size) {
+                return;
+            }
+        }
+    }
+}
+async function fetchAndExtract(fetchImpl, bundleUrls, targets) {
+    const discovered = new Map();
+    const CONCURRENCY = 6;
+    for (let i = 0; i < bundleUrls.length; i += CONCURRENCY) {
+        const chunk = bundleUrls.slice(i, i + CONCURRENCY);
+        await Promise.all(chunk.map(async (url) => {
+            if (discovered.size === targets.size) {
+                return;
+            }
+            const label = url.split('/').at(-1) ?? url;
+            try {
+                const js = await fetchText(fetchImpl, url);
+                extractOperations(js, label, targets, discovered);
+            }
+            catch {
+                // ignore failed bundles
+            }
+        }));
+        if (discovered.size === targets.size) {
+            break;
+        }
+    }
+    return discovered;
+}
+export function createRuntimeQueryIdStore(options = {}) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    const cachePath = options.cachePath ? path.resolve(options.cachePath) : resolveDefaultCachePath();
+    let memorySnapshot = null;
+    let loadOnce = null;
+    let refreshInFlight = null;
+    const loadSnapshot = async () => {
+        if (memorySnapshot) {
+            return memorySnapshot;
+        }
+        if (!loadOnce) {
+            loadOnce = (async () => {
+                const fromDisk = await readSnapshotFromDisk(cachePath);
+                memorySnapshot = fromDisk;
+                return fromDisk;
+            })();
+        }
+        return loadOnce;
+    };
+    const getSnapshotInfo = async () => {
+        const snapshot = await loadSnapshot();
+        if (!snapshot) {
+            return null;
+        }
+        const fetchedAtMs = new Date(snapshot.fetchedAt).getTime();
+        const ageMs = Number.isFinite(fetchedAtMs) ? Math.max(0, Date.now() - fetchedAtMs) : Number.POSITIVE_INFINITY;
+        const effectiveTtl = Number.isFinite(snapshot.ttlMs) ? snapshot.ttlMs : ttlMs;
+        const isFresh = ageMs <= effectiveTtl;
+        return { snapshot, cachePath, ageMs, isFresh };
+    };
+    const getQueryId = async (operationName) => {
+        const info = await getSnapshotInfo();
+        if (!info) {
+            return null;
+        }
+        return info.snapshot.ids[operationName] ?? null;
+    };
+    const refresh = async (operationNames, opts = {}) => {
+        if (refreshInFlight) {
+            return refreshInFlight;
+        }
+        refreshInFlight = (async () => {
+            const current = await getSnapshotInfo();
+            if (!opts.force && current?.isFresh) {
+                return current;
+            }
+            const targets = new Set(operationNames);
+            const bundleUrls = await discoverBundles(fetchImpl);
+            const discovered = await fetchAndExtract(fetchImpl, bundleUrls, targets);
+            if (discovered.size === 0) {
+                return current ?? null;
+            }
+            const ids = {};
+            for (const name of operationNames) {
+                const entry = discovered.get(name);
+                if (entry?.queryId) {
+                    ids[name] = entry.queryId;
+                }
+            }
+            const snapshot = {
+                fetchedAt: new Date().toISOString(),
+                ttlMs,
+                ids,
+                discovery: {
+                    pages: [...DISCOVERY_PAGES],
+                    bundles: bundleUrls.map((url) => url.split('/').at(-1) ?? url),
+                },
+            };
+            await writeSnapshotToDisk(cachePath, snapshot);
+            memorySnapshot = snapshot;
+            return getSnapshotInfo();
+        })().finally(() => {
+            refreshInFlight = null;
+        });
+        return refreshInFlight;
+    };
+    return {
+        cachePath,
+        ttlMs,
+        getSnapshotInfo,
+        getQueryId,
+        refresh,
+        clearMemory() {
+            memorySnapshot = null;
+            loadOnce = null;
+        },
+    };
+}
+export const runtimeQueryIds = createRuntimeQueryIdStore();
+//# sourceMappingURL=runtime-query-ids.js.map

package/.xtrm/skills/default/last30days/scripts/lib/vendor/bird-search/lib/twitter-client-base.js

@@ -0,0 +1,129 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+import { runtimeQueryIds } from './runtime-query-ids.js';
+import { QUERY_IDS, TARGET_QUERY_ID_OPERATIONS } from './twitter-client-constants.js';
+import { normalizeQuoteDepth } from './twitter-client-utils.js';
+export class TwitterClientBase {
+    authToken;
+    ct0;
+    cookieHeader;
+    userAgent;
+    timeoutMs;
+    quoteDepth;
+    clientUuid;
+    clientDeviceId;
+    clientUserId;
+    constructor(options) {
+        if (!options.cookies.authToken || !options.cookies.ct0) {
+            throw new Error('Both authToken and ct0 cookies are required');
+        }
+        this.authToken = options.cookies.authToken;
+        this.ct0 = options.cookies.ct0;
+        this.cookieHeader = options.cookies.cookieHeader || `auth_token=${this.authToken}; ct0=${this.ct0}`;
+        this.userAgent =
+            options.userAgent ||
+                'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36';
+        this.timeoutMs = options.timeoutMs;
+        this.quoteDepth = normalizeQuoteDepth(options.quoteDepth);
+        this.clientUuid = randomUUID();
+        this.clientDeviceId = randomUUID();
+    }
+    async sleep(ms) {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async getQueryId(operationName) {
+        const cached = await runtimeQueryIds.getQueryId(operationName);
+        return cached ?? QUERY_IDS[operationName];
+    }
+    async refreshQueryIds() {
+        if (process.env.NODE_ENV === 'test') {
+            return;
+        }
+        try {
+            await runtimeQueryIds.refresh(TARGET_QUERY_ID_OPERATIONS, { force: true });
+        }
+        catch {
+            // ignore refresh failures; callers will fall back to baked-in IDs
+        }
+    }
+    async withRefreshedQueryIdsOn404(attempt) {
+        const firstAttempt = await attempt();
+        if (firstAttempt.success || !firstAttempt.had404) {
+            return { result: firstAttempt, refreshed: false };
+        }
+        await this.refreshQueryIds();
+        const secondAttempt = await attempt();
+        return { result: secondAttempt, refreshed: true };
+    }
+    async getTweetDetailQueryIds() {
+        const primary = await this.getQueryId('TweetDetail');
+        return Array.from(new Set([primary, '97JF30KziU00483E_8elBA', 'aFvUsJm2c-oDkJV75blV6g']));
+    }
+    async getSearchTimelineQueryIds() {
+        const primary = await this.getQueryId('SearchTimeline');
+        return Array.from(new Set([primary, 'M1jEez78PEfVfbQLvlWMvQ', '5h0kNbk3ii97rmfY6CdgAA', 'Tp1sewRU1AsZpBWhqCZicQ']));
+    }
+    async fetchWithTimeout(url, init) {
+        if (!this.timeoutMs || this.timeoutMs <= 0) {
+            return fetch(url, init);
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            return await fetch(url, { ...init, signal: controller.signal });
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    getHeaders() {
+        return this.getJsonHeaders();
+    }
+    createTransactionId() {
+        return randomBytes(16).toString('hex');
+    }
+    getBaseHeaders() {
+        const headers = {
+            accept: '*/*',
+            'accept-language': 'en-US,en;q=0.9',
+            authorization: 'Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA',
+            'x-csrf-token': this.ct0,
+            'x-twitter-auth-type': 'OAuth2Session',
+            'x-twitter-active-user': 'yes',
+            'x-twitter-client-language': 'en',
+            'x-client-uuid': this.clientUuid,
+            'x-twitter-client-deviceid': this.clientDeviceId,
+            'x-client-transaction-id': this.createTransactionId(),
+            cookie: this.cookieHeader,
+            'user-agent': this.userAgent,
+            origin: 'https://x.com',
+            referer: 'https://x.com/',
+        };
+        if (this.clientUserId) {
+            headers['x-twitter-client-user-id'] = this.clientUserId;
+        }
+        return headers;
+    }
+    getJsonHeaders() {
+        return {
+            ...this.getBaseHeaders(),
+            'content-type': 'application/json',
+        };
+    }
+    getUploadHeaders() {
+        // Note: do not set content-type; URLSearchParams/FormData need to set it (incl boundary) themselves.
+        return this.getBaseHeaders();
+    }
+    async ensureClientUserId() {
+        if (process.env.NODE_ENV === 'test') {
+            return;
+        }
+        if (this.clientUserId) {
+            return;
+        }
+        const result = await this.getCurrentUser();
+        if (result.success && result.user?.id) {
+            this.clientUserId = result.user.id;
+        }
+    }
+}
+//# sourceMappingURL=twitter-client-base.js.map

package/.xtrm/skills/default/last30days/scripts/lib/vendor/bird-search/lib/twitter-client-constants.js

@@ -0,0 +1,50 @@
+// biome-ignore lint/correctness/useImportExtensions: JSON module import doesn't use .js extension.
+import queryIds from './query-ids.json' with { type: 'json' };
+export const TWITTER_API_BASE = 'https://x.com/i/api/graphql';
+export const TWITTER_GRAPHQL_POST_URL = 'https://x.com/i/api/graphql';
+export const TWITTER_UPLOAD_URL = 'https://upload.twitter.com/i/media/upload.json';
+export const TWITTER_MEDIA_METADATA_URL = 'https://x.com/i/api/1.1/media/metadata/create.json';
+export const TWITTER_STATUS_UPDATE_URL = 'https://x.com/i/api/1.1/statuses/update.json';
+export const SETTINGS_SCREEN_NAME_REGEX = /"screen_name":"([^"]+)"/;
+export const SETTINGS_USER_ID_REGEX = /"user_id"\s*:\s*"(\d+)"/;
+export const SETTINGS_NAME_REGEX = /"name":"([^"\\]*(?:\\.[^"\\]*)*)"/;
+// Query IDs rotate frequently; the values in query-ids.json are refreshed by
+// scripts/update-query-ids.ts. The fallback values keep the client usable if
+// the file is missing or incomplete.
+export const FALLBACK_QUERY_IDS = {
+    CreateTweet: 'TAJw1rBsjAtdNgTdlo2oeg',
+    CreateRetweet: 'ojPdsZsimiJrUGLR1sjUtA',
+    DeleteRetweet: 'iQtK4dl5hBmXewYZuEOKVw',
+    CreateFriendship: '8h9JVdV8dlSyqyRDJEPCsA',
+    DestroyFriendship: 'ppXWuagMNXgvzx6WoXBW0Q',
+    FavoriteTweet: 'lI07N6Otwv1PhnEgXILM7A',
+    UnfavoriteTweet: 'ZYKSe-w7KEslx3JhSIk5LA',
+    CreateBookmark: 'aoDbu3RHznuiSkQ9aNM67Q',
+    DeleteBookmark: 'Wlmlj2-xzyS1GN3a6cj-mQ',
+    TweetDetail: '97JF30KziU00483E_8elBA',
+    SearchTimeline: 'M1jEez78PEfVfbQLvlWMvQ',
+    UserArticlesTweets: '8zBy9h4L90aDL02RsBcCFg',
+    UserTweets: 'Wms1GvIiHXAPBaCr9KblaA',
+    Bookmarks: 'RV1g3b8n_SGOHwkqKYSCFw',
+    Following: 'BEkNpEt5pNETESoqMsTEGA',
+    Followers: 'kuFUYP9eV1FPoEy4N-pi7w',
+    Likes: 'JR2gceKucIKcVNB_9JkhsA',
+    BookmarkFolderTimeline: 'KJIQpsvxrTfRIlbaRIySHQ',
+    ListOwnerships: 'wQcOSjSQ8NtgxIwvYl1lMg',
+    ListMemberships: 'BlEXXdARdSeL_0KyKHHvvg',
+    ListLatestTweetsTimeline: '2TemLyqrMpTeAmysdbnVqw',
+    ListByRestId: 'wXzyA5vM_aVkBL9G8Vp3kw',
+    HomeTimeline: 'edseUwk9sP5Phz__9TIRnA',
+    HomeLatestTimeline: 'iOEZpOdfekFsxSlPQCQtPg',
+    ExploreSidebar: 'lpSN4M6qpimkF4nRFPE3nQ',
+    ExplorePage: 'kheAINB_4pzRDqkzG3K-ng',
+    GenericTimelineById: 'uGSr7alSjR9v6QJAIaqSKQ',
+    TrendHistory: 'Sj4T-jSB9pr0Mxtsc1UKZQ',
+    AboutAccountQuery: 'zs_jFPFT78rBpXv9Z3U2YQ',
+};
+export const QUERY_IDS = {
+    ...FALLBACK_QUERY_IDS,
+    ...queryIds,
+};
+export const TARGET_QUERY_ID_OPERATIONS = Object.keys(FALLBACK_QUERY_IDS);
+//# sourceMappingURL=twitter-client-constants.js.map