command line args support

app.ts

···
 import { AppBskyVideoDefs, AtpAgent, BlobRef, RichText } from '@atproto/api';
 
 import {
-    getEmbeddedUrlAndRecord, getMergeEmbed, getReplyRefs, PAST_HANDLES
+    getEmbeddedUrlAndRecord, getMergeEmbed, getReplyRefs
 } from './libs/bskyParams';
 import { checkPastHandles, convertToBskyPostUrl, getBskyPostUrl } from './libs/urlHandler';
 let fetch: any;
···
 const oembetter = require('oembetter')();
 oembetter.endpoints(oembetter.suggestedEndpoints);
 
-dotenv.config();
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
 
-const agent = new AtpAgent({
-    service: 'https://bsky.social',
-})
 
-const SIMULATE = process.env.SIMULATE === "1";
-const API_DELAY = 2500; // https://docs.bsky.app/docs/advanced-guides/rate-limits
 const TWEETS_MAPPING_FILE_NAME = 'tweets_mapping.json'; // store the imported tweets & bsky id mapping
-const DISABLE_IMPORT_REPLY = process.env.DISABLE_IMPORT_REPLY === "1";
 const MAX_FILE_SIZE = 1 * 1000 * 1000; // 1MiB
-
+const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3';
 
-let MIN_DATE: Date | undefined = undefined;
-if (process.env.MIN_DATE != null && process.env.MIN_DATE.length > 0)
-    MIN_DATE = new Date(process.env.MIN_DATE as string);
+dotenv.config();
 
-let MAX_DATE: Date | undefined = undefined;
-if (process.env.MAX_DATE != null && process.env.MAX_DATE.length > 0)
-    MAX_DATE = new Date(process.env.MAX_DATE as string);
+const agent = new AtpAgent({
+    service: 'https://bsky.social',
+})
 
 let alreadySavedCache = false;
-const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3';
 
 class RateLimitedAgent {
     private agent: AtpAgent;
···
 }
 
 async function cleanTweetText(
-  tweetFullText: string, 
-  urlMappings: Array<{
-    url: string;
-    expanded_url: string
-  }>, 
-  embeddedUrl: string|null,
-  tweets
+    twitterHandles: string[],
+    blueskyUsername: string,
+    tweetFullText: string, 
+    urlMappings: Array<{
+        url: string;
+        expanded_url: string
+    }>, 
+    embeddedUrl: string|null,
+    tweets
 ): Promise<string> {
     let newText = tweetFullText;
     const urls: string[] = [];
···
                 return urls[index];
             });
 
-            if (   checkPastHandles(newUrl) 
+            if (   checkPastHandles(twitterHandles, newUrl) 
                 && newUrl.indexOf("/photo/") == -1 
                 && newUrl.indexOf("/video/") == -1 
                 && embeddedUrl != newUrl) {
               // self quote exchange ( tweet-> bsky)
-              newUrls.push(convertToBskyPostUrl(newUrl, tweets))
+              newUrls.push(convertToBskyPostUrl(blueskyUsername, newUrl, tweets))
             }else{
               newUrls.push(newUrl)
             }
···
             newText = URI.withinString(tweetFullText, (url, start, end, source) => {
                 // I exclude links to photos, because they have already been inserted into the Bluesky post independently
                 // also exclude embeddedUrl (ex. your twitter quote post)
-                if ( (checkPastHandles(newUrls[j]) && (newUrls[j].indexOf("/photo/") > 0 || newUrls[j].indexOf("/video/") > 0) )
+                if ( (checkPastHandles(twitterHandles, newUrls[j]) && (newUrls[j].indexOf("/photo/") > 0 || newUrls[j].indexOf("/video/") > 0) )
                   || embeddedUrl == newUrls[j]
                 ) {
                     j++;
···
         .replace(/;$/, "");
 }
 
-function getTweets(){
+function getTweets(archiveFolder: string){
     // get cache (from last time imported)
     let caches = []
     if(FS.existsSync(TWEETS_MAPPING_FILE_NAME)){
···
     }
 
     // get original tweets
-    const fTweets = FS.readFileSync(process.env.ARCHIVE_FOLDER + "/data/tweets.js");
+    const fTweets = FS.readFileSync(path.join(archiveFolder, 'data', 'tweets.js'));
     let tweets = JSON.parse(cleanTweetFileContent(fTweets));
 
     let archiveExists = true;
     for (let i=1; archiveExists; i++) {
-        let archiveFile = `${process.env.ARCHIVE_FOLDER}/data/tweets-part${i}.js`;
+        let archiveFile = path.join(archiveFolder, 'data', `tweets-part${i}.js`);
         archiveExists = FS.existsSync(archiveFile)
         if( archiveExists ) {
             let fTweetsPart = FS.readFileSync(archiveFile);
···
 }
 
 async function main() {
+
+    const argv = yargs(hideBin(process.argv))
+        .option('simulate', {
+            type: 'boolean',
+            description: 'Simulate the import without making any changes (defaults to false)',
+            default: process.env.SIMULATE === '1',
+        })
+        .option('disable-import-reply', {
+            type: 'boolean',
+            description: 'Disable importing replies',
+            default: process.env.DISABLE_IMPORT_REPLY === '1',
+        })
+        .option('min-date', {
+            type: 'string',
+            description: 'Minimum date for tweets to import (YYYY-MM-DD)',
+            default: process.env.MIN_DATE,
+        })
+        .option('max-date', {
+            type: 'string',
+            description: 'Maximum date for tweets to import (YYYY-MM-DD)',
+            default: process.env.MAX_DATE,
+        })
+        .option('api-delay', {
+            type: 'number',
+            description: 'Delay between API calls in milliseconds',
+            default: process.env.API_DELAY ? parseInt(process.env.API_DELAY) : 2500,
+        })
+        .option('archive-folder', {
+            type: 'string',
+            description: 'Path to the archive folder',
+            default: process.env.ARCHIVE_FOLDER,
+            demandOption: true,
+        })
+        .option('bluesky-username', {
+            type: 'string',
+            description: 'Bluesky username',
+            default: process.env.BLUESKY_USERNAME,
+            demandOption: true,
+        })
+        .option('bluesky-password', {
+            type: 'string',
+            description: 'Bluesky password',
+            default: process.env.BLUESKY_PASSWORD,
+            demandOption: true,
+        })
+        .option('twitter-handles', {
+            type: 'array',
+            description: 'Twitter handles to import',
+            default: process.env.PAST_HANDLES?.split(','),
+            demandOption: true,
+        })
+        .help()
+        .argv;
+
+    let minDate = argv.minDate ? new Date(argv.minDate) : undefined;
+    let maxDate = argv.maxDate ? new Date(argv.maxDate) : undefined;
+
     console.log(`Import started at ${new Date().toISOString()}`)
-    console.log(`SIMULATE is ${SIMULATE ? "ON" : "OFF"}`);
-    console.log(`IMPORT REPLY is ${!DISABLE_IMPORT_REPLY ? "ON" : "OFF"}`);
+    console.log(`Simulate is ${argv.simulate ? "ON" : "OFF"}`);
+    console.log(`Import Reply is ${!argv.disableImportReply ? "ON" : "OFF"}`);
+    console.log(`Min Date is ${minDate ? minDate.toISOString() : "OFF"}`);
+    console.log(`Max Date is ${maxDate ? maxDate.toISOString() : "OFF"}`);
+    console.log(`API Delay is ${argv.apiDelay}ms`);
+    console.log(`Archive Folder is ${argv.archiveFolder}`);
+    console.log(`Bluesky Username is ${argv.blueskyUsername}`);
 
-    const tweets = getTweets();
+    const tweets = getTweets(argv.archiveFolder);
   
     let importedTweet = 0;
     if (tweets != null && tweets.length > 0) {
···
             return ad - bd;
         });
 
-        await rateLimitedAgent.login({ identifier: process.env.BLUESKY_USERNAME!, password: process.env.BLUESKY_PASSWORD! });
+        await rateLimitedAgent.login({ identifier: argv.blueskyUsername, password: argv.blueskyPassword });
        
         process.on('exit', () => saveCache(sortedTweets));
         process.on('SIGINT', () => process.exit());
···
                 const tweet_createdAt = tweetDate.toISOString();
 
                 //this cheks assume that the array is sorted by date (first the oldest)
-                if (MIN_DATE != undefined && tweetDate < MIN_DATE)
+                if (minDate != undefined && tweetDate < minDate)
                     continue;
-                if (MAX_DATE != undefined && tweetDate > MAX_DATE)
+                if (maxDate != undefined && tweetDate > maxDate)
                     break;
                 
                 if(bsky){
···
                 console.log(` Created at ${tweet_createdAt}`);
                 console.log(` Full text '${tweet.full_text}'`);
 
-                if (DISABLE_IMPORT_REPLY && tweet.in_reply_to_screen_name) {
+                if (argv.disableImportReply && tweet.in_reply_to_screen_name) {
                     console.log("Discarded (reply)");
                     continue;
                 }
 
                 if (tweet.in_reply_to_screen_name) {
-                    if (PAST_HANDLES.some(handle => tweet.in_reply_to_screen_name == handle)) {
+                    if (argv.twitterHandles.some(handle => tweet.in_reply_to_screen_name == handle)) {
                         // Remove "@screen_name" from the beginning of the tweet's full text
                         const replyPrefix = `@${tweet.in_reply_to_screen_name} `;
                         if (tweet.full_text.startsWith(replyPrefix)) {
···
                                 break;
                             }
 
-                            let mediaFilename = `${process.env.ARCHIVE_FOLDER}${path.sep}data${path.sep}tweets_media${path.sep}${tweet.id}-${media?.media_url.substring(i + 1)}`;
+                            let mediaFilename = `${argv.archiveFolder}${path.sep}data${path.sep}tweets_media${path.sep}${tweet.id}-${media?.media_url.substring(i + 1)}`;
 
                             let localMediaFileNotFound = true;
                             if (FS.existsSync(mediaFilename)) {
···
                             }
 
                             if (localMediaFileNotFound) {
-                                const wildcardPath = `${process.env.ARCHIVE_FOLDER}${path.sep}data${path.sep}tweets_media${path.sep}${tweet.id}-*`;
+                                const wildcardPath = `${argv.archiveFolder}${path.sep}data${path.sep}tweets_media${path.sep}${tweet.id}-*`;
                                 const files = FS.readdirSync(path.dirname(wildcardPath)).filter(file => file.startsWith(`${tweet.id}-`));
 
                                 if (files.length > 0) {
···
                                 mimeType = 'image/jpeg';
                             }
 
-                            if (!SIMULATE) {
+                            if (!argv.simulate) {
                                 const blobRecord = await rateLimitedAgent.uploadBlob(imageBuffer, {
                                     encoding: mimeType
                                 });
···
                                 tweet.full_text = tweet.full_text.replace(media?.url, '').replace(/\s\s+/g, ' ').trim();
                             }
 
-                            const baseVideoPath = `${process.env.ARCHIVE_FOLDER}/data/tweets_media/${tweet.id}-`;
+                            const baseVideoPath = `${argv.archiveFolder}/data/tweets_media/${tweet.id}-`;
                             let videoFileName = '';
                             let videoFilePath = '';
                             let localVideoFileNotFound = true;
···
                                 continue
                             }
     
-                            if (!SIMULATE) {
+                            if (!argv.simulate) {
                                 const { data: serviceAuth } = await rateLimitedAgent.getServiceAuth(
                                     {
                                       aud: `did:web:${rateLimitedAgent.dispatchUrl.host}`,
···
                 }
 
                 // handle bsky embed record
-                const { embeddedUrl = null, embeddedRecord = null } = getEmbeddedUrlAndRecord(tweet.entities?.urls, sortedTweets);
+                const { embeddedUrl = null, embeddedRecord = null } = getEmbeddedUrlAndRecord(argv.twitterHandles, tweet.entities?.urls, sortedTweets);
 
                 let replyTo: {}|null = null; 
-                if ( !DISABLE_IMPORT_REPLY && !SIMULATE && tweet.in_reply_to_screen_name) {
-                    replyTo = getReplyRefs(tweet,sortedTweets);
+                if ( !argv.disableImportReply && !argv.simulate && tweet.in_reply_to_screen_name) {
+                    replyTo = getReplyRefs(argv.twitterHandles, tweet, sortedTweets);
                 }
 
                 let postText = tweet.full_text as string;
-                if (!SIMULATE) {
-                    postText = await cleanTweetText(tweet.full_text, tweet.entities?.urls, embeddedUrl, sortedTweets);
+                if (!argv.simulate) {
+                    postText = await cleanTweetText(argv.twitterHandles, argv.blueskyUsername, tweet.full_text, tweet.entities?.urls, embeddedUrl, sortedTweets);
 
                     if (postText.length > 300)
                         postText = tweet.full_text;
···
 
                 console.log(postRecord);
 
-                if (!SIMULATE) {
+                if (!argv.simulate) {
                     //I wait 3 seconds so as not to exceed the api rate limits
-                    await new Promise(resolve => setTimeout(resolve, API_DELAY));
+                    await new Promise(resolve => setTimeout(resolve, argv.apiDelay));
 
                     try 
                     {
                         const recordData = await rateLimitedAgent.post(postRecord);
                         const i = recordData.uri.lastIndexOf("/");
                         if (i > 0) {
-                            const postUri = getBskyPostUrl(recordData.uri);
+                            const postUri = getBskyPostUrl(argv.blueskyUsername, recordData.uri);
                             console.log("Bluesky post create, URL: " + postUri);
 
                             importedTweet++;
···
         }
     }
 
-    if (SIMULATE) {
+    if (argv.simulate) {
         // In addition to the delay in AT Proto API calls, we will also consider a 5% delta for URL resolution calls
-        const minutes = Math.round((importedTweet * API_DELAY / 1000) / 60) + (1 / 0.1);
+        const minutes = Math.round((importedTweet * argv.apiDelay / 1000) / 60) + (1 / 0.1);
         const hours = Math.floor(minutes / 60);
         const min = minutes % 60;
         console.log(`Estimated time for real import: ${hours} hours and ${min} minutes`);

libs/bskyAPI.ts

···
-import * as dotenv from 'dotenv';
-import * as process from 'process';
 import FS from 'fs';
 
-dotenv.config();
-
 export const TWEETS_MAPPING_FILE_NAME = 'tweets_mapping.json'; // store the imported tweets & bsky id mapping
 
-
-let MIN_DATE: Date | undefined = undefined;
-if (process.env.MIN_DATE != null && process.env.MIN_DATE.length > 0)
-    MIN_DATE = new Date(process.env.MIN_DATE as string);
-
-let MAX_DATE: Date | undefined = undefined;
-if (process.env.MAX_DATE != null && process.env.MAX_DATE.length > 0)
-    MAX_DATE = new Date(process.env.MAX_DATE as string);
-
-
-
-export async function deleteBskyPosts(agent, tweets){
+export async function deleteBskyPosts(agent, tweets, minDate: Date, maxDate: Date){
 // Delete bsky posts with a record in TWEETS_MAPPING_FILE_NAME.
 // If something goes wrong, call this method to clear the previously imported posts.
 // You may also use MIN_DATE and MAX_DATE to limit the range.
···
               
                 const tweetDate = new Date(tweet.created_at);
       
-                if (MIN_DATE != undefined && tweetDate < MIN_DATE)
+                if (minDate != undefined && tweetDate < minDate)
                     continue;
-                if (MAX_DATE != undefined && tweetDate > MAX_DATE)
+                if (maxDate != undefined && tweetDate > maxDate)
                     continue;
                 
                 await agent.deletePost(bsky.uri);

libs/bskyParams.ts

···
-import * as dotenv from 'dotenv';
-import * as process from 'process';
-
 import { checkPastHandles } from './urlHandler';
 
-dotenv.config();
-
-export const PAST_HANDLES = process.env.PAST_HANDLES!.split(",");
-
-export function getReplyRefs({in_reply_to_screen_name, in_reply_to_status_id}, tweets):{
+export function getReplyRefs(
+    twitterHandles: string[],
+    {in_reply_to_screen_name, in_reply_to_status_id}, tweets):{
     "root": {
         "uri": string;
         "cid": string;
···
         "cid":string;
     },
 }|null{
-    const importReplyScreenNames = PAST_HANDLES || [];
+    const importReplyScreenNames = twitterHandles || [];
     if(importReplyScreenNames.every(handle => in_reply_to_screen_name != handle)){
         console.log(`Skip Reply (wrong reply screen name :${in_reply_to_screen_name})`, importReplyScreenNames);
         return null;
···
 
 
 export function getEmbeddedUrlAndRecord(
+    twitterHandles: string[],
     urls: Array<{expanded_url: string}>, 
     tweets: Array<{
         tweet: Record<string, string>,
···
 
     // get the last one url to embed
     const reversedUrls = urls.reverse(); 
-    embeddedTweetUrl = reversedUrls.find(({expanded_url})=> checkPastHandles(expanded_url))?.expanded_url ?? null;
+    embeddedTweetUrl = reversedUrls.find(({expanded_url})=> checkPastHandles(twitterHandles, expanded_url))?.expanded_url ?? null;
     
     if(!embeddedTweetUrl){
         return nullResult;

libs/urlHandler.ts

···
-import * as dotenv from 'dotenv';
-import * as process from 'process';
 
-dotenv.config();
-
-export const PAST_HANDLES = process.env.PAST_HANDLES!.split(",");
-
-export function checkPastHandles(url: string): boolean{
-    return (PAST_HANDLES || []).some(handle => 
+export function checkPastHandles(twitterHandles: string[], url: string): boolean{
+    return (twitterHandles || []).some(handle => 
         url.startsWith(`https://x.com/${handle}/`) || 
         url.startsWith(`https://twitter.com/${handle}/`)
     )
 }
 
 export function convertToBskyPostUrl(
+    blueskyUsername: string,
     tweetUrl:string , 
     tweets: Array<{
             tweet: Record<string, string>,
···
     if(!tweet?.bsky){
         return tweetUrl;
     }
-    return getBskyPostUrl(tweet.bsky.uri);
+    return getBskyPostUrl(blueskyUsername, tweet.bsky.uri);
 }
 
-export function getBskyPostUrl(bskyUri: string): string {
+export function getBskyPostUrl(blueskyUsername : string, bskyUri: string): string {
     const i = bskyUri.lastIndexOf("/");
     if(i == -1){
         return bskyUri;
     }
     const rkey = bskyUri.substring(i + 1);
-    return `https://bsky.app/profile/${process.env.BLUESKY_USERNAME!}/post/${rkey}`;
+    return `https://bsky.app/profile/${blueskyUsername!}/post/${rkey}`;
 }
 
 

package-lock.json

···
         "process": "^0.11.10",
         "sharp": "^0.33.5",
         "typescript": "^5.6.3",
-        "urijs": "^1.19.11"
+        "urijs": "^1.19.11",
+        "yargs": "17.7.2"
       },
       "devDependencies": {
         "@types/follow-redirects": "^1.14.4",
···
       "integrity": "sha512-XOfUup9r3Y06nFAZh3WvO0rBU4OtlfPB/vgxpjg+NRdGU6CN6djdc6OEiH+PcqHCY6eFLo9Ista73uarf4gnBg==",
       "dev": true
     },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
     "node_modules/async": {
       "version": "0.9.2",
       "resolved": "https://registry.npmjs.org/async/-/async-0.9.2.tgz",
···
       },
       "funding": {
         "url": "https://github.com/sponsors/fb55"
+      }
+    },
+    "node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
       }
     },
     "node_modules/color": {
···
         "url": "https://dotenvx.com"
       }
     },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
     "node_modules/encoding-sniffer": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/encoding-sniffer/-/encoding-sniffer-0.2.0.tgz",
···
       },
       "funding": {
         "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
       }
     },
     "node_modules/fast-xml-parser": {
···
         "node": ">=12.20.0"
       }
     },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
     "node_modules/graphemer": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
···
       "version": "0.3.2",
       "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.3.2.tgz",
       "integrity": "sha512-eVRqCvVlZbuw3GrM63ovNSNAeA1K16kaR/LRY/92w0zxQ5/1YzwblUX652i4Xs9RwAGjW9d9y6X88t8OaAJfWQ=="
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
     },
     "node_modules/iso-datestring-validator": {
       "version": "2.2.2",
···
         "node": ">= 0.6.0"
       }
     },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/safer-buffer": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
···
       "integrity": "sha512-JA//kQgZtbuY83m+xT+tXJkmJncGMTFT+C+g2h2R9uxkYIrE2yy9sgmcLhCnw57/WSD+Eh3J97FPEDFnbXnDUg==",
       "dependencies": {
         "is-arrayish": "^0.3.1"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
       }
     },
     "node_modules/strnum": {
···
       "dependencies": {
         "tr46": "~0.0.3",
         "webidl-conversions": "^3.0.0"
+      }
+    },
+    "node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
       }
     },
     "node_modules/zod": {

package.json

···
     "sharp": "^0.33.5",
     "cheerio": "^1.0.0",
     "node-fetch": "^3.3.2",
-    "oembetter": "1.1.4"
+    "oembetter": "1.1.4",
+    "yargs": "17.7.2"
   },
   "devDependencies": {
     "@types/follow-redirects": "^1.14.4",