fieldtheory 1.0.0

package/dist/graphql-bookmarks.js

@@ -0,0 +1,388 @@
+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;
+    return exportBookmarksForSyncSeed();
+}
+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) {
+    return {
+        authorization: `Bearer ${X_PUBLIC_BEARER}`,
+        'x-csrf-token': csrfToken,
+        'x-twitter-auth-type': 'OAuth2Session',
+        'x-twitter-active-user': 'yes',
+        'content-type': 'application/json',
+        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 = 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.FT_DATA_DIR;
+    if (override)
+        return override;
+    return path.join(os.homedir(), '.ft-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 {};

package/dist/xauth.js

@@ -0,0 +1,135 @@
+import crypto from 'node:crypto';
+import http from 'node:http';
+import { URL } from 'node:url';
+import { pathExists, readJson, writeJson } from './fs.js';
+import { ensureDataDir, twitterOauthTokenPath } from './paths.js';
+import { loadXApiConfig } from './config.js';
+function base64Url(input) {
+    return input.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+function createPkce() {
+    const verifier = base64Url(crypto.randomBytes(32));
+    const challenge = base64Url(crypto.createHash('sha256').update(verifier).digest());
+    const state = base64Url(crypto.randomBytes(16));
+    return { verifier, challenge, state };
+}
+export function buildTwitterOAuthUrl() {
+    const cfg = loadXApiConfig();
+    if (!cfg.callbackUrl) {
+        throw new Error('Missing X_CALLBACK_URL in .env.local');
+    }
+    const { verifier, challenge, state } = createPkce();
+    const url = new URL('https://twitter.com/i/oauth2/authorize');
+    url.searchParams.set('response_type', 'code');
+    url.searchParams.set('client_id', cfg.clientId);
+    url.searchParams.set('redirect_uri', cfg.callbackUrl);
+    url.searchParams.set('scope', 'tweet.read users.read bookmark.read offline.access');
+    url.searchParams.set('state', state);
+    url.searchParams.set('code_challenge', challenge);
+    url.searchParams.set('code_challenge_method', 'S256');
+    return { url: url.toString(), state, verifier };
+}
+async function exchangeCodeForToken(code, verifier) {
+    const cfg = loadXApiConfig();
+    if (!cfg.callbackUrl) {
+        throw new Error('Missing X_CALLBACK_URL in .env.local');
+    }
+    const basic = Buffer.from(`${cfg.clientId}:${cfg.clientSecret}`).toString('base64');
+    const body = new URLSearchParams({
+        grant_type: 'authorization_code',
+        code,
+        redirect_uri: cfg.callbackUrl,
+        code_verifier: verifier,
+        client_id: cfg.clientId,
+    });
+    const response = await fetch('https://api.x.com/2/oauth2/token', {
+        method: 'POST',
+        headers: {
+            Authorization: `Basic ${basic}`,
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body,
+    });
+    const text = await response.text();
+    const parsed = JSON.parse(text);
+    if (!response.ok) {
+        throw new Error(`Token exchange failed (${response.status}): ${text}`);
+    }
+    return {
+        access_token: parsed.access_token,
+        refresh_token: parsed.refresh_token,
+        expires_in: parsed.expires_in,
+        scope: parsed.scope,
+        token_type: parsed.token_type,
+        obtained_at: new Date().toISOString(),
+    };
+}
+export async function saveTwitterOAuthToken(token) {
+    ensureDataDir();
+    const tokenPath = twitterOauthTokenPath();
+    await writeJson(tokenPath, token);
+    // Restrict permissions — OAuth tokens should only be readable by the owner
+    const { chmod } = await import('node:fs/promises');
+    await chmod(tokenPath, 0o600);
+    return tokenPath;
+}
+export async function loadTwitterOAuthToken() {
+    const tokenPath = twitterOauthTokenPath();
+    if (!(await pathExists(tokenPath)))
+        return null;
+    return readJson(tokenPath);
+}
+export async function runTwitterOAuthFlow() {
+    const cfg = loadXApiConfig();
+    if (!cfg.callbackUrl) {
+        throw new Error('Missing X_CALLBACK_URL in .env.local');
+    }
+    const { url, state, verifier } = buildTwitterOAuthUrl();
+    const callback = new URL(cfg.callbackUrl);
+    const port = Number(callback.port || 80);
+    const pathname = callback.pathname;
+    const code = await new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            try {
+                const reqUrl = new URL(req.url ?? '/', `http://127.0.0.1:${port}`);
+                if (reqUrl.pathname !== pathname) {
+                    res.statusCode = 404;
+                    res.end('Not found');
+                    return;
+                }
+                const returnedState = reqUrl.searchParams.get('state');
+                const returnedCode = reqUrl.searchParams.get('code');
+                const error = reqUrl.searchParams.get('error');
+                if (error) {
+                    res.statusCode = 400;
+                    res.end(`OAuth error: ${error}`);
+                    server.close();
+                    reject(new Error(`OAuth error: ${error}`));
+                    return;
+                }
+                if (!returnedCode || returnedState !== state) {
+                    res.statusCode = 400;
+                    res.end('Invalid OAuth callback');
+                    server.close();
+                    reject(new Error('Invalid OAuth callback state/code'));
+                    return;
+                }
+                res.statusCode = 200;
+                res.end('ft auth complete. You can close this tab.');
+                server.close();
+                resolve(returnedCode);
+            }
+            catch (err) {
+                server.close();
+                reject(err);
+            }
+        });
+        server.listen(port, '127.0.0.1', () => {
+            console.log('Open this URL in your browser to authorize X bookmarks access:');
+            console.log(url);
+        });
+    });
+    const token = await exchangeCodeForToken(code, verifier);
+    const tokenPath = await saveTwitterOAuthToken(token);
+    return { tokenPath, scope: token.scope };
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "fieldtheory",
+  "version": "1.0.0",
+  "description": "Field Theory CLI. Self-custody for your X/Twitter bookmarks. Local sync, full-text search, classification, and terminal dashboards.",
+  "type": "module",
+  "bin": {
+    "ft": "bin/ft.mjs"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "tsx --test tests/**/*.test.ts",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/afar1/fieldtheory-cli.git"
+  },
+  "keywords": [
+    "bookmarks",
+    "twitter",
+    "x",
+    "search",
+    "fts5",
+    "sqlite",
+    "local-first",
+    "self-custody",
+    "cli"
+  ],
+  "dependencies": {
+    "commander": "^14.0.3",
+    "dotenv": "^17.3.1",
+    "sql.js": "^1.14.1",
+    "sql.js-fts5": "^1.4.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@types/sql.js": "^1.4.11",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2"
+  }
+}