9 | View your index 10 |
11 | 147 | 154 | 198 | 228 | 239 |240 | Notice a bug? Open an issue! 241 |
242 | 247 | -------------------------------------------------------------------------------- /public/problem_find.mjs: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env node 2 | 3 | import fs from 'node:fs'; 4 | import path from 'node:path'; 5 | import child_process from 'node:child_process'; 6 | 7 | import { 8 | loadPref, 9 | cache_file, 10 | index_file, 11 | } from '../src/args.js'; 12 | 13 | const CLEAN = false; 14 | const CONCURRENT = 7; 15 | const sleep = ms => new Promise(res => setTimeout(res, ms)); 16 | const problems = new Map(); 17 | let cleaning = false; 18 | let made = false; 19 | 20 | process.on('exit', cleanup); 21 | process.on('SIGINT', cleanup); 22 | process.on('SIGTERM', cleanup); 23 | process.on('SIGHUP', cleanup); 24 | process.on('SIGUSR2', cleanup); 25 | process.on('beforeExit', cleanup); 26 | 27 | console.log({Pref:loadPref(), cache_file: cache_file(), index_file: index_file()}); 28 | make(); 29 | 30 | async function make() { 31 | const indexFile = fs.readFileSync(index_file()).toString(); 32 | JSON.parse(indexFile).map(([key, value]) => { 33 | if ( typeof key === "number" ) return; 34 | if ( key.startsWith('ndx') ) return; 35 | if ( value.title === undefined ) { 36 | console.log('no title property', {key, value}); 37 | } 38 | const url = key; 39 | const title = value.title.toLocaleLowerCase(); 40 | if ( title.length === 0 || title.includes('404') || title.includes('not found') ) { 41 | if ( problems.has(url) ) { 42 | console.log('Found duplicate', url, title, problems.get(url)); 43 | } 44 | problems.set(url, title); 45 | } 46 | }); 47 | 48 | made = true; 49 | 50 | cleanup(); 51 | } 52 | 53 | function cleanup() { 54 | if ( cleaning ) return; 55 | if ( ! made ) return; 56 | cleaning = true; 57 | console.log('cleanup running'); 58 | const outData = [...problems.entries()]; 59 | fs.writeFileSync( 60 | path.resolve('.', 'url-problems.json'), 61 | JSON.stringify(outData, null, 2) 62 | ); 63 | const {size:bytesWritten} = fs.statSync( 64 | path.resolve('.', 'url-problems.json'), 65 | {bigint: true} 66 | ); 67 | console.log(`Wrote ${outData.length} problem urls in ${bytesWritten} bytes.`); 68 | process.exit(0); 69 | } 70 | 71 | function clean(urlString) { 72 | const url = new URL(urlString); 73 | if ( url.hash.startsWith('#!') || url.hostname.includes('google.com') || url.hostname.includes('80s.nyc') ) { 74 | } else { 75 | url.hash = ''; 76 | } 77 | for ( const [key, value] of url.searchParams ) { 78 | if ( key.startsWith('utm_') ) { 79 | url.searchParams.delete(key); 80 | } 81 | } 82 | url.pathname = url.pathname.replace(/\/$/, ''); 83 | url.protocol = 'https:'; 84 | url.pathname = url.pathname.replace(/(\.htm.?|\.php)$/, ''); 85 | if ( url.hostname.startsWith('www.') ) { 86 | url.hostname = url.hostname.replace(/^www./, ''); 87 | } 88 | const key = url.toString(); 89 | return key; 90 | } 91 | 92 | function clean2(urlString) { 93 | const url = new URL(urlString); 94 | url.pathname = ''; 95 | return url.toString(); 96 | } 97 | 98 | function curlCommand(url) { 99 | return `curl -k -L -s -o /dev/null -w '%{url_effective}' ${JSON.stringify(url)} \ 100 | -H 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9' \ 101 | -H 'Accept-Language: en,en-US;q=0.9,zh-TW;q=0.8,zh-CN;q=0.7,zh;q=0.6,ja;q=0.5' \ 102 | -H 'Cache-Control: no-cache' \ 103 | -H 'Connection: keep-alive' \ 104 | -H 'DNT: 1' \ 105 | -H 'Pragma: no-cache' \ 106 | -H 'Sec-Fetch-Dest: document' \ 107 | -H 'Sec-Fetch-Mode: navigate' \ 108 | -H 'Sec-Fetch-Site: none' \ 109 | -H 'Sec-Fetch-User: ?1' \ 110 | -H 'Upgrade-Insecure-Requests: 1' \ 111 | -H 'User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36' \ 112 | -H 'sec-ch-ua: "Chromium";v="104", " Not A;Brand";v="99", "Google Chrome";v="104"' \ 113 | -H 'sec-ch-ua-mobile: ?0' \ 114 | -H 'sec-ch-ua-platform: "macOS"' \ 115 | --compressed ; 116 | `; 117 | } 118 | -------------------------------------------------------------------------------- /public/redirector.html: -------------------------------------------------------------------------------- 1 | 2 | 3 |This navigation was prevented by 22120 as a Chrome bug fix for some requests causing issues.
6 | `).toString("base64"); 7 | export const BLOCKED_HEADERS = [ 8 | {name: "X-Powered-By", value: "Dosyago-Corporation"}, 9 | {name: "X-Blocked-Internally", value: "Custom 22120 Chrome bug fix"}, 10 | {name: "Accept-Ranges", value: "bytes"}, 11 | {name: "Cache-Control", value: "public, max-age=0"}, 12 | {name: "Content-Type", value: "text/html; charset=UTF-8"}, 13 | {name: "Content-Length", value: `${BLOCKED_BODY.length}`} 14 | ]; 15 | 16 | const BLOCKED_RESPONSE = ` 17 | HTTP/1.1 ${BLOCKED_CODE} OK 18 | X-Powered-By: Zanj-Dosyago-Corporation 19 | X-Blocked-Internally: Custom ad blocking 20 | Accept-Ranges: bytes 21 | Cache-Control: public, max-age=0 22 | Content-Type: text/html; charset=UTF-8 23 | Content-Length: ${BLOCKED_BODY.length} 24 | 25 | ${BLOCKED_BODY} 26 | `; 27 | 28 | export default BLOCKED_RESPONSE; 29 | 30 | -------------------------------------------------------------------------------- /src/bookmarker.js: -------------------------------------------------------------------------------- 1 | import os from 'os'; 2 | import Path from 'path'; 3 | import fs from 'fs'; 4 | 5 | import {DEBUG as debug} from './common.js'; 6 | 7 | const DEBUG = debug || false; 8 | // Chrome user data directories by platform. 9 | // Source 1: https://chromium.googlesource.com/chromium/src/+/HEAD/docs/user_data_dir.md 10 | // Source 2: https://superuser.com/questions/329112/where-are-the-user-profile-directories-of-google-chrome-located-in 11 | 12 | const FS_WATCH_OPTS = { 13 | persistent: false, 14 | }; 15 | 16 | // Note: 17 | // Not all the below are now used or supported by this code 18 | const UDD_PATHS = { 19 | 'win': '%LOCALAPPDATA%\\Google\\Chrome\\User Data', 20 | 'winxp' : '%USERPROFILE%\\Local Settings\\Application Data\\Google\\Chrome\\User Data', 21 | 'macos' : Path.resolve(os.homedir(), 'Library/Application Support/Google/Chrome'), 22 | 'nix' : Path.resolve(os.homedir(), '.config/google-chrome'), 23 | 'chromeos': '/home/chronos', /* no support */ 24 | 'ios': 'Library/Application Support/Google/Chrome', /* no support */ 25 | }; 26 | const PLAT_TABLE = { 27 | 'darwin': 'macos', 28 | 'linux': 'nix' 29 | }; 30 | const PROFILE_DIR_NAME_REGEX = /^(Default|Profile \d+)$/i; 31 | const isProfileDir = name => PROFILE_DIR_NAME_REGEX.test(name); 32 | const BOOKMARK_FILE_NAME_REGEX = /^Bookmarks$/i; 33 | const isBookmarkFile = name => BOOKMARK_FILE_NAME_REGEX.test(name); 34 | const State = { 35 | active: new Set(), /* active Bookmark files (we don't know these until file changes) */ 36 | books: { 37 | 38 | } 39 | }; 40 | 41 | export async function* bookmarkChanges() { 42 | // try to get the profile directory 43 | const rootDir = getProfileRootDir(); 44 | 45 | if ( !fs.existsSync(rootDir) ) { 46 | throw new TypeError(`Sorry! The directory where we thought the Chrome profile directories may be found (${rootDir}), does not exist. We can't monitor changes to your bookmarks, so Bookmark Select Mode is not supported.`); 47 | } 48 | 49 | // state constants and variables (including chokidar file glob observer) 50 | const observers = []; 51 | const ps = []; 52 | let change = false; 53 | let notifyChange = false; 54 | let stopLooping = false; 55 | let shuttingDown = false; 56 | 57 | // create sufficient observers 58 | const dirs = fs.readdirSync(rootDir, {withFileTypes:true}).reduce((Files, dirent) => { 59 | if ( dirent.isDirectory() && isProfileDir(dirent.name) ) { 60 | const filePath = Path.resolve(rootDir, dirent.name); 61 | 62 | if ( fs.existsSync(filePath) ) { 63 | Files.push(filePath); 64 | } 65 | } 66 | return Files; 67 | }, []); 68 | for( const dirPath of dirs ) { 69 | // first read it in 70 | const filePath = Path.resolve(dirPath, 'Bookmarks'); 71 | if ( fs.existsSync(filePath) ) { 72 | const data = fs.readFileSync(filePath); 73 | const jData = JSON.parse(data); 74 | State.books[filePath] = flatten(jData, {toMap:true}); 75 | } 76 | 77 | const observer = fs.watch(dirPath, FS_WATCH_OPTS); 78 | console.log(`Observing ${dirPath}`); 79 | // Note 80 | // allow the parent process to exit 81 | //even if observer is still active somehow 82 | observer.unref(); 83 | 84 | // listen for all events from the observer 85 | observer.on('change', (event, filename) => { 86 | filename = filename || ''; 87 | // listen to everything 88 | const path = Path.resolve(dirPath, filename); 89 | DEBUG.verboseSlow && console.log(event, path); 90 | if ( isBookmarkFile(filename) ) { 91 | if ( ! State.active.has(path) ) { 92 | State.active.add(path); 93 | } 94 | // but only act if it is a bookmark file 95 | DEBUG.verboseSlow && console.log(event, path, notifyChange); 96 | // save the event type and file it happened to 97 | change = {event, path}; 98 | // drop the most recently pushed promise from our bookkeeping list 99 | ps.pop(); 100 | // resolve the promise in the wait loop to process the bookmark file and emit the changes 101 | notifyChange && notifyChange(); 102 | } 103 | }); 104 | observer.on('error', error => { 105 | console.warn(`Bookmark file observer for ${dirPath} error`, error); 106 | observers.slice(observers.indexOf(observer), 1); 107 | if ( observers.length ) { 108 | notifyChange && notifyChange(); 109 | } else { 110 | stopLooping && stopLooping(); 111 | } 112 | }); 113 | observer.on('close', () => { 114 | console.info(`Observer for ${dirPath} closed`); 115 | observers.slice(observers.indexOf(observer), 1); 116 | if ( observers.length ) { 117 | notifyChange && notifyChange(); 118 | } else { 119 | stopLooping && stopLooping(); 120 | } 121 | }); 122 | 123 | observers.push(observer); 124 | } 125 | 126 | // make sure we kill the watcher on process restart or shutdown 127 | process.on('SIGTERM', shutdown); 128 | process.on('SIGHUP', shutdown); 129 | process.on('SIGINT', shutdown); 130 | process.on('SIGBRK', shutdown); 131 | 132 | // the main wait loop that enables us to turn a traditional NodeJS eventemitter 133 | // into an asychronous stream generator 134 | waiting: while(true) { 135 | // Note: code resilience 136 | //the below two statements can come in any order in this loop, both work 137 | 138 | // get, process and publish changes 139 | // only do if the change is there (first time it won't be because 140 | // we haven't yielded out (async or yield) yet) 141 | if ( change ) { 142 | const {path} = change; 143 | change = false; 144 | 145 | try { 146 | const changes = flatten( 147 | JSON.parse(fs.readFileSync(path)), 148 | {toMap:true, map: State.books[path]} 149 | ); 150 | 151 | for( const changeEvent of changes ) yield changeEvent; 152 | } catch(e) { 153 | console.warn(`Error publishing Bookmarks changes`, e); 154 | } 155 | } 156 | 157 | // wait for the next change 158 | // always wait tho (to allow queueing of the next event to process) 159 | try { 160 | await new Promise((res, rej) => { 161 | // save these 162 | notifyChange = res; // so we can turn the next turn of the loop 163 | stopLooping = rej; // so we can break out of the loop (on shutdown) 164 | ps.push({res,rej}); // so we can clean up any left over promises 165 | }); 166 | } catch { 167 | ps.pop(); 168 | break waiting; 169 | } 170 | } 171 | 172 | shutdown(); 173 | 174 | return true; 175 | 176 | async function shutdown() { 177 | if ( shuttingDown ) return; 178 | shuttingDown = true; 179 | console.log('Bookmark observer shutting down...'); 180 | // clean up any outstanding waiting promises 181 | while ( ps.length ) { 182 | /* eslint-disable no-empty */ 183 | try { ps.pop().rej(); } finally {} 184 | /* eslint-enable no-empty */ 185 | } 186 | // stop the waiting loop 187 | stopLooping && setTimeout(() => stopLooping('bookmark watching stopped'), 0); 188 | // clean up any observers 189 | while(observers.length) { 190 | /* eslint-disable no-empty */ 191 | try { observers.pop().close(); } finally {} 192 | /* eslint-enable no-empty */ 193 | } 194 | console.log('Bookmark observer shut down cleanly.'); 195 | } 196 | } 197 | 198 | export function hasBookmark(url) { 199 | return Object.keys(State.books).filter(key => { 200 | if ( State.active.size == 0 ) return true; 201 | return State.active.has(key); 202 | }).map(key => State.books[key]) 203 | .some(map => map.has(url)); 204 | } 205 | 206 | function getProfileRootDir() { 207 | const plat = os.platform(); 208 | let name = PLAT_TABLE[plat]; 209 | let rootDir; 210 | 211 | DEBUG.verboseSlow && console.log({plat, name}); 212 | 213 | if ( !name ) { 214 | if ( plat === 'win32' ) { 215 | // because Chrome profile dir location only changes in XP 216 | // we only care if it's XP or not and so 217 | // we try to resolve based on the version major and minor (given by release) 218 | // source: https://docs.microsoft.com/en-us/windows/win32/sysinfo/operating-system-version?redirectedfrom=MSDN 219 | const rel = os.release(); 220 | const ver = parseFloat(rel); 221 | if ( !Number.isNaN(ver) && ver <= 5.2 ) { 222 | // this should be reliable 223 | name = 'winxp'; 224 | } else { 225 | // this may not be reliable, but we just do it 226 | name = 'win'; 227 | } 228 | } else { 229 | throw new TypeError( 230 | `Sorry! We don't know how to find the default Chrome profile on OS platform: ${plat}` 231 | ); 232 | } 233 | } 234 | 235 | if ( UDD_PATHS[name] ) { 236 | rootDir = Path.resolve(resolveEnvironmentVariablesToPathSegments(UDD_PATHS[name])); 237 | } else { 238 | throw new TypeError( 239 | `Sorry! We don't know how to find the default Chrome profile on OS name: ${name}` 240 | ); 241 | } 242 | 243 | return rootDir; 244 | } 245 | 246 | function flatten(bookmarkObj, {toMap: toMap = false, map} = {}) { 247 | const nodes = [...Object.values(bookmarkObj.roots)]; 248 | const urls = toMap? (map || new Map()) : []; 249 | const urlSet = new Set(); 250 | const changes = []; 251 | 252 | while(nodes.length) { 253 | const next = nodes.pop(); 254 | const {name, type, url} = next; 255 | switch(type) { 256 | case "url": 257 | if ( toMap ) { 258 | if ( map ) { 259 | if ( urls.has(url) ) { 260 | const {name:oldName} = urls.get(url); 261 | if ( name !== oldName ) { 262 | if ( !urlSet.has(url) ) { 263 | changes.push({ 264 | type: "Title updated", 265 | url, 266 | oldName, 267 | name 268 | }); 269 | } 270 | } 271 | } else { 272 | changes.push({ 273 | type: "new", 274 | name, url 275 | }); 276 | } 277 | } 278 | if ( !urlSet.has(url) ) { 279 | urls.set(url, next); 280 | } 281 | urlSet.add(url); 282 | } else { 283 | urls.push(next); 284 | } 285 | break; 286 | case "folder": 287 | nodes.push(...next.children); 288 | break; 289 | default: 290 | console.info("New type", type, next); 291 | break; 292 | 293 | } 294 | } 295 | 296 | if (map) { 297 | [...map.keys()].forEach(url => { 298 | if ( !urlSet.has(url) ) { 299 | changes.push({ 300 | type: "delete", 301 | url 302 | }); 303 | map.delete(url); 304 | } 305 | }); 306 | } 307 | 308 | return map ? changes : urls; 309 | } 310 | 311 | // source: https://stackoverflow.com/a/33017068 312 | function resolveEnvironmentVariablesToPathSegments(path) { 313 | return path.replace(/%([^%]+)%/g, function(_, key) { 314 | return process.env[key]; 315 | }); 316 | } 317 | 318 | /* 319 | test(); 320 | async function test() { 321 | for await ( const change of bookmarkChanges() ) { 322 | console.log(change); 323 | } 324 | } 325 | */ 326 | 327 | 328 | /* 329 | function* profileDirectoryEnumerator(maxN = 9999) { 330 | let index = 0; 331 | while(index <= maxN) { 332 | const profileDirName = index ? `Profile ${index}` : `Default`; 333 | yield profileDirName; 334 | } 335 | } 336 | */ 337 | -------------------------------------------------------------------------------- /src/common.js: -------------------------------------------------------------------------------- 1 | import path from 'path'; 2 | import {fileURLToPath} from 'url'; 3 | import fs from 'fs'; 4 | import os from 'os'; 5 | import { root } from './root.js'; 6 | 7 | const { APP_ROOT: __ROOT } = root; 8 | 9 | const DEEB = process.env.DEBUG_22120_VERBOSE || false; 10 | 11 | export const DEBUG = { 12 | showBrowser: false, 13 | verboseBrowser: false, 14 | showList: false, 15 | showStatus: false, 16 | debugSec: false, 17 | askFirst: true, 18 | verboseSlow: process.env.VERBOSE_DEBUG_22120 || DEEB, 19 | debug: process.env.DEBUG_22120 || DEEB, 20 | verbose: DEEB || process.env.VERBOSE_DEBUG_22120 || process.env.DEBUG_22120, 21 | checkPred: false, 22 | } 23 | export const SHOW_FETCH = false; 24 | 25 | if ( DEBUG.debug ) { 26 | console.log({__ROOT}); 27 | } 28 | 29 | // server related 30 | export const PUBLIC_SERVER = true; 31 | 32 | // crawl related 33 | export const MIN_TIME_PER_PAGE = 10000; 34 | export const MAX_TIME_PER_PAGE = 32000; 35 | export const MIN_WAIT = 200; 36 | export const MAX_WAITS = 300; 37 | export const BATCH_SIZE = 5; // crawl batch size (how many concurrent tabs for crawling) 38 | export const MAX_REAL_URL_LENGTH = 2**15 - 1; 39 | 40 | export const CHECK_INTERVAL = 400; 41 | export const TEXT_NODE = 3; 42 | export const MAX_HIGHLIGHTABLE_LENGTH = 0; /* 0 is no max length for highlight */ 43 | export const MAX_TITLE_LENGTH = 140; 44 | export const MAX_URL_LENGTH = 140; 45 | export const MAX_HEAD = 140; 46 | 47 | const LOCALP = path.resolve(os.homedir(), 'local-sslcerts', 'privkey.pem'); 48 | const ANYP = path.resolve(os.homedir(), 'sslcerts', 'privkey.pem'); 49 | export const GO_SECURE = fs.existsSync(LOCALP) || fs.existsSync(ANYP); 50 | const cert_path = GO_SECURE ? path.dirname(fs.existsSync(LOCALP) ? LOCALP : fs.existsSync(ANYP) ? ANYP : null) : null; 51 | export const CERT_PATH = () => GO_SECURE ? cert_path : false; 52 | 53 | export class RichError extends Error { 54 | constructor(msg) { 55 | super(msg); 56 | let textMessage; 57 | try { 58 | textMessage = JSON.stringify(msg); 59 | } catch(e) { 60 | console.warn(`Could not create RichError from argument ${msg.toString ? msg.toString() : msg} as JSON serialization failed. RichError argument MUST be JSON serializable. Failure error was:`, e); 61 | return; 62 | } 63 | super(textMessage); 64 | } 65 | } 66 | 67 | /* text nodes inside these elements that are ignored */ 68 | export const FORBIDDEN_TEXT_PARENT = new Set([ 69 | 'STYLE', 70 | 'SCRIPT', 71 | 'NOSCRIPT', 72 | /* we could remove these last two so as to index them as well */ 73 | 'DATALIST', 74 | 'OPTION' 75 | ]); 76 | export const ERROR_CODE_SAFE_TO_IGNORE = new Set([ 77 | -32000, /* message: 78 | Can only get response body on requests captured after headers received. 79 | * ignore because: 80 | seems to only happen when new navigation aborts all 81 | pending requests of the unloading page 82 | */ 83 | -32602, /* message: 84 | Invalid InterceptionId. 85 | * ignore because: 86 | seems to only happen when new navigation aborts all 87 | pending requests of the unloading page 88 | */ 89 | ]); 90 | 91 | export const SNIP_CONTEXT = 31; 92 | 93 | export const NO_SANDBOX = (process.env.DEBUG_22120 && process.env.SET_22120_NO_SANDBOX) || false; 94 | 95 | export const APP_ROOT = __ROOT; 96 | 97 | export const sleep = ms => new Promise(res => setTimeout(res, ms)); 98 | 99 | export function say(o) { 100 | console.log(JSON.stringify(o)); 101 | } 102 | 103 | export function clone(o) { 104 | return JSON.parse(JSON.stringify(o)); 105 | } 106 | 107 | export async function untilTrue(pred, waitOverride = MIN_WAIT, maxWaits = MAX_WAITS) { 108 | if ( waitOverride < 0 ) { 109 | maxWaits = -1; 110 | waitOverride = MIN_WAIT; 111 | } 112 | let waitCount = 0; 113 | let resolve; 114 | const pr = new Promise(res => resolve = res); 115 | setTimeout(checkPred, 0); 116 | return pr; 117 | 118 | async function checkPred() { 119 | DEBUG.checkPred && console.log('Checking', pred.toString()); 120 | if ( await pred() ) { 121 | return resolve(true); 122 | } else { 123 | waitCount++; 124 | if ( waitCount < maxWaits || maxWaits < 0 ) { 125 | setTimeout(checkPred, waitOverride); 126 | } else { 127 | resolve(false); 128 | } 129 | } 130 | } 131 | } 132 | -------------------------------------------------------------------------------- /src/hello.js: -------------------------------------------------------------------------------- 1 | console.log(`hello...is it me you're looking for?`); 2 | -------------------------------------------------------------------------------- /src/highlighter.js: -------------------------------------------------------------------------------- 1 | // highlighter.js 2 | 3 | import ukkonen from 'ukkonen'; 4 | import {DEBUG} from './common.js'; 5 | 6 | const MAX_ACCEPT_SCORE = 0.5; 7 | const CHUNK_SIZE = 12; 8 | 9 | // Helper to wrap query terms with tags within a text 10 | // This function will be used by both highlight and trilight before returning results. 11 | function internalMarkText(textToMark, queryToFind) { 12 | if (!textToMark || !queryToFind) return textToMark; 13 | try { 14 | // Case-insensitive replacement, escaping regex special characters in query 15 | const escapedQuery = queryToFind.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); 16 | const regex = new RegExp('(' + escapedQuery + ')', 'gi'); 17 | return textToMark.replace(regex, '$1'); 18 | } catch (e) { 19 | console.warn("internalMarkText: Regex failed for query:", queryToFind, e); 20 | return textToMark; // Fallback to original text if regex fails 21 | } 22 | } 23 | 24 | 25 | function calculateUkkonenParams(queryLength, chunkSize = CHUNK_SIZE) { 26 | // Renamed from 'params' for clarity 27 | const maxDistance = chunkSize; // Max edit distance for Ukkonen 28 | const minPossibleScore = Math.abs(queryLength - chunkSize); // Minimum edits based on length difference 29 | // Max possible score range (denominator for scaling) 30 | let maxScoreRange = Math.max(queryLength, chunkSize) - minPossibleScore; 31 | if (maxScoreRange === 0) maxScoreRange = 1; // Avoid division by zero 32 | 33 | return {maxDistance, minPossibleScore, maxScoreRange}; 34 | } 35 | 36 | export function highlight(query, docString, { 37 | maxLength = 0, 38 | maxAcceptScore = MAX_ACCEPT_SCORE, 39 | chunkSize = CHUNK_SIZE, 40 | // Options from server (around, before) are now handled internally by 41 | // numResults and contextChars are effectively handled by the original logic's 42 | // "better.slice(0,3)" and "extra" context respectively. 43 | } = {}) { 44 | if (chunkSize % 2) { 45 | // Original code threw an error. Preserving this behavior. 46 | throw new TypeError(`chunkSize must be even. Was: ${chunkSize} which is odd.`); 47 | } 48 | 49 | let docChars = Array.from(docString); // Use character array for Unicode safety 50 | if (maxLength > 0 && docChars.length > maxLength) { 51 | docChars = docChars.slice(0, maxLength); 52 | } 53 | 54 | if (docChars.length === 0 || query.trim() === "") { 55 | return []; 56 | } 57 | 58 | const queryLower = query.toLocaleLowerCase(); // Lowercase query once 59 | const queryLength = Array.from(query).length; // Unicode-safe query length 60 | 61 | if (queryLength === 0) return []; 62 | 63 | const {maxDistance, minPossibleScore, maxScoreRange} = calculateUkkonenParams(queryLength, chunkSize); 64 | 65 | // --- Fragment Generation (Identical to original) --- 66 | // First set of fragments (docChars1) 67 | const docChars1 = [...docChars]; // Create a mutable copy 68 | // Pad to make length a multiple of chunkSize 69 | const padding1Length = (chunkSize - docChars1.length % chunkSize) % chunkSize; 70 | docChars1.push(...Array(padding1Length).fill(' ')); 71 | const fragments1 = docChars1.reduce(getFragmenter(chunkSize, {symbolsArray: docChars}), []); // Pass original docChars for context 72 | 73 | // Second set of fragments (docChars2) with offset 74 | const docChars2 = [...docChars]; // Create another mutable copy 75 | // Pad start by half chunkSize 76 | docChars2.splice(0, 0, ...Array(chunkSize / 2).fill(' ')); 77 | // Pad end to make length a multiple of chunkSize 78 | const padding2Length = (chunkSize - docChars2.length % chunkSize) % chunkSize; 79 | docChars2.push(...Array(padding2Length).fill(' ')); 80 | const fragments2 = docChars2.reduce(getFragmenter(chunkSize, {symbolsArray: docChars, initialOffset: -(chunkSize/2)}), []); // Adjust offset 81 | 82 | DEBUG.verboseSlow && console.log("highlight: fragments1 count:", fragments1.length, "fragments2 count:", fragments2.length); 83 | 84 | const allFragments = [...fragments1, ...fragments2]; 85 | const scoredFragments = allFragments.map(fragment => { 86 | // fragment.text is already from the original doc, no need to lowercase it here for distance calculation 87 | // ukkonen should compare queryLower with fragment.text.toLocaleLowerCase() 88 | const distance = ukkonen(queryLower, fragment.text.toLocaleLowerCase(), maxDistance); 89 | 90 | let scaledScore; 91 | if (distance === -1) { // Exceeded maxDistance 92 | scaledScore = Infinity; 93 | } else { 94 | scaledScore = (distance - minPossibleScore) / maxScoreRange; 95 | } 96 | return {score: scaledScore, fragment}; // fragment object contains {text, offset, symbols} 97 | }); 98 | 99 | // Sort ascending (smallest scores win) 100 | scoredFragments.sort((a, b) => a.score - b.score); 101 | 102 | const initialHighlights = []; 103 | for (const {score, fragment} of scoredFragments) { 104 | if (score > maxAcceptScore) { 105 | // If we already have some highlights, we can stop if scores get too bad. 106 | // If we have none, we might continue to find at least one, even if poor. 107 | if (initialHighlights.length > 0) break; 108 | } 109 | initialHighlights.push({score, fragment}); 110 | if (initialHighlights.length >= 10 + 1) break; // Get a bit more than needed for the "better" selection (original took 10 for "better") 111 | } 112 | 113 | DEBUG.verboseSlow && console.log("highlight: initialHighlights count:", initialHighlights.length); 114 | 115 | let topSnippets; 116 | 117 | if (initialHighlights.length === 0) { 118 | DEBUG.verboseSlow && console.log('highlight: Zero initial highlights. Considering first scored fragment if available.'); 119 | // Original logic: scores.slice(0,1) - this implies taking the best raw score if no "good" highlights 120 | if (scoredFragments.length > 0 && scoredFragments[0].score !== Infinity) { 121 | // Take the single best fragment, expand context, and mark it. 122 | const bestFragment = scoredFragments[0].fragment; 123 | const contextChars = chunkSize; // Original 'extra' was chunkSize 124 | const start = Math.max(0, bestFragment.offset - contextChars); 125 | const end = Math.min(docChars.length, bestFragment.offset + Array.from(bestFragment.text).length + contextChars); 126 | const snippetText = docChars.slice(start, end).join(''); 127 | 128 | topSnippets = [{ 129 | // score: scoredFragments[0].score, // Keep score if needed 130 | fragment: { 131 | text: internalMarkText(snippetText, query), 132 | offset: bestFragment.offset // Original offset of the core matched chunk 133 | } 134 | }]; 135 | } else { 136 | topSnippets = []; // Truly no usable fragments 137 | } 138 | } else { 139 | // --- "Better" loop for context expansion and re-scoring (Identical logic to original) --- 140 | const contextCharsForBetterLoop = chunkSize; // Original 'extra' was chunkSize 141 | let betterScoredSnippets = initialHighlights.slice(0, 10).map(hl => { 142 | const originalFragment = hl.fragment; 143 | const originalFragmentTextChars = Array.from(originalFragment.text); // Unicode safe length 144 | const originalFragmentLength = originalFragmentTextChars.length; 145 | 146 | // Expand context using original document characters (hl.fragment.symbols) 147 | const startContext = Math.max(0, originalFragment.offset - contextCharsForBetterLoop); 148 | const endContext = Math.min(originalFragment.symbols.length, originalFragment.offset + originalFragmentLength + contextCharsForBetterLoop); 149 | 150 | const expandedText = originalFragment.symbols.slice(startContext, endContext).join(''); 151 | const expandedTextLength = Array.from(expandedText).length; // Unicode safe 152 | 153 | // Re-calculate Ukkonen parameters for this new expanded text against the query 154 | const { 155 | maxDistance: newMaxDist, 156 | minPossibleScore: newMinScore, 157 | maxScoreRange: newMaxScoreRange 158 | } = calculateUkkonenParams(queryLength, expandedTextLength); // chunkSize is now expandedTextLength 159 | 160 | const newDistance = ukkonen(queryLower, expandedText.toLocaleLowerCase(), newMaxDist); 161 | 162 | let newScaledScore; 163 | if (newDistance === -1) { 164 | newScaledScore = Infinity; 165 | } else { 166 | newScaledScore = (newDistance - newMinScore) / newMaxScoreRange; 167 | } 168 | 169 | // The fragment text for output is the expanded text 170 | return { 171 | score: newScaledScore, 172 | fragment: { // New fragment object 173 | text: expandedText, // This text will be marked later 174 | // The offset should ideally be the start of this expanded snippet in the original document 175 | offset: startContext, 176 | // symbols: originalFragment.symbols // Not needed in final output 177 | } 178 | }; 179 | }); 180 | 181 | betterScoredSnippets.sort((a, b) => a.score - b.score); 182 | DEBUG.verboseSlow && console.log("highlight: betterScoredSnippets (after re-scoring with context):", JSON.stringify(betterScoredSnippets.slice(0,3),null,2)); 183 | 184 | // Take top 3 from these "better" snippets and apply marking 185 | topSnippets = betterScoredSnippets.slice(0, 3).map(item => ({ 186 | // score: item.score, // Keep score if needed 187 | fragment: { 188 | text: internalMarkText(item.fragment.text, query), 189 | offset: item.fragment.offset 190 | } 191 | })); 192 | } 193 | 194 | DEBUG.verboseSlow && console.log("highlight: final topSnippets to return:", topSnippets); 195 | return topSnippets; 196 | } 197 | 198 | 199 | // --- getFragmenter (Helper for highlight and trilight) --- 200 | // Preserving its original logic as much as possible, with clearer parameters. 201 | // The `symbolsArray` and `initialOffset` are for `highlight`'s specific needs. 202 | function getFragmenter(chunkSize, {overlap = false, symbolsArray = null, initialOffset = 0} = {}) { 203 | if (!Number.isInteger(chunkSize) || chunkSize < 1) { 204 | throw new TypeError(`chunkSize needs to be a whole number greater than 0`); 205 | } 206 | 207 | let currentFragmentCharCount; // Renamed from currentLength for clarity 208 | 209 | return function fragmentReducer(fragmentsAccumulator, nextCharSymbol, charIndex, fullSymbolArray) { 210 | // `fullSymbolArray` is the array being reduced. 211 | // `symbolsArray` (passed in options) is the *original* document characters, 212 | // used by `highlight` to ensure fragment.symbols points to the original doc. 213 | const effectiveSymbolsArray = symbolsArray || fullSymbolArray; 214 | const effectiveCharIndex = charIndex + initialOffset; // Adjust index for highlight's second pass 215 | 216 | if (overlap) { 217 | // Logic for overlapping fragments (primarily for trilight's n-grams) 218 | // This part of original getFragmenter was complex and seemed to modify previous frags. 219 | // For n-grams, it's simpler: create a new fragment for each possible n-gram. 220 | if (charIndex <= fullSymbolArray.length - chunkSize) { 221 | const ngramChars = fullSymbolArray.slice(charIndex, charIndex + chunkSize); 222 | fragmentsAccumulator.push({ 223 | text: ngramChars.join(''), 224 | offset: effectiveCharIndex, // Offset in the original document 225 | symbols: effectiveSymbolsArray 226 | }); 227 | } 228 | } else { 229 | // Logic for non-overlapping fragments (for highlight's chunking) 230 | if (fragmentsAccumulator.length === 0 || currentFragmentCharCount >= chunkSize) { 231 | // Start a new fragment 232 | fragmentsAccumulator.push({ 233 | text: nextCharSymbol, 234 | offset: effectiveCharIndex, // Offset in the original document 235 | symbols: effectiveSymbolsArray 236 | }); 237 | currentFragmentCharCount = 1; 238 | } else { 239 | // Add to the current fragment 240 | const currentFragment = fragmentsAccumulator[fragmentsAccumulator.length - 1]; 241 | currentFragment.text += nextCharSymbol; 242 | currentFragmentCharCount++; 243 | } 244 | } 245 | return fragmentsAccumulator; 246 | }; 247 | } 248 | 249 | 250 | // --- trilight function --- 251 | // Preserving original algorithm and segment generation logic with clarity and support. 252 | export function trilight(query, docString, { 253 | maxLength = 0, 254 | ngramSize = 3, 255 | maxSegmentSize = 140, 256 | // numResults is implicitly 3 due to .slice(0,3) at the end 257 | } = {}) { 258 | const originalDocChars = Array.from(docString); // For final slicing, Unicode safe 259 | const queryChars = Array.from(query.toLocaleLowerCase()); // Lowercase query once 260 | 261 | let docCharsForProcessing = Array.from(docString.toLocaleLowerCase()); 262 | if (maxLength > 0 && docCharsForProcessing.length > maxLength) { 263 | docCharsForProcessing = docCharsForProcessing.slice(0, maxLength); 264 | } 265 | 266 | if (docCharsForProcessing.length < ngramSize || queryChars.length < ngramSize) { 267 | return []; 268 | } 269 | 270 | // Generate n-grams for document and query using the getFragmenter 271 | // For n-grams, getFragmenter should be called with overlap: true 272 | const docNgrams = docCharsForProcessing.reduce(getFragmenter(ngramSize, {overlap: true, symbolsArray: originalDocChars}), []); 273 | const queryNgrams = queryChars.reduce(getFragmenter(ngramSize, {overlap: true, symbolsArray: queryChars}), []); // symbolsArray here is queryChars 274 | 275 | if (docNgrams.length === 0 || queryNgrams.length === 0) return []; 276 | 277 | // Index document n-grams by their text 278 | const docNgramIndex = new Map(); 279 | docNgrams.forEach(ngram => { 280 | if (!docNgramIndex.has(ngram.text)) { 281 | docNgramIndex.set(ngram.text, []); 282 | } 283 | // Store original character offset of the ngram in the document 284 | docNgramIndex.get(ngram.text).push(ngram.offset); 285 | }); 286 | 287 | // --- Find matching entries (Identical to original logic) --- 288 | const matchingEntries = []; 289 | queryNgrams.forEach((queryNgram, queryNgramIndex) => { 290 | const docOffsetsForNgram = docNgramIndex.get(queryNgram.text); 291 | if (docOffsetsForNgram) { 292 | docOffsetsForNgram.forEach(docCharOffset => { 293 | matchingEntries.push({ 294 | ngramText: queryNgram.text, 295 | queryNgramIndex: queryNgramIndex, // Index of ngram within queryNgrams list 296 | docCharOffset: docCharOffset // Character offset of ngram in original document 297 | }); 298 | }); 299 | } 300 | }); 301 | matchingEntries.sort((a, b) => a.docCharOffset - b.docCharOffset); // Sort by document offset 302 | 303 | // --- Identify runs of consecutive matching n-grams (Identical to original logic) --- 304 | const runs = []; 305 | if (matchingEntries.length > 0) { 306 | let currentRun = { 307 | ngramsInRun: [matchingEntries[0].ngramText], 308 | startQueryNgramIndex: matchingEntries[0].queryNgramIndex, 309 | startDocCharOffset: matchingEntries[0].docCharOffset 310 | }; 311 | let lastQueryNgramIndexInRun = matchingEntries[0].queryNgramIndex; 312 | let lastDocCharOffsetInRun = matchingEntries[0].docCharOffset; 313 | 314 | for (let i = 1; i < matchingEntries.length; i++) { 315 | const entry = matchingEntries[i]; 316 | const queryIndexDiff = entry.queryNgramIndex - lastQueryNgramIndexInRun; 317 | const docOffsetDiff = entry.docCharOffset - lastDocCharOffsetInRun; 318 | 319 | if (queryIndexDiff === 1 && docOffsetDiff === 1) { // Consecutive in both query and doc 320 | currentRun.ngramsInRun.push(entry.ngramText); 321 | } else { 322 | // End current run, add its length, then push 323 | currentRun.charLengthInDoc = currentRun.ngramsInRun.length + (ngramSize - 1); 324 | runs.push(currentRun); 325 | // Start new run 326 | currentRun = { 327 | ngramsInRun: [entry.ngramText], 328 | startQueryNgramIndex: entry.queryNgramIndex, 329 | startDocCharOffset: entry.docCharOffset 330 | }; 331 | } 332 | lastQueryNgramIndexInRun = entry.queryNgramIndex; 333 | lastDocCharOffsetInRun = entry.docCharOffset; 334 | } 335 | // Add the last run 336 | currentRun.charLengthInDoc = currentRun.ngramsInRun.length + (ngramSize - 1); 337 | runs.push(currentRun); 338 | } 339 | 340 | DEBUG.verboseSlow && console.log("trilight: identified runs:", runs.length); 341 | 342 | // --- Calculate gaps between runs (Identical to original logic) --- 343 | const gaps = []; 344 | if (runs.length > 1) { 345 | for (let i = 0; i < runs.length - 1; i++) { 346 | const run1 = runs[i]; 347 | const run2 = runs[i+1]; 348 | gaps.push({ 349 | connectedRuns: [run1, run2], 350 | gapSize: run2.startDocCharOffset - (run1.startDocCharOffset + run1.charLengthInDoc) 351 | }); 352 | } 353 | } 354 | gaps.sort((a, b) => a.gapSize - b.gapSize); // Sort by smallest gap 355 | 356 | // --- Merge runs into segments (Identical to original logic) --- 357 | const segments = []; 358 | const runToSegmentMap = new Map(); // Maps run's startDocCharOffset to the segment it belongs to 359 | 360 | // Initialize segments with individual runs if they are not too long 361 | runs.forEach(run => { 362 | if (run.charLengthInDoc <= maxSegmentSize) { 363 | const newSegment = { 364 | startOffset: run.startDocCharOffset, 365 | endOffset: run.startDocCharOffset + run.charLengthInDoc, 366 | score: run.charLengthInDoc // Initial score is its own length 367 | }; 368 | segments.push(newSegment); 369 | runToSegmentMap.set(run.startDocCharOffset, newSegment); 370 | } 371 | }); 372 | 373 | 374 | for (const gapInfo of gaps) { 375 | const runLeft = gapInfo.connectedRuns[0]; 376 | const runRight = gapInfo.connectedRuns[1]; 377 | 378 | const segmentForLeftRun = runToSegmentMap.get(runLeft.startDocCharOffset); 379 | const segmentForRightRun = runToSegmentMap.get(runRight.startDocCharOffset); 380 | 381 | if (segmentForLeftRun && segmentForRightRun && segmentForLeftRun === segmentForRightRun) { 382 | continue; // Already in the same segment 383 | } 384 | 385 | let merged = false; 386 | if (segmentForLeftRun && !segmentForRightRun) { // Try to extend left segment with right run 387 | const potentialNewEnd = runRight.startDocCharOffset + runRight.charLengthInDoc; 388 | if ((potentialNewEnd - segmentForLeftRun.startOffset) <= maxSegmentSize) { 389 | segmentForLeftRun.endOffset = potentialNewEnd; 390 | segmentForLeftRun.score += runRight.charLengthInDoc; // Add length of right run 391 | runToSegmentMap.set(runRight.startDocCharOffset, segmentForLeftRun); // Right run now points to left's segment 392 | // Remove standalone segment for right run if it existed (it shouldn't if !segmentForRightRun) 393 | const rightRunStandaloneSegmentIndex = segments.findIndex(s => s.startOffset === runRight.startDocCharOffset && s.endOffset === runRight.startDocCharOffset + runRight.charLengthInDoc); 394 | if (rightRunStandaloneSegmentIndex > -1) segments.splice(rightRunStandaloneSegmentIndex, 1); 395 | merged = true; 396 | } 397 | } else if (!segmentForLeftRun && segmentForRightRun) { // Try to extend right segment with left run 398 | const potentialNewStart = runLeft.startDocCharOffset; 399 | if ((segmentForRightRun.endOffset - potentialNewStart) <= maxSegmentSize) { 400 | segmentForRightRun.startOffset = potentialNewStart; 401 | segmentForRightRun.score += runLeft.charLengthInDoc; 402 | runToSegmentMap.set(runLeft.startDocCharOffset, segmentForRightRun); 403 | const leftRunStandaloneSegmentIndex = segments.findIndex(s => s.startOffset === runLeft.startDocCharOffset && s.endOffset === runLeft.startDocCharOffset + runLeft.charLengthInDoc); 404 | if (leftRunStandaloneSegmentIndex > -1) segments.splice(leftRunStandaloneSegmentIndex, 1); 405 | merged = true; 406 | } 407 | } else if (segmentForLeftRun && segmentForRightRun) { // Both runs are in existing (different) segments, try to merge these segments 408 | const potentialNewLength = segmentForRightRun.endOffset - segmentForLeftRun.startOffset; 409 | if (potentialNewLength <= maxSegmentSize) { 410 | segmentForLeftRun.endOffset = segmentForRightRun.endOffset; 411 | segmentForLeftRun.score += segmentForRightRun.score; // Combine scores 412 | 413 | // All runs that were part of segmentForRightRun now point to segmentForLeftRun 414 | for (const [runStartOffset, seg] of runToSegmentMap.entries()) { 415 | if (seg === segmentForRightRun) { 416 | runToSegmentMap.set(runStartOffset, segmentForLeftRun); 417 | } 418 | } 419 | // Remove segmentForRightRun from segments array 420 | const rightSegmentIndex = segments.indexOf(segmentForRightRun); 421 | if (rightSegmentIndex > -1) segments.splice(rightSegmentIndex, 1); 422 | merged = true; 423 | } 424 | } 425 | // Original code also had a case for creating a new segment from two runs not yet in segments. 426 | // This is covered by the initialization of segments with individual runs, and then merging. 427 | // The provided logic for merging was: 428 | // else { /* if (!leftSeg && !rightSeg) */ 429 | // const newSegment = { start: runs[0].di, end: runs[0].di + runs[0].length + nextGap.gap + runs[1].length, score: runs[0].length + runs[1].length }; 430 | // if ( newSegment.end - newSegment.start <= maxSegmentSize ) { runSegMap[runs[0].di] = newSegment; runSegMap[runs[1].di] = newSegment; segments.push(newSegment); assigned = newSegment; } 431 | // } 432 | // This specific "else" is tricky to map directly if segments are pre-initialized. 433 | // The current merging logic tries to extend existing segments. If two runs are not in segments 434 | // and their combined length (including gap) is <= maxSegmentSize, they should form a new segment. 435 | // This is implicitly handled if they were small enough to be individual segments initially and then get merged. 436 | // The key is that `runToSegmentMap` correctly tracks which segment a run belongs to. 437 | 438 | if (merged) { 439 | DEBUG.verboseSlow && console.log('trilight: Merged gap, new segment length:', segmentForLeftRun ? segmentForLeftRun.endOffset - segmentForLeftRun.startOffset : segmentForRightRun.endOffset - segmentForRightRun.startOffset); 440 | } else { 441 | DEBUG.verboseSlow && console.log('trilight: Gap could not be merged or runs not in mappable segments.'); 442 | } 443 | } 444 | 445 | // Deduplicate segments that might have become identical after merges (e.g., if map pointed multiple runs to same segment object) 446 | const uniqueSegments = Array.from(new Set(segments.filter(s => s))); // Filter out undefined/null if any 447 | uniqueSegments.sort((a, b) => b.score - a.score); // Sort by score (descending) 448 | 449 | const textSegments = uniqueSegments.slice(0, 3).map(segment => { 450 | const snippetText = originalDocChars.slice(segment.startOffset, segment.endOffset).join(''); 451 | return { // Return in the same format as highlight() 452 | fragment: { 453 | text: internalMarkText(snippetText, query), 454 | offset: segment.startOffset 455 | } 456 | }; 457 | }); 458 | 459 | DEBUG.verboseSlow && console.log("trilight: final textSegments:", textSegments.length); 460 | 461 | if (textSegments.length === 0 && originalDocChars.length > 0) { 462 | DEBUG.verboseSlow && console.log("trilight: No segments found, returning beginning of doc."); 463 | const fallbackText = originalDocChars.slice(0, Math.min(maxSegmentSize, originalDocChars.length)).join(''); 464 | return [{ fragment: { text: internalMarkText(fallbackText, query), offset: 0 } }]; 465 | } 466 | 467 | return textSegments; 468 | } 469 | -------------------------------------------------------------------------------- /src/index.js: -------------------------------------------------------------------------------- 1 | 2 | require = require('esm')(module/*, options*/); 3 | module.exports = require('./app.js'); 4 | 5 | -------------------------------------------------------------------------------- /src/installBrowser.js: -------------------------------------------------------------------------------- 1 | import { exec } from 'child_process'; 2 | import { promisify } from 'util'; 3 | import { createWriteStream } from 'fs'; 4 | import { pipeline } from 'stream/promises'; 5 | import { readFile } from 'fs/promises'; 6 | import https from 'node:https'; 7 | 8 | // Constants 9 | const execPromise = promisify(exec); 10 | 11 | const SUPPORTED_BROWSERS = ['chrome', 'brave', 'vivaldi', 'edge', 'chromium']; 12 | const PLATFORM = process.platform; // 'win32', 'darwin', 'linux' 13 | const ARCH = process.arch; // 'x64', 'arm64', etc. 14 | 15 | // Logic 16 | // None; function is exported for use 17 | 18 | // Functions 19 | export async function installBrowser(browserName) { 20 | if (!SUPPORTED_BROWSERS.includes(browserName)) { 21 | throw new Error(`Unsupported browser: ${browserName}. Supported: ${SUPPORTED_BROWSERS.join(', ')}`); 22 | } 23 | 24 | console.log(`Installing ${browserName} on ${PLATFORM} (${ARCH})...`); 25 | 26 | await checkBrowserAvailability(browserName); 27 | const binaryPath = await installBrowserForPlatform(browserName); 28 | console.log(`${browserName} installed at: ${binaryPath}`); 29 | return binaryPath; 30 | } 31 | 32 | async function checkBrowserAvailability(browserName) { 33 | if (PLATFORM === 'linux' && ARCH === 'arm64' && browserName === 'chrome') { 34 | throw new Error('Chrome is not available for ARM64 Linux. Try Brave or Chromium instead.'); 35 | } 36 | // Add more checks for other browsers if needed (e.g., Vivaldi ARM64 stability) 37 | } 38 | 39 | async function installBrowserForPlatform(browserName) { 40 | if (PLATFORM === 'win32') { 41 | return await installOnWindows(browserName); 42 | } else if (PLATFORM === 'darwin') { 43 | return await installOnMacOS(browserName); 44 | } else if (PLATFORM === 'linux') { 45 | return await installOnLinux(browserName); 46 | } else { 47 | throw new Error(`Unsupported platform: ${PLATFORM}`); 48 | } 49 | } 50 | 51 | async function installOnWindows(browserName) { 52 | try { 53 | // Check if winget is installed 54 | try { 55 | await execPromise('winget --version'); 56 | } catch { 57 | console.log('winget not found. Installing winget...'); 58 | await execPromise('powershell -Command "irm asheroto.com/winget | iex"'); 59 | console.log('winget installed successfully.'); 60 | } 61 | 62 | if (browserName === 'chrome') { 63 | await execPromise('winget install Google.Chrome --silent --accept-package-agreements --accept-source-agreements'); 64 | return 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe'; 65 | } else if (browserName === 'brave') { 66 | await execPromise('winget install Brave.Brave --silent --accept-package-agreements --accept-source-agreements'); 67 | return 'C:\\Program Files\\BraveSoftware\\Brave-Browser\\Application\\brave.exe'; 68 | } else if (browserName === 'vivaldi') { 69 | await execPromise('winget install Vivaldi.Vivaldi --silent --accept-package-agreements --accept-source-agreements'); 70 | return 'C:\\Program Files\\Vivaldi\\Application\\vivaldi.exe'; 71 | } else if (browserName === 'edge') { 72 | await execPromise('winget install Microsoft.Edge --silent --accept-package-agreements --accept-source-agreements'); 73 | return 'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe'; 74 | } else if (browserName === 'chromium') { 75 | const url = getDownloadUrl(browserName, PLATFORM, ARCH); 76 | if (!url) throw new Error('Chromium download not supported on Windows'); 77 | const outputPath = 'C:\\Program Files\\Chromium\\chromium.exe'; 78 | await downloadBinary(url, outputPath); 79 | return outputPath; 80 | } 81 | } catch (error) { 82 | console.error(`Windows install failed: ${error.message}`); 83 | throw error; 84 | } 85 | } 86 | 87 | async function installOnMacOS(browserName) { 88 | try { 89 | // Check if brew is installed 90 | try { 91 | await execPromise('brew --version'); 92 | } catch { 93 | throw new Error('Homebrew is not installed. Please install it from https://brew.sh and try again.'); 94 | } 95 | 96 | if (browserName === 'chrome') { 97 | await execPromise('brew install --cask google-chrome'); 98 | return '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'; 99 | } else if (browserName === 'brave') { 100 | await execPromise('brew install --cask brave-browser'); 101 | return '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser'; 102 | } else if (browserName === 'vivaldi') { 103 | await execPromise('brew install --cask vivaldi'); 104 | return '/Applications/Vivaldi.app/Contents/MacOS/Vivaldi'; 105 | } else if (browserName === 'edge') { 106 | await execPromise('brew install --cask microsoft-edge'); 107 | return '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge'; 108 | } else if (browserName === 'chromium') { 109 | await execPromise('brew install --cask chromium'); 110 | return '/Applications/Chromium.app/Contents/MacOS/Chromium'; 111 | } 112 | } catch (error) { 113 | console.error(`macOS install failed: ${error.message}`); 114 | throw error; 115 | } 116 | } 117 | 118 | async function installOnLinux(browserName) { 119 | try { 120 | const distro = await getLinuxDistro(); 121 | if (distro === 'debian') { 122 | return await installOnDebian(browserName); 123 | } else if (distro === 'fedora') { 124 | return await installOnFedora(browserName); 125 | } else { 126 | throw new Error(`Unsupported Linux distribution: ${distro}`); 127 | } 128 | } catch (error) { 129 | console.error(`Linux install failed: ${error.message}`); 130 | throw error; 131 | } 132 | } 133 | 134 | async function installOnDebian(browserName) { 135 | let binaryPath = '/usr/bin/' + browserName; 136 | if (browserName === 'chrome') { 137 | await execPromise('wget -q -O - https://dl.google.com/linux/linux_signing_key.pub | sudo apt-key add -'); 138 | await execPromise(`sudo sh -c 'echo "deb [arch=${ARCH === 'arm64' ? 'arm64' : 'amd64'}] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google-chrome.list'`); 139 | await execPromise('sudo apt-get update && sudo apt-get install -y google-chrome-stable'); 140 | binaryPath = '/usr/bin/google-chrome'; 141 | } else if (browserName === 'brave') { 142 | await execPromise('sudo curl -fsSLo /usr/share/keyrings/brave-browser-archive-keyring.gpg https://brave-browser-apt-release.s3.brave.com/brave-browser-archive-keyring.gpg'); 143 | await execPromise(`echo "deb [signed-by=/usr/share/keyrings/brave-browser-archive-keyring.gpg arch=${ARCH === 'arm64' ? 'arm64' : 'amd64'}] https://brave-browser-apt-release.s3.brave.com/ stable main" | sudo tee /etc/apt/sources.list.d/brave-browser-release.list`); 144 | await execPromise('sudo apt update && sudo apt install -y brave-browser'); 145 | binaryPath = '/usr/bin/brave-browser'; 146 | } else if (browserName === 'vivaldi') { 147 | await execPromise('wget -qO- https://repo.vivaldi.com/archive/linux_signing_key.pub | sudo apt-key add -'); 148 | await execPromise(`sudo add-apt-repository "deb [arch=${ARCH === 'arm64' ? 'arm64' : 'amd64'}] https://repo.vivaldi.com/archive/deb/ stable main"`); 149 | await execPromise('sudo apt update && sudo apt install -y vivaldi-stable'); 150 | binaryPath = '/usr/bin/vivaldi'; 151 | } else if (browserName === 'edge') { 152 | await execPromise('curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg'); 153 | await execPromise('sudo mv microsoft.gpg /usr/share/keyrings/microsoft-archive-keyring.gpg'); 154 | await execPromise(`sudo sh -c 'echo "deb [arch=${ARCH === 'arm64' ? 'arm64' : 'amd64'} signed-by=/usr/share/keyrings/microsoft-archive-keyring.gpg] https://packages.microsoft.com/repos/edge stable main" > /etc/apt/sources.list.d/microsoft-edge.list'`); 155 | await execPromise('sudo apt update && sudo apt install -y microsoft-edge-stable'); 156 | binaryPath = '/usr/bin/microsoft-edge'; 157 | } else if (browserName === 'chromium') { 158 | await execPromise('sudo apt update && sudo apt install -y chromium-browser'); 159 | // Check for Snap installation 160 | try { 161 | const { stdout } = await execPromise('which chromium'); 162 | binaryPath = stdout.trim(); 163 | if (binaryPath.includes('/snap/')) { 164 | binaryPath = '/snap/bin/chromium'; 165 | } else { 166 | binaryPath = '/usr/bin/chromium-browser'; 167 | } 168 | } catch { 169 | binaryPath = '/usr/bin/chromium-browser'; 170 | } 171 | } 172 | return binaryPath; 173 | } 174 | 175 | async function installOnFedora(browserName) { 176 | let binaryPath = '/usr/bin/' + browserName; 177 | if (browserName === 'chrome') { 178 | await execPromise('sudo dnf config-manager --add-repo https://dl.google.com/linux/chrome/rpm/stable/x86_64'); 179 | await execPromise('sudo rpm --import https://dl.google.com/linux/linux_signing_key.pub'); 180 | await execPromise('sudo dnf install -y google-chrome-stable'); 181 | binaryPath = '/usr/bin/google-chrome'; 182 | } else if (browserName === 'brave') { 183 | await execPromise('sudo dnf config-manager --add-repo https://brave-browser-rpm-release.s3.brave.com/x86_64/'); 184 | await execPromise('sudo rpm --import https://brave-browser-rpm-release.s3.brave.com/brave-core.asc'); 185 | await execPromise('sudo dnf install -y brave-browser'); 186 | binaryPath = '/usr/bin/brave-browser'; 187 | } else if (browserName === 'vivaldi') { 188 | await execPromise('sudo dnf config-manager --add-repo https://repo.vivaldi.com/archive/vivaldi-fedora.repo'); 189 | await execPromise('sudo dnf install -y vivaldi-stable'); 190 | binaryPath = '/usr/bin/vivaldi'; 191 | } else if (browserName === 'edge') { 192 | await execPromise('sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc'); 193 | await execPromise('sudo dnf config-manager --add-repo https://packages.microsoft.com/yumrepos/edge'); 194 | await execPromise('sudo dnf install -y microsoft-edge-stable'); 195 | binaryPath = '/usr/bin/microsoft-edge'; 196 | } else if (browserName === 'chromium') { 197 | await execPromise('sudo dnf install -y chromium'); 198 | binaryPath = '/usr/bin/chromium-browser'; 199 | } 200 | return binaryPath; 201 | } 202 | 203 | async function getLinuxDistro() { 204 | try { 205 | const osRelease = await readFile('/etc/os-release', 'utf8'); 206 | const lines = osRelease.split('\n'); 207 | const releaseInfo = {}; 208 | for (const line of lines) { 209 | const [key, value] = line.split('='); 210 | if (key && value) { 211 | releaseInfo[key] = value.replace(/"/g, ''); 212 | } 213 | } 214 | 215 | if (releaseInfo.ID === 'fedora' || releaseInfo.ID_LIKE?.includes('fedora')) { 216 | return 'fedora'; 217 | } else if (releaseInfo.ID === 'debian' || releaseInfo.ID === 'ubuntu' || releaseInfo.ID_LIKE?.includes('debian')) { 218 | return 'debian'; 219 | } else { 220 | return releaseInfo.ID || 'unknown'; 221 | } 222 | } catch (error) { 223 | console.error(`Failed to read /etc/os-release: ${error.message}`); 224 | return 'unknown'; 225 | } 226 | } 227 | 228 | // Helper functions 229 | async function downloadBinary(url, outputPath) { 230 | const response = await fetch(url, { 231 | agent: url.startsWith('https:') ? new https.Agent({ keepAlive: true }) : undefined 232 | }); 233 | if (!response.ok) { 234 | throw new Error(`Failed to download ${url}: ${response.statusText}`); 235 | } 236 | await pipeline(response.body, createWriteStream(outputPath)); 237 | } 238 | 239 | function getDownloadUrl(browserName, platform, arch) { 240 | const urls = { 241 | chrome: { 242 | win32: { x64: 'https://dl.google.com/chrome/install/ChromeSetup.exe', arm64: 'https://dl.google.com/chrome/install/ChromeSetup.exe' }, 243 | darwin: { x64: 'https://dl.google.com/chrome/mac/stable/GGRO/googlechrome.dmg', arm64: 'https://dl.google.com/chrome/mac/arm64/googlechrome.dmg' }, 244 | linux: { x64: 'https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb', arm64: null } 245 | }, 246 | brave: { 247 | win32: { x64: 'https://referrals.brave.com/latest/BraveBrowserSetup.exe', arm64: 'https://referrals.brave.com/latest/BraveBrowserSetup.exe' }, 248 | darwin: { x64: 'https://laptop-updates.brave.com/latest/osx/Brave-Browser.dmg', arm64: 'https://laptop-updates.brave.com/latest/osx-arm64/Brave-Browser.dmg' }, 249 | linux: { x64: 'https://laptop-updates.brave.com/latest/linux64', arm64: 'https://laptop-updates.brave.com/latest/linux-arm64' } 250 | }, 251 | vivaldi: { 252 | win32: { x64: 'https://downloads.vivaldi.com/stable/Vivaldi_Setup.exe', arm64: 'https://downloads.vivaldi.com/stable/Vivaldi_Setup.exe' }, 253 | darwin: { x64: 'https://downloads.vivaldi.com/stable/Vivaldi.dmg', arm64: 'https://downloads.vivaldi.com/stable/Vivaldi.dmg' }, 254 | linux: { x64: 'https://downloads.vivaldi.com/stable/vivaldi-stable_amd64.deb', arm64: 'https://downloads.vivaldi.com/stable/vivaldi-stable_arm64.deb' } 255 | }, 256 | edge: { 257 | win32: { x64: 'https://go.microsoft.com/fwlink/?linkid=2069148', arm64: 'https://go.microsoft.com/fwlink/?linkid=2069148' }, 258 | darwin: { x64: 'https://go.microsoft.com/fwlink/?linkid=2069324', arm64: 'https://go.microsoft.com/fwlink/?linkid=2069324' }, 259 | linux: { x64: 'https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-stable/microsoft-edge-stable_latest_amd64.deb', arm64: 'https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-stable/microsoft-edge-stable_latest_arm64.deb' } 260 | }, 261 | chromium: { 262 | win32: { x64: 'https://download-chromium.appspot.com/dl/Win_x64?type=snapshots', arm64: 'https://download-chromium.appspot.com/dl/Win_arm64?type=snapshots' }, 263 | darwin: { x64: 'https://download-chromium.appspot.com/dl/Mac?type=snapshots', arm64: 'https://download-chromium.appspot.com/dl/Mac_Arm?type=snapshots' }, 264 | linux: { x64: 'https://download-chromium.appspot.com/dl/Linux_x64?type=snapshots', arm64: 'https://download-chromium.appspot.com/dl/Linux_Arm?type=snapshots' } 265 | } 266 | }; 267 | return urls[browserName]?.[platform]?.[arch] || null; 268 | } 269 | -------------------------------------------------------------------------------- /src/launcher.js: -------------------------------------------------------------------------------- 1 | // launcher.js 2 | import { spawn } from 'child_process'; 3 | import { DEBUG } from './common.js'; // Assuming common.js is accessible 4 | 5 | /** 6 | * Launches a browser executable with specified arguments. 7 | * @param {string} executablePath - Absolute path to the browser executable. 8 | * @param {string[]} browserArgs - Array of arguments to pass to the browser. 9 | * @param {object} [options={}] - Options for child_process.spawn. 10 | * @returns {import('child_process').ChildProcess | null} The spawned browser process or null on error. 11 | */ 12 | function launch(executablePath, browserArgs = [], options = {}) { 13 | if (!executablePath) { 14 | console.error('launcher.js: Executable path is required.'); 15 | return null; 16 | } 17 | 18 | DEBUG.verbose && console.log(`launcher.js: Spawning '${executablePath}' with args:`, browserArgs); 19 | 20 | try { 21 | const defaultSpawnOptions = { 22 | detached: process.platform !== 'win32', // Detach by default on non-Windows for independent exit 23 | stdio: ['ignore', 'pipe', 'pipe'], 24 | }; 25 | 26 | const spawnOptions = { ...defaultSpawnOptions, ...options }; 27 | 28 | const browserProcess = spawn(executablePath, browserArgs, spawnOptions); 29 | 30 | browserProcess.on('error', (err) => { 31 | console.error(`launcher.js: Failed to start browser process for ${executablePath}: ${err.message}`); 32 | }); 33 | 34 | if (DEBUG.verboseBrowser) { 35 | const browserName = executablePath.split(/[/\\]/).pop(); 36 | browserProcess.stdout.on('data', (data) => { 37 | DEBUG.verbose && process.stdout.write(`[BROWSER STDOUT - ${browserName}]: ${data}`); 38 | }); 39 | browserProcess.stderr.on('data', (data) => { 40 | DEBUG.verbose && process.stderr.write(`[BROWSER STDERR - ${browserName}]: ${data}`); 41 | }); 42 | } 43 | 44 | // If detached, unref() allows the parent to exit independently. 45 | // This is often desired so closing the terminal doesn't kill the browser launched by the script. 46 | if (spawnOptions.detached) { 47 | browserProcess.unref(); 48 | } 49 | 50 | return browserProcess; 51 | } catch (error) { 52 | console.error(`launcher.js: Error spawning browser ${executablePath}: ${error.message}`); 53 | DEBUG.verbose && console.error(error); 54 | return null; 55 | } 56 | } 57 | 58 | export default { 59 | launch, 60 | }; 61 | -------------------------------------------------------------------------------- /src/protocol.js: -------------------------------------------------------------------------------- 1 | import Ws from 'ws'; 2 | import {sleep, untilTrue, SHOW_FETCH, DEBUG, ERROR_CODE_SAFE_TO_IGNORE} from './common.js'; 3 | 4 | const ROOT_SESSION = "browser"; 5 | const MESSAGES = new Map(); 6 | 7 | const RANDOM_LOCAL = () => [ 8 | '127.0.0.1', 9 | '[::1]', 10 | 'localhost', 11 | '127.0.0.1', 12 | '[::1]', 13 | 'localhost' 14 | ][Math.floor(Math.random()*6)]; 15 | 16 | export async function connect({port:port = 9222} = {}) { 17 | let webSocketDebuggerUrl, socket; 18 | let url; 19 | try { 20 | await untilTrue(async () => { 21 | let result = false; 22 | try { 23 | url = `http://${RANDOM_LOCAL()}:${port}/json/version`; 24 | DEBUG.verbose && console.log(`Trying browser at ${url}...`, url); 25 | const {webSocketDebuggerUrl} = await Promise.race([ 26 | fetch(url).then(r => r.json()), 27 | (async () => { 28 | await sleep(2500); 29 | throw new Error(`Connect took too long.`) 30 | })(), 31 | ]); 32 | if ( webSocketDebuggerUrl ) { 33 | result = true; 34 | } 35 | } catch(e) { 36 | DEBUG.verbose && console.error('Error while checking browser', e); 37 | } finally { 38 | return result; 39 | } 40 | }); 41 | ({webSocketDebuggerUrl} = await fetch(url).then(r => r.json())); 42 | let isOpen = false; 43 | socket = new Ws(webSocketDebuggerUrl); 44 | socket.on('open', () => { isOpen = true }); 45 | await untilTrue(() => isOpen); 46 | DEBUG.verbose && console.log(`Connected to browser`); 47 | } catch(e) { 48 | console.log("Error communicating with browser", e); 49 | process.exit(1); 50 | } 51 | 52 | const Resolvers = {}; 53 | const Handlers = {}; 54 | socket.on('message', handle); 55 | let id = 0; 56 | 57 | let resolve, reject; 58 | const promise = new Promise((res, rej) => (resolve = res, reject = rej)); 59 | 60 | switch(socket.readyState) { 61 | case Ws.CONNECTING: 62 | socket.on('open', () => resolve()); break; 63 | case Ws.OPEN: 64 | resolve(); break; 65 | case Ws.CLOSED: 66 | case Ws.CLOSING: 67 | reject(); break; 68 | } 69 | 70 | await promise; 71 | 72 | return { 73 | send, 74 | on, ons, ona, 75 | close 76 | }; 77 | 78 | async function send(method, params = {}, sessionId) { 79 | const message = { 80 | method, params, sessionId, 81 | id: ++id 82 | }; 83 | if ( ! sessionId ) { 84 | delete message[sessionId]; 85 | } 86 | const key = `${sessionId||ROOT_SESSION}:${message.id}`; 87 | let resolve; 88 | const promise = new Promise(res => resolve = res); 89 | Resolvers[key] = resolve; 90 | const outGoing = JSON.stringify(message); 91 | MESSAGES.set(key, outGoing); 92 | socket.send(outGoing); 93 | DEBUG.verboseSlow && (SHOW_FETCH || !method.startsWith('Fetch')) && console.log("Sent", message); 94 | return promise; 95 | } 96 | 97 | async function handle(message) { 98 | if ( typeof message !== "string" ) { 99 | try { 100 | message += ''; 101 | } catch(e) { 102 | message = message.toString(); 103 | } 104 | } 105 | const stringMessage = message; 106 | message = JSON.parse(message); 107 | if ( message.error ) { 108 | const showError = DEBUG.protocol || !ERROR_CODE_SAFE_TO_IGNORE.has(message.error.code); 109 | if ( showError ) { 110 | DEBUG.protocol && console.warn(message); 111 | } 112 | } 113 | const {sessionId} = message; 114 | const {method} = message; 115 | const {id, result} = message; 116 | 117 | if ( id ) { 118 | const key = `${sessionId||ROOT_SESSION}:${id}`; 119 | const resolve = Resolvers[key]; 120 | if ( ! resolve ) { 121 | DEBUG.protocol && console.warn(`No resolver for key`, key, stringMessage.slice(0,140)); 122 | } else { 123 | Resolvers[key] = undefined; 124 | try { 125 | await resolve(result); 126 | } catch(e) { 127 | console.warn(`Resolver failed`, e, key, stringMessage.slice(0,140), resolve); 128 | } 129 | } 130 | if ( DEBUG ) { 131 | if ( message.error ) { 132 | const showError = DEBUG || !ERROR_CODE_SAFE_TO_IGNORE.has(message.error.code); 133 | if ( showError ) { 134 | const originalMessage = MESSAGES.get(key); 135 | DEBUG.protocol && console.warn({originalMessage}); 136 | } 137 | } 138 | } 139 | MESSAGES.delete(key); 140 | } else if ( method ) { 141 | const listeners = Handlers[method]; 142 | if ( Array.isArray(listeners) ) { 143 | for( const func of listeners ) { 144 | try { 145 | func({message, sessionId}); 146 | } catch(e) { 147 | console.warn(`Listener failed`, method, e, func.toString().slice(0,140), stringMessage.slice(0,140)); 148 | } 149 | } 150 | } 151 | } else { 152 | console.warn(`Unknown message on socket`, message); 153 | } 154 | } 155 | 156 | function on(method, handler) { 157 | let listeners = Handlers[method]; 158 | if ( ! listeners ) { 159 | Handlers[method] = listeners = []; 160 | } 161 | listeners.push(wrap(handler)); 162 | } 163 | 164 | function ons(method, handler) { 165 | let listeners = Handlers[method]; 166 | if ( ! listeners ) { 167 | Handlers[method] = listeners = []; 168 | } 169 | listeners.push(handler); 170 | } 171 | 172 | function ona(method, handler, sessionId) { 173 | let listeners = Handlers[method]; 174 | if ( ! listeners ) { 175 | Handlers[method] = listeners = []; 176 | } 177 | listeners.push(({message}) => { 178 | if ( message.sessionId === sessionId ) { 179 | handler(message.params); 180 | } else { 181 | console.log(`No such`, {method, handler, sessionId, message}); 182 | } 183 | }); 184 | } 185 | 186 | function close() { 187 | socket.close(); 188 | } 189 | 190 | function wrap(fn) { 191 | return ({message}) => fn(message.params) 192 | } 193 | } 194 | -------------------------------------------------------------------------------- /src/root.cjs: -------------------------------------------------------------------------------- 1 | const path = require('path'); 2 | const url = require('url'); 3 | 4 | const file = __filename; 5 | const dir = path.dirname(file); 6 | const APP_ROOT = dir; 7 | 8 | //console.log({APP_ROOT}); 9 | 10 | module.exports = { 11 | APP_ROOT, 12 | dir, 13 | file 14 | } 15 | 16 | -------------------------------------------------------------------------------- /src/root.js: -------------------------------------------------------------------------------- 1 | import path from 'path'; 2 | import url from 'url'; 3 | 4 | let mod; 5 | let esm = false; 6 | 7 | try { 8 | const [a, b] = [__dirname, __filename]; 9 | } catch(e) { 10 | esm = true; 11 | } 12 | 13 | if ( ! esm ) { 14 | mod = require('./root.cjs'); 15 | } else { 16 | const file = url.fileURLToPath(import.meta.url); 17 | const dir = path.dirname(file); 18 | mod = { 19 | dir, 20 | file, 21 | APP_ROOT: dir 22 | }; 23 | } 24 | 25 | //console.log({root}); 26 | 27 | export const root = mod; 28 | 29 | -------------------------------------------------------------------------------- /stampers/macos-new.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # macOS Single Executable Application (SEA) Stamper, Signer, and Conditional Notarizer for DownloadNet 4 | 5 | set -e 6 | # set -x 7 | 8 | # --- Configuration & Variables --- 9 | DEFAULT_NODE_VERSION="22" 10 | MACOS_APP_BUNDLE_ID="com.DOSAYGO.DownloadNet" # Your registered Bundle ID 11 | ENTITLEMENTS_FILE_PATH="scripts/downloadnet-entitlements.xml" 12 | NOTARIZE_SCRIPT_PATH="./stampers/notarize_macos.sh" # Path to your notarization script 13 | 14 | # --- NEW: Check for Notarization Environment Variables --- 15 | CAN_ATTEMPT_NOTARIZATION=true 16 | echo "INFO: Checking for notarization prerequisites..." >&2 17 | if [ -z "$API_KEY_ID" ]; then 18 | echo "WARNING: Environment variable API_KEY_ID is not set. Notarization will be skipped." >&2 19 | CAN_ATTEMPT_NOTARIZATION=false 20 | fi 21 | if [ -z "$API_KEY_ISSUER_ID" ]; then 22 | echo "WARNING: Environment variable API_KEY_ISSUER_ID is not set. Notarization will be skipped." >&2 23 | CAN_ATTEMPT_NOTARIZATION=false 24 | fi 25 | if [ -z "$API_KEY_P8_PATH" ]; then 26 | echo "WARNING: Environment variable API_KEY_P8_PATH is not set. Notarization will be skipped." >&2 27 | CAN_ATTEMPT_NOTARIZATION=false 28 | elif [ ! -f "$API_KEY_P8_PATH" ]; then # Also check if the path points to an actual file 29 | echo "WARNING: API Key .p8 file not found at path specified by API_KEY_P8_PATH: '$API_KEY_P8_PATH'. Notarization will be skipped." >&2 30 | CAN_ATTEMPT_NOTARIZATION=false 31 | fi 32 | 33 | if [ "$CAN_ATTEMPT_NOTARIZATION" = true ]; then 34 | echo "INFO: Notarization environment variables appear to be set." >&2 35 | else 36 | echo "INFO: One or more required environment variables for notarization are missing or invalid." >&2 37 | echo " To enable notarization, please set: API_KEY_ID, API_KEY_ISSUER_ID, API_KEY_P8_PATH." >&2 38 | fi 39 | echo "-----------------------------------------------------" >&2 40 | 41 | 42 | # --- Helper Functions (source_nvm, find_developer_id_identities - keep as is) --- 43 | source_nvm() { 44 | if [ -n "$NVM_DIR" ] && [ -s "$NVM_DIR/nvm.sh" ]; then source "$NVM_DIR/nvm.sh"; 45 | elif [ -s "$HOME/.nvm/nvm.sh" ]; then source "$HOME/.nvm/nvm.sh"; fi 46 | if ! command -v nvm &> /dev/null; then echo "ERROR: NVM command not found." >&2; return 1; fi 47 | return 0 48 | } 49 | 50 | find_developer_id_identities() { 51 | local identities_output developer_id_identities=() identity_line 52 | echo "INFO: Searching for valid 'Developer ID Application' signing identities in keychain..." >&2 53 | identities_output=$(security find-identity -v -p codesigning | awk '{$1=$1;print}') 54 | while IFS= read -r identity_line; do 55 | if [[ "$identity_line" == *"Developer ID Application:"* ]]; then 56 | local name; name=$(echo "$identity_line" | awk -F '"' '{print $2}') 57 | if [ -n "$name" ]; then developer_id_identities+=("$name"); fi 58 | fi 59 | done <<< "$identities_output"; for id_name in "${developer_id_identities[@]}"; do echo "$id_name"; done 60 | } 61 | # --- End Helper Functions --- 62 | 63 | if [ "$#" -ne 3 ]; then 64 | echo "Usage: $0