fieldtheory-cli-windowsport 0.1.0

package/dist/command-path.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { constants as fsConstants } from 'node:fs';
+function pathEntries() {
+    return (process.env.PATH ?? '')
+        .split(path.delimiter)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function commandExtensions() {
+    if (process.platform !== 'win32')
+        return [''];
+    const raw = process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD';
+    return raw
+        .split(';')
+        .map((entry) => entry.trim().toLowerCase())
+        .filter(Boolean);
+}
+function candidateNames(command) {
+    if (process.platform !== 'win32')
+        return [command];
+    const lower = command.toLowerCase();
+    const hasKnownExtension = commandExtensions().some((ext) => lower.endsWith(ext));
+    if (hasKnownExtension)
+        return [command];
+    return ['', ...commandExtensions()].map((ext) => `${command}${ext}`);
+}
+function isExecutable(filePath) {
+    if (!fs.existsSync(filePath))
+        return false;
+    if (process.platform === 'win32')
+        return true;
+    try {
+        fs.accessSync(filePath, fsConstants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveCommandPath(command) {
+    const includesSeparator = command.includes('/') || command.includes('\\');
+    if (includesSeparator) {
+        const absolute = path.resolve(command);
+        return isExecutable(absolute) ? absolute : null;
+    }
+    for (const dir of pathEntries()) {
+        for (const name of candidateNames(command)) {
+            const fullPath = path.join(dir, name);
+            if (isExecutable(fullPath))
+                return fullPath;
+        }
+    }
+    return null;
+}
+export function isCommandAvailable(command) {
+    return resolveCommandPath(command) !== null;
+}

package/dist/config.js

@@ -0,0 +1,54 @@
+import { config as loadDotenv } from 'dotenv';
+import path from 'node:path';
+import os from 'node:os';
+import { dataDir } from './paths.js';
+export function loadEnv() {
+    const dir = dataDir();
+    const candidatePaths = [
+        path.join(process.cwd(), '.env.local'),
+        path.join(process.cwd(), '.env'),
+        path.join(dir, '.env.local'),
+        path.join(dir, '.env'),
+    ];
+    for (const envPath of candidatePaths) {
+        loadDotenv({ path: envPath, quiet: true });
+    }
+}
+function detectChromeUserDataDir() {
+    const platform = os.platform();
+    const home = os.homedir();
+    if (platform === 'darwin')
+        return path.join(home, 'Library', 'Application Support', 'Google', 'Chrome');
+    if (platform === 'linux')
+        return path.join(home, '.config', 'google-chrome');
+    if (platform === 'win32')
+        return path.join(home, 'AppData', 'Local', 'Google', 'Chrome', 'User Data');
+    return undefined;
+}
+export function loadChromeSessionConfig() {
+    loadEnv();
+    const dir = process.env.FTX_CHROME_USER_DATA_DIR ?? process.env.FT_CHROME_USER_DATA_DIR ?? detectChromeUserDataDir();
+    if (!dir) {
+        throw new Error('Could not detect Chrome user-data directory.\n' +
+            'Set FTX_CHROME_USER_DATA_DIR in .env or pass --chrome-user-data-dir.');
+    }
+    return {
+        chromeUserDataDir: dir,
+        chromeProfileDirectory: process.env.FTX_CHROME_PROFILE_DIRECTORY ?? process.env.FT_CHROME_PROFILE_DIRECTORY ?? 'Default',
+    };
+}
+export function loadXApiConfig() {
+    loadEnv();
+    const apiKey = process.env.X_API_KEY ?? process.env.X_CONSUMER_KEY;
+    const apiSecret = process.env.X_API_SECRET ?? process.env.X_SECRET_KEY;
+    const clientId = process.env.X_CLIENT_ID;
+    const clientSecret = process.env.X_CLIENT_SECRET;
+    const bearerToken = process.env.X_BEARER_TOKEN;
+    const callbackUrl = process.env.X_CALLBACK_URL ?? 'http://127.0.0.1:3000/callback';
+    if (!apiKey || !apiSecret || !clientId || !clientSecret) {
+        throw new Error('Missing X API credentials for API sync.\n' +
+            'Set X_API_KEY, X_API_SECRET, X_CLIENT_ID, and X_CLIENT_SECRET in .env.\n' +
+            'These are only needed for --api mode. Default sync uses your Chrome session.');
+    }
+    return { apiKey, apiSecret, clientId, clientSecret, bearerToken, callbackUrl };
+}

package/dist/db.js

@@ -0,0 +1,33 @@
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+const require = createRequire(import.meta.url);
+let sqlPromise;
+function getSql() {
+    if (!sqlPromise) {
+        const initSqlJs = require('sql.js-fts5');
+        const wasmPath = require.resolve('sql.js-fts5/dist/sql-wasm.wasm');
+        const wasmBinary = fs.readFileSync(wasmPath);
+        sqlPromise = initSqlJs({ wasmBinary });
+    }
+    return sqlPromise;
+}
+export async function openDb(filePath) {
+    const SQL = await getSql();
+    if (fs.existsSync(filePath)) {
+        const buf = fs.readFileSync(filePath);
+        return new SQL.Database(buf);
+    }
+    return new SQL.Database();
+}
+export async function createDb() {
+    const SQL = await getSql();
+    return new SQL.Database();
+}
+export function saveDb(db, filePath) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const data = db.export();
+    fs.writeFileSync(filePath, Buffer.from(data));
+}

package/dist/fs.js

@@ -0,0 +1,45 @@
+import { access, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+export async function ensureDir(dirPath) {
+    await mkdir(dirPath, { recursive: true });
+}
+export async function pathExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function listFiles(dirPath) {
+    try {
+        return await readdir(dirPath);
+    }
+    catch {
+        return [];
+    }
+}
+export async function writeJson(filePath, value) {
+    await writeFile(filePath, JSON.stringify(value, null, 2), 'utf8');
+}
+export async function readJson(filePath) {
+    const raw = await readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+}
+export async function writeJsonLines(filePath, rows) {
+    const content = rows.map((row) => JSON.stringify(row)).join('\n') + (rows.length ? '\n' : '');
+    await writeFile(filePath, content, 'utf8');
+}
+export async function readJsonLines(filePath) {
+    try {
+        const raw = await readFile(filePath, 'utf8');
+        return raw
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/graphql-bookmarks.js

@@ -0,0 +1,398 @@
+import { readJsonLines, writeJsonLines, readJson, writeJson, pathExists } from './fs.js';
+import { ensureDataDir, twitterBookmarksCachePath, twitterBackfillStatePath } from './paths.js';
+import { loadChromeSessionConfig } from './config.js';
+import { extractChromeXCookies } from './chrome-cookies.js';
+import { exportBookmarksForSyncSeed } from './bookmarks-db.js';
+const X_PUBLIC_BEARER = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+const BOOKMARKS_QUERY_ID = 'Z9GWmP0kP2dajyckAaDUBw';
+const BOOKMARKS_OPERATION = 'Bookmarks';
+const GRAPHQL_FEATURES = {
+    graphql_timeline_v2_bookmark_timeline: true,
+    rweb_tipjar_consumption_enabled: true,
+    responsive_web_graphql_exclude_directive_enabled: true,
+    verified_phone_label_enabled: false,
+    creator_subscriptions_tweet_preview_api_enabled: true,
+    responsive_web_graphql_timeline_navigation_enabled: true,
+    responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+    communities_web_enable_tweet_community_results_fetch: true,
+    c9s_tweet_anatomy_moderator_badge_enabled: true,
+    articles_preview_enabled: true,
+    responsive_web_edit_tweet_api_enabled: true,
+    tweetypie_unmention_optimization_enabled: true,
+    responsive_web_uc_gql_enabled: true,
+    vibe_api_enabled: true,
+    responsive_web_text_conversations_enabled: false,
+    freedom_of_speech_not_reach_fetch_enabled: true,
+    longform_notetweets_rich_text_read_enabled: true,
+    longform_notetweets_inline_media_enabled: true,
+    responsive_web_enhance_cards_enabled: false,
+    tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
+    responsive_web_media_download_video_enabled: false,
+};
+function parseSnowflake(value) {
+    if (!value || !/^\d+$/.test(value))
+        return null;
+    try {
+        return BigInt(value);
+    }
+    catch {
+        return null;
+    }
+}
+function parseBookmarkTimestamp(record) {
+    const candidates = [record.bookmarkedAt, record.postedAt, record.syncedAt];
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        const parsed = Date.parse(candidate);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return null;
+}
+function compareBookmarkChronology(a, b) {
+    const aTimestamp = parseBookmarkTimestamp(a);
+    const bTimestamp = parseBookmarkTimestamp(b);
+    if (aTimestamp != null && bTimestamp != null && aTimestamp !== bTimestamp) {
+        return aTimestamp > bTimestamp ? 1 : -1;
+    }
+    const aId = parseSnowflake(a.tweetId ?? a.id);
+    const bId = parseSnowflake(b.tweetId ?? b.id);
+    if (aId != null && bId != null && aId !== bId) {
+        return aId > bId ? 1 : -1;
+    }
+    const aStamp = String(a.bookmarkedAt ?? a.postedAt ?? a.syncedAt ?? '');
+    const bStamp = String(b.bookmarkedAt ?? b.postedAt ?? b.syncedAt ?? '');
+    return aStamp.localeCompare(bStamp);
+}
+async function loadExistingBookmarks() {
+    const cachePath = twitterBookmarksCachePath();
+    const existing = await readJsonLines(cachePath);
+    if (existing.length > 0)
+        return existing;
+    // On first run, no JSONL and no DB — return empty
+    try {
+        return await exportBookmarksForSyncSeed();
+    }
+    catch {
+        return [];
+    }
+}
+function buildUrl(cursor) {
+    const variables = { count: 20 };
+    if (cursor)
+        variables.cursor = cursor;
+    const params = new URLSearchParams({
+        variables: JSON.stringify(variables),
+        features: JSON.stringify(GRAPHQL_FEATURES),
+    });
+    return `https://x.com/i/api/graphql/${BOOKMARKS_QUERY_ID}/${BOOKMARKS_OPERATION}?${params}`;
+}
+function buildHeaders(csrfToken, cookieHeader) {
+    const userAgent = process.platform === 'win32'
+        ? 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36'
+        : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36';
+    return {
+        authorization: `Bearer ${X_PUBLIC_BEARER}`,
+        'x-csrf-token': csrfToken,
+        'x-twitter-auth-type': 'OAuth2Session',
+        'x-twitter-active-user': 'yes',
+        'content-type': 'application/json',
+        'user-agent': userAgent,
+        cookie: cookieHeader ?? `ct0=${csrfToken}`,
+    };
+}
+export function convertTweetToRecord(tweetResult, now) {
+    const tweet = tweetResult.tweet ?? tweetResult;
+    const legacy = tweet?.legacy;
+    if (!legacy)
+        return null;
+    const tweetId = legacy.id_str ?? tweet?.rest_id;
+    if (!tweetId)
+        return null;
+    const userResult = tweet?.core?.user_results?.result;
+    const authorHandle = userResult?.core?.screen_name ?? userResult?.legacy?.screen_name;
+    const authorName = userResult?.core?.name ?? userResult?.legacy?.name;
+    const authorProfileImageUrl = userResult?.avatar?.image_url ??
+        userResult?.legacy?.profile_image_url_https ??
+        userResult?.legacy?.profile_image_url;
+    const author = userResult
+        ? {
+            id: userResult.rest_id,
+            handle: authorHandle,
+            name: authorName,
+            profileImageUrl: authorProfileImageUrl,
+            bio: userResult?.legacy?.description,
+            followerCount: userResult?.legacy?.followers_count,
+            followingCount: userResult?.legacy?.friends_count,
+            isVerified: Boolean(userResult?.is_blue_verified ?? userResult?.legacy?.verified),
+            location: typeof userResult?.location === 'object'
+                ? userResult.location.location
+                : userResult?.legacy?.location,
+            snapshotAt: now,
+        }
+        : undefined;
+    const mediaEntities = legacy?.extended_entities?.media ?? legacy?.entities?.media ?? [];
+    const media = mediaEntities
+        .map((m) => m.media_url_https ?? m.media_url)
+        .filter(Boolean);
+    const mediaObjects = mediaEntities.map((m) => ({
+        type: m.type,
+        url: m.media_url_https ?? m.media_url,
+        expandedUrl: m.expanded_url,
+        width: m.original_info?.width,
+        height: m.original_info?.height,
+        altText: m.ext_alt_text,
+        videoVariants: Array.isArray(m.video_info?.variants)
+            ? m.video_info.variants
+                .filter((v) => v.content_type === 'video/mp4')
+                .map((v) => ({ bitrate: v.bitrate, url: v.url }))
+            : undefined,
+    }));
+    const urlEntities = legacy?.entities?.urls ?? [];
+    const links = urlEntities
+        .map((u) => u.expanded_url)
+        .filter((u) => u && !u.includes('t.co'));
+    return {
+        id: tweetId,
+        tweetId,
+        url: `https://x.com/${authorHandle ?? '_'}/status/${tweetId}`,
+        text: legacy.full_text ?? legacy.text ?? '',
+        authorHandle,
+        authorName,
+        authorProfileImageUrl,
+        author,
+        postedAt: legacy.created_at ?? null,
+        bookmarkedAt: null,
+        syncedAt: now,
+        conversationId: legacy.conversation_id_str,
+        inReplyToStatusId: legacy.in_reply_to_status_id_str,
+        inReplyToUserId: legacy.in_reply_to_user_id_str,
+        quotedStatusId: legacy.quoted_status_id_str,
+        language: legacy.lang,
+        sourceApp: legacy.source,
+        possiblySensitive: legacy.possibly_sensitive,
+        engagement: {
+            likeCount: legacy.favorite_count,
+            repostCount: legacy.retweet_count,
+            replyCount: legacy.reply_count,
+            quoteCount: legacy.quote_count,
+            bookmarkCount: legacy.bookmark_count,
+            viewCount: tweet?.views?.count ? Number(tweet.views.count) : undefined,
+        },
+        media,
+        mediaObjects,
+        links,
+        tags: [],
+        ingestedVia: 'graphql',
+    };
+}
+export function parseBookmarksResponse(json, now) {
+    const ts = now ?? new Date().toISOString();
+    const instructions = json?.data?.bookmark_timeline_v2?.timeline?.instructions ?? [];
+    const entries = [];
+    for (const inst of instructions) {
+        if (inst.type === 'TimelineAddEntries' && Array.isArray(inst.entries)) {
+            entries.push(...inst.entries);
+        }
+    }
+    const records = [];
+    let nextCursor;
+    for (const entry of entries) {
+        if (entry.entryId?.startsWith('cursor-bottom')) {
+            nextCursor = entry.content?.value;
+            continue;
+        }
+        const tweetResult = entry?.content?.itemContent?.tweet_results?.result;
+        if (!tweetResult)
+            continue;
+        const record = convertTweetToRecord(tweetResult, ts);
+        if (record)
+            records.push(record);
+    }
+    return { records, nextCursor };
+}
+async function fetchPageWithRetry(csrfToken, cursor, cookieHeader) {
+    let lastError;
+    for (let attempt = 0; attempt < 4; attempt++) {
+        const response = await fetch(buildUrl(cursor), { headers: buildHeaders(csrfToken, cookieHeader) });
+        if (response.status === 429) {
+            const waitSec = Math.min(15 * Math.pow(2, attempt), 120);
+            lastError = new Error(`Rate limited (429) on attempt ${attempt + 1}`);
+            await new Promise((r) => setTimeout(r, waitSec * 1000));
+            continue;
+        }
+        if (response.status >= 500) {
+            lastError = new Error(`Server error (${response.status}) on attempt ${attempt + 1}`);
+            await new Promise((r) => setTimeout(r, 5000 * (attempt + 1)));
+            continue;
+        }
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`GraphQL Bookmarks API returned ${response.status}.\n` +
+                `Response: ${text.slice(0, 300)}\n\n` +
+                (response.status === 401 || response.status === 403
+                    ? 'Fix: Your X session may have expired. Open Chrome, go to https://x.com, and make sure you are logged in. Then retry.'
+                    : 'This may be a temporary issue. Try again in a few minutes.'));
+        }
+        const json = await response.json();
+        return parseBookmarksResponse(json);
+    }
+    throw lastError ?? new Error('GraphQL Bookmarks API: all retry attempts failed. Try again later.');
+}
+export function scoreRecord(record) {
+    let score = 0;
+    if (record.postedAt)
+        score += 2;
+    if (record.authorProfileImageUrl)
+        score += 2;
+    if (record.author)
+        score += 3;
+    if (record.engagement)
+        score += 3;
+    if ((record.mediaObjects?.length ?? 0) > 0)
+        score += 3;
+    if ((record.links?.length ?? 0) > 0)
+        score += 2;
+    return score;
+}
+export function mergeBookmarkRecord(existing, incoming) {
+    if (!existing)
+        return incoming;
+    return scoreRecord(incoming) >= scoreRecord(existing)
+        ? { ...existing, ...incoming }
+        : { ...incoming, ...existing };
+}
+export function mergeRecords(existing, incoming) {
+    const byId = new Map(existing.map((r) => [r.id, r]));
+    let added = 0;
+    for (const record of incoming) {
+        const prev = byId.get(record.id);
+        if (!prev)
+            added += 1;
+        byId.set(record.id, mergeBookmarkRecord(prev, record));
+    }
+    const merged = Array.from(byId.values());
+    merged.sort((a, b) => compareBookmarkChronology(b, a));
+    return { merged, added };
+}
+function updateState(prev, input) {
+    return {
+        provider: 'twitter',
+        lastRunAt: new Date().toISOString(),
+        totalRuns: prev.totalRuns + 1,
+        totalAdded: prev.totalAdded + input.added,
+        lastAdded: input.added,
+        lastSeenIds: input.seenIds.slice(-20),
+        stopReason: input.stopReason,
+    };
+}
+export function formatSyncResult(result) {
+    return [
+        'Sync complete.',
+        `- bookmarks added: ${result.added}`,
+        `- total bookmarks: ${result.totalBookmarks}`,
+        `- pages fetched: ${result.pages}`,
+        `- stop reason: ${result.stopReason}`,
+        `- cache: ${result.cachePath}`,
+        `- state: ${result.statePath}`,
+    ].join('\n');
+}
+export async function syncBookmarksGraphQL(options = {}) {
+    const incremental = options.incremental ?? true;
+    const maxPages = options.maxPages ?? 500;
+    const delayMs = options.delayMs ?? 600;
+    const maxMinutes = options.maxMinutes ?? 30;
+    const stalePageLimit = options.stalePageLimit ?? 3;
+    const checkpointEvery = options.checkpointEvery ?? 25;
+    let csrfToken;
+    let cookieHeader;
+    if (options.csrfToken) {
+        csrfToken = options.csrfToken;
+        cookieHeader = options.cookieHeader;
+    }
+    else {
+        const chromeConfig = loadChromeSessionConfig();
+        const chromeDir = options.chromeUserDataDir ?? chromeConfig.chromeUserDataDir;
+        const chromeProfile = options.chromeProfileDirectory ?? chromeConfig.chromeProfileDirectory;
+        const cookies = await extractChromeXCookies(chromeDir, chromeProfile);
+        csrfToken = cookies.csrfToken;
+        cookieHeader = cookies.cookieHeader;
+    }
+    ensureDataDir();
+    const cachePath = twitterBookmarksCachePath();
+    const statePath = twitterBackfillStatePath();
+    let existing = await loadExistingBookmarks();
+    const newestKnownId = incremental
+        ? existing.slice().sort((a, b) => compareBookmarkChronology(b, a))[0]?.id
+        : undefined;
+    const prevState = (await pathExists(statePath))
+        ? await readJson(statePath)
+        : { provider: 'twitter', totalRuns: 0, totalAdded: 0, lastAdded: 0, lastSeenIds: [] };
+    const started = Date.now();
+    let page = 0;
+    let totalAdded = 0;
+    let stalePages = 0;
+    let cursor;
+    const allSeenIds = [];
+    let stopReason = 'unknown';
+    while (page < maxPages) {
+        if (Date.now() - started > maxMinutes * 60_000) {
+            stopReason = 'max runtime reached';
+            break;
+        }
+        const result = await fetchPageWithRetry(csrfToken, cursor, cookieHeader);
+        page += 1;
+        if (result.records.length === 0 && !result.nextCursor) {
+            stopReason = 'end of bookmarks';
+            break;
+        }
+        const { merged, added } = mergeRecords(existing, result.records);
+        existing = merged;
+        totalAdded += added;
+        result.records.forEach((r) => allSeenIds.push(r.id));
+        const reachedLatestStored = Boolean(newestKnownId) && result.records.some((record) => record.id === newestKnownId);
+        stalePages = added === 0 ? stalePages + 1 : 0;
+        options.onProgress?.({
+            page,
+            totalFetched: allSeenIds.length,
+            newAdded: totalAdded,
+            running: true,
+            done: false,
+        });
+        if (options.targetAdds && totalAdded >= options.targetAdds) {
+            stopReason = 'target additions reached';
+            break;
+        }
+        if (incremental && reachedLatestStored) {
+            stopReason = 'caught up to newest stored bookmark';
+            break;
+        }
+        if (incremental && stalePages >= stalePageLimit) {
+            stopReason = 'no new bookmarks (stale)';
+            break;
+        }
+        if (!result.nextCursor) {
+            stopReason = 'end of bookmarks';
+            break;
+        }
+        if (page % checkpointEvery === 0)
+            await writeJsonLines(cachePath, existing);
+        cursor = result.nextCursor;
+        if (page < maxPages)
+            await new Promise((r) => setTimeout(r, delayMs));
+    }
+    if (stopReason === 'unknown')
+        stopReason = page >= maxPages ? 'max pages reached' : 'unknown';
+    await writeJsonLines(cachePath, existing);
+    await writeJson(statePath, updateState(prevState, { added: totalAdded, seenIds: allSeenIds.slice(-20), stopReason }));
+    options.onProgress?.({
+        page,
+        totalFetched: allSeenIds.length,
+        newAdded: totalAdded,
+        running: false,
+        done: true,
+        stopReason,
+    });
+    return { added: totalAdded, totalBookmarks: existing.length, pages: page, stopReason, cachePath, statePath };
+}

package/dist/paths.js

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+export function dataDir() {
+    const override = process.env.FTX_DATA_DIR ?? process.env.FT_DATA_DIR;
+    if (override)
+        return override;
+    return path.join(os.homedir(), '.ftx-bookmarks');
+}
+function ensureDirSync(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+export function ensureDataDir() {
+    const dir = dataDir();
+    ensureDirSync(dir);
+    return dir;
+}
+export function twitterBookmarksCachePath() {
+    return path.join(dataDir(), 'bookmarks.jsonl');
+}
+export function twitterBookmarksMetaPath() {
+    return path.join(dataDir(), 'bookmarks-meta.json');
+}
+export function twitterOauthTokenPath() {
+    return path.join(dataDir(), 'oauth-token.json');
+}
+export function twitterBackfillStatePath() {
+    return path.join(dataDir(), 'bookmarks-backfill-state.json');
+}
+export function bookmarkMediaDir() {
+    return path.join(dataDir(), 'media');
+}
+export function bookmarkMediaManifestPath() {
+    return path.join(dataDir(), 'media-manifest.json');
+}
+export function twitterBookmarksIndexPath() {
+    return path.join(dataDir(), 'bookmarks.db');
+}
+export function isFirstRun() {
+    return !fs.existsSync(twitterBookmarksCachePath());
+}

package/dist/types.js

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