1324 lines
47 KiB
TypeScript
1324 lines
47 KiB
TypeScript
import browser from 'webextension-polyfill'
|
|
import { isLikelyDownloadResponse, normalizeUrl } from '../lib/downloadIntent'
|
|
import { nativeAddUri, nativeFocus } from '../lib/nativeHost'
|
|
import { getSettings } from '../lib/settings'
|
|
import { upsertHistory } from '../lib/history'
|
|
import { makeMediaCandidate, mediaFingerprint, shouldCaptureMediaResponse } from '../lib/mediaCapture'
|
|
import { clearMediaCandidates, listMediaCandidates, upsertMediaCandidate } from '../lib/mediaStore'
|
|
import { deleteClip, getClipById, importClips, insertClip, listClips, listClipsByUrl, updateClipResolveStatus } from '../lib/clipStore'
|
|
import { normalizePageUrl, normalizeQuote, type ClipItem } from '../lib/clipTypes'
|
|
|
|
const REQUEST_TTL_MS = 8000
|
|
const TRANSFER_DEDUPE_TTL_MS = 7000
|
|
const contextMenuId = 'gomdown-helper-download-context-menu-option'
|
|
const OBSIDIAN_LAST_VAULT_KEY = 'obsidianLastVault'
|
|
|
|
const pendingRequests = new Map<string, any>()
|
|
const capturedUrls = new Map<string, number>()
|
|
const capturedFingerprints = new Map<string, number>()
|
|
const recentTransferFingerprints = new Map<string, number>()
|
|
const handledRequestIds = new Map<string, number>()
|
|
const capturedTabIds = new Map<number, number>()
|
|
const recentMediaFingerprints = new Map<string, number>()
|
|
let webRequestHooked = false
|
|
let downloadHooked = false
|
|
let contextMenuHooked = false
|
|
let contextMenuUpdateInFlight: Promise<void> | null = null
|
|
|
|
const MP4_PREFERRED_FORMAT = 'bv*[ext=mp4]+ba[ext=m4a]/b[ext=mp4]/best'
|
|
const SITE_STRATEGIES: Array<{
|
|
hosts: string[]
|
|
extractor: 'yt-dlp' | 'aria2'
|
|
format?: string
|
|
}> = [
|
|
{
|
|
hosts: ['youtube.com', 'www.youtube.com', 'm.youtube.com', 'youtu.be'],
|
|
extractor: 'yt-dlp',
|
|
format: MP4_PREFERRED_FORMAT,
|
|
},
|
|
]
|
|
|
|
function clipLog(...args: unknown[]): void {
|
|
console.log('[gomdown-helper][clip][bg]', ...args)
|
|
}
|
|
|
|
function urlFingerprint(raw: string): string {
|
|
try {
|
|
const u = new URL(raw)
|
|
const path = (u.pathname || '/').replace(/\/+$/, '') || '/'
|
|
return `${u.protocol}//${u.host}${path}`.toLowerCase()
|
|
} catch {
|
|
return String(raw || '').toLowerCase()
|
|
}
|
|
}
|
|
|
|
function pruneMap<K>(map: Map<K, number>): void {
|
|
const now = Date.now()
|
|
for (const [key, expiresAt] of map.entries()) {
|
|
if (expiresAt <= now) map.delete(key)
|
|
}
|
|
}
|
|
|
|
function rememberCapturedUrl(url: string): void {
|
|
const expiresAt = Date.now() + REQUEST_TTL_MS
|
|
capturedUrls.set(normalizeUrl(url), expiresAt)
|
|
capturedFingerprints.set(urlFingerprint(url), expiresAt)
|
|
}
|
|
|
|
function rememberCapturedTab(tabId?: number): void {
|
|
if (!Number.isInteger(tabId) || (tabId ?? -1) < 0) return
|
|
capturedTabIds.set(tabId as number, Date.now() + REQUEST_TTL_MS)
|
|
}
|
|
|
|
function wasCapturedUrl(url: string): boolean {
|
|
pruneMap(capturedUrls)
|
|
pruneMap(capturedFingerprints)
|
|
const normalized = normalizeUrl(url)
|
|
return capturedUrls.has(normalized) || capturedFingerprints.has(urlFingerprint(url))
|
|
}
|
|
|
|
function wasCapturedTab(tabId?: number): boolean {
|
|
pruneMap(capturedTabIds)
|
|
if (!Number.isInteger(tabId) || (tabId ?? -1) < 0) return false
|
|
return capturedTabIds.has(tabId as number)
|
|
}
|
|
|
|
function shouldSuppressDuplicateTransfer(url: string): boolean {
|
|
pruneMap(recentTransferFingerprints)
|
|
return recentTransferFingerprints.has(urlFingerprint(url))
|
|
}
|
|
|
|
function rememberRecentTransfer(url: string): void {
|
|
recentTransferFingerprints.set(urlFingerprint(url), Date.now() + TRANSFER_DEDUPE_TTL_MS)
|
|
}
|
|
|
|
function wasRequestHandled(requestId?: string): boolean {
|
|
pruneMap(handledRequestIds)
|
|
return !!requestId && handledRequestIds.has(requestId)
|
|
}
|
|
|
|
function markRequestHandled(requestId?: string): void {
|
|
if (!requestId) return
|
|
handledRequestIds.set(requestId, Date.now() + REQUEST_TTL_MS)
|
|
}
|
|
|
|
function shouldSuppressDuplicateMedia(url: string): boolean {
|
|
pruneMap(recentMediaFingerprints)
|
|
const fp = mediaFingerprint(url)
|
|
return recentMediaFingerprints.has(fp)
|
|
}
|
|
|
|
function rememberMediaFingerprint(url: string): void {
|
|
recentMediaFingerprints.set(mediaFingerprint(url), Date.now() + REQUEST_TTL_MS)
|
|
}
|
|
|
|
async function requestGdownFocus(): Promise<void> {
|
|
try {
|
|
await nativeFocus()
|
|
} catch {
|
|
// ignored
|
|
}
|
|
}
|
|
|
|
async function notify(message: string): Promise<void> {
|
|
await browser.notifications
|
|
.create(`gomdown-notice-${Date.now()}`, {
|
|
type: 'basic',
|
|
iconUrl: '/images/icon-large.png',
|
|
title: 'Gomdown Helper',
|
|
message,
|
|
})
|
|
.catch(() => null)
|
|
}
|
|
|
|
async function transferUrlToGdown(
|
|
url: string,
|
|
referer = '',
|
|
extractor?: 'yt-dlp' | 'aria2',
|
|
format?: string,
|
|
out?: string,
|
|
extra?: { cookie?: string; userAgent?: string; authorization?: string; proxy?: string }
|
|
): Promise<{ ok: boolean; error?: string }> {
|
|
if (shouldSuppressDuplicateTransfer(url)) {
|
|
return { ok: false, error: 'duplicate transfer suppressed' }
|
|
}
|
|
|
|
const settings = await getSettings()
|
|
if (!settings.extensionStatus) return { ok: false, error: 'extension disabled' }
|
|
if (!settings.motrixAPIkey) return { ok: false, error: 'motrixAPIkey is not set' }
|
|
|
|
try {
|
|
const nativeResult = await nativeAddUri({
|
|
url,
|
|
rpcPort: settings.motrixPort,
|
|
rpcSecret: settings.motrixAPIkey,
|
|
referer,
|
|
split: 64,
|
|
out: out?.trim() || undefined,
|
|
cookie: extra?.cookie?.trim() || undefined,
|
|
userAgent: extra?.userAgent?.trim() || undefined,
|
|
authorization: extra?.authorization?.trim() || undefined,
|
|
proxy: extra?.proxy?.trim() || undefined,
|
|
extractor: extractor === 'yt-dlp' ? 'yt-dlp' : undefined,
|
|
format: extractor === 'yt-dlp' ? format || MP4_PREFERRED_FORMAT : undefined,
|
|
})
|
|
|
|
if (!nativeResult?.ok) {
|
|
return { ok: false, error: nativeResult?.error || 'native host addUri failed' }
|
|
}
|
|
|
|
if (settings.activateAppOnDownload) {
|
|
await requestGdownFocus()
|
|
}
|
|
rememberRecentTransfer(url)
|
|
const gid = String(nativeResult?.gid || nativeResult?.requestId || `pending-${Date.now()}`)
|
|
const pathname = (() => {
|
|
try {
|
|
return new URL(url).pathname
|
|
} catch {
|
|
return ''
|
|
}
|
|
})()
|
|
const guessedName = pathname.split('/').filter(Boolean).pop() || url
|
|
await upsertHistory({
|
|
gid,
|
|
downloader: 'native',
|
|
startTime: new Date().toISOString(),
|
|
icon: '/images/32.png',
|
|
name: decodeURIComponent(guessedName),
|
|
path: null,
|
|
status: nativeResult?.pending ? 'queued' : 'downloading',
|
|
size: 0,
|
|
downloaded: 0,
|
|
})
|
|
|
|
if (settings.enableNotifications) {
|
|
await browser.notifications.create(`gomdown-transfer-${Date.now()}`, {
|
|
type: 'basic',
|
|
iconUrl: '/images/icon-large.png',
|
|
title: 'Gomdown Helper',
|
|
message: 'Download sent to gdown',
|
|
})
|
|
}
|
|
|
|
return { ok: true }
|
|
} catch (error) {
|
|
return { ok: false, error: String(error) }
|
|
}
|
|
}
|
|
|
|
function hostOf(raw: string): string {
|
|
try {
|
|
return new URL(raw).hostname.toLowerCase()
|
|
} catch {
|
|
return ''
|
|
}
|
|
}
|
|
|
|
function resolveStrategy(
|
|
url: string,
|
|
referer = '',
|
|
kind = ''
|
|
): { extractor: 'yt-dlp' | 'aria2'; format?: string } {
|
|
const candidates = [hostOf(url), hostOf(referer)].filter(Boolean)
|
|
for (const rule of SITE_STRATEGIES) {
|
|
if (candidates.some((host) => rule.hosts.includes(host))) {
|
|
return { extractor: rule.extractor, format: rule.format }
|
|
}
|
|
}
|
|
|
|
const mediaKind = kind.toLowerCase()
|
|
if (mediaKind === 'm3u8' || mediaKind === 'm3u' || mediaKind === 'hls') {
|
|
return { extractor: 'yt-dlp', format: 'best' }
|
|
}
|
|
if (mediaKind === 'mp4') {
|
|
return { extractor: 'aria2' }
|
|
}
|
|
return { extractor: 'aria2' }
|
|
}
|
|
|
|
function getHeaderFromRequestHeaders(headers: any[], name: string): string {
|
|
const lower = name.toLowerCase()
|
|
const found = headers.find((item: any) => String(item?.name || '').toLowerCase() === lower)
|
|
return String(found?.value || '').trim()
|
|
}
|
|
|
|
async function shouldCaptureRequest(details: any): Promise<boolean> {
|
|
if (details.type !== 'main_frame') return false
|
|
if ((details.method || '').toUpperCase() !== 'GET') return false
|
|
if (typeof details.statusCode === 'number' && (details.statusCode < 200 || details.statusCode > 299)) return false
|
|
|
|
const settings = await getSettings()
|
|
if (!settings.extensionStatus || !settings.motrixAPIkey) return false
|
|
const contentLengthRaw = String(
|
|
Array.isArray(details?.responseHeaders)
|
|
? details.responseHeaders.find((h: any) => String(h?.name || '').toLowerCase() === 'content-length')?.value || ''
|
|
: ''
|
|
)
|
|
const contentLength = Number(contentLengthRaw || 0)
|
|
if (settings.minFileSize > 0 && contentLength > 0 && contentLength < settings.minFileSize * 1024 * 1024) {
|
|
return false
|
|
}
|
|
return isLikelyDownloadResponse(details)
|
|
}
|
|
|
|
async function interceptByWebRequest(details: any): Promise<void> {
|
|
if (wasRequestHandled(details.requestId)) return
|
|
|
|
const accepted = await shouldCaptureRequest(details)
|
|
if (!accepted) return
|
|
|
|
const req = pendingRequests.get(details.requestId)
|
|
const referer = String(req?.documentUrl || req?.originUrl || req?.initiator || req?.url || '')
|
|
const sent = await transferUrlToGdown(details.url, referer)
|
|
if (!sent.ok) return
|
|
|
|
markRequestHandled(details.requestId)
|
|
rememberCapturedUrl(details.url)
|
|
rememberCapturedTab(details.tabId)
|
|
}
|
|
|
|
async function interceptMediaByWebRequest(details: any): Promise<void> {
|
|
if (!shouldCaptureMediaResponse(details)) return
|
|
const settings = await getSettings()
|
|
if (!settings.extensionStatus) return
|
|
if (shouldSuppressDuplicateMedia(details.url)) return
|
|
|
|
const req = pendingRequests.get(details.requestId)
|
|
const referer = String(req?.documentUrl || req?.originUrl || req?.initiator || req?.url || '')
|
|
const requestHeaders = Array.isArray(req?.requestHeaders) ? req.requestHeaders : []
|
|
const cookie = getHeaderFromRequestHeaders(requestHeaders, 'cookie')
|
|
const userAgent = getHeaderFromRequestHeaders(requestHeaders, 'user-agent')
|
|
const candidate = makeMediaCandidate(details, referer)
|
|
let pageTitle = ''
|
|
if (candidate.tabId >= 0) {
|
|
const tab = await browser.tabs.get(candidate.tabId).catch(() => null)
|
|
pageTitle = String(tab?.title || '').trim()
|
|
}
|
|
const suggestedOut = suggestMediaOut(candidate.url, candidate.kind, pageTitle)
|
|
const enriched = {
|
|
...candidate,
|
|
pageTitle: pageTitle || undefined,
|
|
cookie: cookie || undefined,
|
|
userAgent: userAgent || undefined,
|
|
suggestedOut: suggestedOut || undefined,
|
|
}
|
|
await upsertMediaCandidate(enriched, mediaFingerprint(enriched.url))
|
|
rememberMediaFingerprint(enriched.url)
|
|
if (enriched.tabId >= 0) {
|
|
await browser.tabs
|
|
.sendMessage(enriched.tabId, {
|
|
type: 'media:captured',
|
|
kind: enriched.kind,
|
|
url: enriched.url,
|
|
suggestedOut: enriched.suggestedOut || '',
|
|
})
|
|
.catch(() => null)
|
|
}
|
|
}
|
|
|
|
function sanitizeOut(value: string): string {
|
|
let next = value
|
|
.trim()
|
|
.replace(/[\\/:*?"<>|]/g, '_')
|
|
.replace(/\s+/g, ' ')
|
|
.replace(/^\.+/, '')
|
|
.replace(/\.+$/, '')
|
|
if (next.length > 180) next = next.slice(0, 180).trim()
|
|
return next
|
|
}
|
|
|
|
function extFromUrl(url: string): string {
|
|
try {
|
|
const path = new URL(url).pathname.toLowerCase()
|
|
const match = path.match(/\.([a-z0-9]{2,6})(?:$|[?#])/)
|
|
return match?.[1] || ''
|
|
} catch {
|
|
return ''
|
|
}
|
|
}
|
|
|
|
function suggestMediaOut(url: string, kind: string, pageTitle: string): string {
|
|
const title = sanitizeOut(pageTitle || '')
|
|
const ext = extFromUrl(url)
|
|
const baseExt = ext || (kind === 'mp4' ? 'mp4' : kind === 'm3u8' || kind === 'm3u' || kind === 'hls' ? 'mp4' : '')
|
|
if (!title) return ''
|
|
if (!baseExt) return title
|
|
if (title.toLowerCase().endsWith(`.${baseExt}`)) return title
|
|
return `${title}.${baseExt}`
|
|
}
|
|
|
|
async function applyShelfVisibility(): Promise<void> {
|
|
const downloadsApi = browser.downloads as any
|
|
if (!downloadsApi.setShelfEnabled) return
|
|
const settings = await getSettings()
|
|
if (!settings.extensionStatus) return
|
|
const enabled = settings.useNativeHost ? false : !settings.hideChromeBar
|
|
await downloadsApi.setShelfEnabled(enabled)
|
|
}
|
|
|
|
function setupDownloadCancelHook(): void {
|
|
if (downloadHooked) return
|
|
downloadHooked = true
|
|
browser.downloads.onCreated.addListener(async (downloadItem) => {
|
|
await applyShelfVisibility()
|
|
const download = downloadItem as any
|
|
const target = download.finalUrl || download.url || ''
|
|
if (!wasCapturedUrl(target) && !wasCapturedTab(download.tabId)) return
|
|
|
|
await browser.downloads.cancel(downloadItem.id).catch(() => null)
|
|
await browser.downloads.erase({ id: downloadItem.id }).catch(() => null)
|
|
await browser.downloads.removeFile(downloadItem.id).catch(() => null)
|
|
})
|
|
}
|
|
|
|
function setupWebRequestInterceptor(): void {
|
|
if (webRequestHooked) return
|
|
webRequestHooked = true
|
|
browser.webRequest.onSendHeaders.addListener(
|
|
(details) => {
|
|
pendingRequests.set(details.requestId, details as any)
|
|
},
|
|
{ urls: ['<all_urls>'] },
|
|
['requestHeaders', 'extraHeaders']
|
|
)
|
|
|
|
browser.webRequest.onErrorOccurred.addListener(
|
|
(details) => {
|
|
pendingRequests.delete(details.requestId)
|
|
handledRequestIds.delete(String(details.requestId))
|
|
},
|
|
{ urls: ['<all_urls>'] }
|
|
)
|
|
|
|
browser.webRequest.onCompleted.addListener(
|
|
(details) => {
|
|
pendingRequests.delete(details.requestId)
|
|
handledRequestIds.delete(String(details.requestId))
|
|
},
|
|
{ urls: ['<all_urls>'] }
|
|
)
|
|
|
|
browser.webRequest.onHeadersReceived.addListener(
|
|
(details) => {
|
|
void interceptByWebRequest(details)
|
|
void interceptMediaByWebRequest(details)
|
|
},
|
|
{ urls: ['<all_urls>'] },
|
|
['responseHeaders']
|
|
)
|
|
}
|
|
|
|
async function handleContextMenuClick(data: any, tab?: any): Promise<void> {
|
|
console.log('[gomdown-helper] context menu clicked', {
|
|
menuItemId: data?.menuItemId,
|
|
linkUrl: data?.linkUrl,
|
|
srcUrl: data?.srcUrl,
|
|
frameUrl: data?.frameUrl,
|
|
pageUrl: data?.pageUrl,
|
|
tabUrl: tab?.url,
|
|
})
|
|
const clickedId = data?.menuItemId
|
|
if (clickedId != null && String(clickedId) !== contextMenuId) return
|
|
|
|
const linkUrl = String(data?.linkUrl || data?.srcUrl || '').trim()
|
|
const pageUrl = String(data?.frameUrl || data?.pageUrl || tab?.url || '').trim()
|
|
const targetUrl = linkUrl || pageUrl
|
|
|
|
const url = String(targetUrl || '').trim()
|
|
if (!url || /^(about:|chrome:|chrome-extension:|edge:|brave:)/i.test(url)) {
|
|
await notify('다운로드 가능한 URL을 찾지 못했습니다.')
|
|
return
|
|
}
|
|
|
|
const strategy = resolveStrategy(url, String(data?.pageUrl || tab?.url || ''), '')
|
|
const result = await transferUrlToGdown(
|
|
url,
|
|
String(data?.pageUrl || tab?.url || ''),
|
|
strategy.extractor,
|
|
strategy.format
|
|
)
|
|
if (!result.ok) {
|
|
await notify(`전송 실패: ${result.error || 'unknown error'}`)
|
|
return
|
|
}
|
|
await notify(strategy.extractor === 'yt-dlp' ? '페이지 URL을 yt-dlp로 gdown에 전송했습니다.' : 'gdown으로 전송했습니다.')
|
|
}
|
|
|
|
function createContextMenuSafe(): void {
|
|
if (typeof chrome === 'undefined' || !chrome.contextMenus?.create) {
|
|
browser.contextMenus.create({
|
|
id: contextMenuId,
|
|
title: 'Download with Gomdown',
|
|
visible: true,
|
|
contexts: ['all'],
|
|
})
|
|
return
|
|
}
|
|
chrome.contextMenus.create(
|
|
{
|
|
id: contextMenuId,
|
|
title: 'Download with Gomdown',
|
|
contexts: ['all'],
|
|
},
|
|
() => {
|
|
void chrome.runtime.lastError
|
|
}
|
|
)
|
|
}
|
|
|
|
function setupContextMenuClickListener(): void {
|
|
if (contextMenuHooked) return
|
|
if (typeof chrome !== 'undefined' && chrome.contextMenus?.onClicked) {
|
|
chrome.contextMenus.onClicked.addListener((info, tab) => {
|
|
void handleContextMenuClick(info, tab)
|
|
})
|
|
} else {
|
|
browser.contextMenus.onClicked.addListener((info: any, tab: any) => {
|
|
void handleContextMenuClick(info, tab)
|
|
})
|
|
}
|
|
contextMenuHooked = true
|
|
}
|
|
|
|
async function createMenuItemInternal(): Promise<void> {
|
|
const settings = await getSettings()
|
|
if (!settings.extensionStatus || !settings.showContextOption) {
|
|
await browser.contextMenus.removeAll().catch(() => null)
|
|
return
|
|
}
|
|
|
|
await browser.contextMenus.removeAll().catch(() => null)
|
|
createContextMenuSafe()
|
|
}
|
|
|
|
function createMenuItem(): Promise<void> {
|
|
if (contextMenuUpdateInFlight) return contextMenuUpdateInFlight
|
|
contextMenuUpdateInFlight = createMenuItemInternal().finally(() => {
|
|
contextMenuUpdateInFlight = null
|
|
})
|
|
return contextMenuUpdateInFlight
|
|
}
|
|
|
|
async function requestCreateClipOnActiveTab(): Promise<{ ok: boolean; error?: string }> {
|
|
clipLog('requestCreateClipOnActiveTab:start')
|
|
const tabs = await browser.tabs.query({ active: true, currentWindow: true })
|
|
const tab = tabs[0]
|
|
const tabId = Number(tab?.id)
|
|
clipLog('active tab', {
|
|
tabId,
|
|
url: String(tab?.url || ''),
|
|
title: String(tab?.title || ''),
|
|
})
|
|
if (!Number.isInteger(tabId) || tabId < 0) {
|
|
clipLog('requestCreateClipOnActiveTab:fail', 'active tab is unavailable')
|
|
return { ok: false, error: 'active tab is unavailable' }
|
|
}
|
|
|
|
const sendClipCreateMessage = async (): Promise<{ ok?: boolean; error?: string } | undefined> => {
|
|
return (await browser.tabs.sendMessage(tabId, {
|
|
type: 'clip:create-from-selection',
|
|
})) as { ok?: boolean; error?: string } | undefined
|
|
}
|
|
|
|
try {
|
|
let result: { ok?: boolean; error?: string } | undefined
|
|
try {
|
|
result = await sendClipCreateMessage()
|
|
} catch (firstError) {
|
|
clipLog('first sendMessage failed, using scripting fallback', String(firstError))
|
|
throw firstError
|
|
}
|
|
clipLog('content response', result)
|
|
if (result?.ok) return { ok: true }
|
|
clipLog('requestCreateClipOnActiveTab:fail', result?.error || 'failed to create clip in active tab')
|
|
return { ok: false, error: result?.error || 'failed to create clip in active tab' }
|
|
} catch (error) {
|
|
clipLog('requestCreateClipOnActiveTab:exception', String(error))
|
|
const scripted = await createClipFromSelectionByScriptingFallback(tabId, {
|
|
url: String(tab?.url || ''),
|
|
title: String(tab?.title || ''),
|
|
}).catch((fallbackError) => {
|
|
clipLog('scripting fallback exception', String(fallbackError))
|
|
return { ok: false, error: String(fallbackError) }
|
|
})
|
|
if (scripted.ok) return { ok: true }
|
|
return { ok: false, error: scripted.error || 'content script is not ready on active tab' }
|
|
}
|
|
}
|
|
|
|
async function showInlineActionBarByScripting(tabId: number): Promise<boolean> {
|
|
try {
|
|
const result = await browser.scripting.executeScript({
|
|
target: { tabId },
|
|
func: () => {
|
|
const rootId = 'gomdown-inline-actionbar-fallback'
|
|
const existing = document.getElementById(rootId)
|
|
if (existing) {
|
|
existing.style.display = 'flex'
|
|
return { ok: true }
|
|
}
|
|
|
|
const root = document.createElement('div')
|
|
root.id = rootId
|
|
root.style.position = 'fixed'
|
|
root.style.left = '50%'
|
|
root.style.bottom = '14px'
|
|
root.style.transform = 'translateX(-50%)'
|
|
root.style.zIndex = '2147483647'
|
|
root.style.display = 'flex'
|
|
root.style.gap = '8px'
|
|
root.style.padding = '10px'
|
|
root.style.background = 'rgba(15, 20, 31, 0.94)'
|
|
root.style.border = '1px solid rgba(97, 112, 155, 0.52)'
|
|
root.style.borderRadius = '12px'
|
|
root.style.boxShadow = '0 12px 24px rgba(0, 0, 0, 0.3)'
|
|
root.style.fontFamily = 'ui-sans-serif, -apple-system, BlinkMacSystemFont, Segoe UI, sans-serif'
|
|
|
|
const status = document.createElement('div')
|
|
status.textContent = 'Gomdown Quick Action'
|
|
status.style.fontSize = '11px'
|
|
status.style.color = '#c9d4f2'
|
|
status.style.display = 'flex'
|
|
status.style.alignItems = 'center'
|
|
status.style.padding = '0 2px'
|
|
|
|
const mk = (label: string, primary = false): HTMLButtonElement => {
|
|
const btn = document.createElement('button')
|
|
btn.type = 'button'
|
|
btn.textContent = label
|
|
btn.style.height = '32px'
|
|
btn.style.padding = '0 12px'
|
|
btn.style.borderRadius = '8px'
|
|
btn.style.border = primary ? '1px solid #5c6cf3' : '1px solid #4b5873'
|
|
btn.style.background = primary ? '#5c6cf3' : '#2a3346'
|
|
btn.style.color = '#e8edff'
|
|
btn.style.fontSize = '12px'
|
|
btn.style.fontWeight = '700'
|
|
btn.style.cursor = 'pointer'
|
|
return btn
|
|
}
|
|
|
|
const clipBtn = mk('클립 저장', true)
|
|
const pageBtn = mk('현재 페이지')
|
|
const mdBtn = mk('MD')
|
|
const jsonBtn = mk('JSON')
|
|
const obsidianBtn = mk('Obsidian')
|
|
const closeBtn = mk('닫기')
|
|
const extras = document.createElement('div')
|
|
extras.style.display = 'none'
|
|
extras.style.gap = '6px'
|
|
extras.style.alignItems = 'center'
|
|
extras.style.flexWrap = 'wrap'
|
|
extras.appendChild(mdBtn)
|
|
extras.appendChild(jsonBtn)
|
|
extras.appendChild(obsidianBtn)
|
|
|
|
clipBtn.onclick = () => {
|
|
try {
|
|
chrome.runtime.sendMessage({ type: 'clip:create-active-tab' }, (response) => {
|
|
const ok = Boolean(response?.ok)
|
|
status.textContent = ok ? '클립 저장 완료' : `실패: ${String(response?.error || 'unknown error')}`
|
|
status.style.color = ok ? '#8ff0a4' : '#ffaaaa'
|
|
if (ok) extras.style.display = 'flex'
|
|
})
|
|
} catch (error) {
|
|
status.textContent = `실패: ${String(error)}`
|
|
status.style.color = '#ffaaaa'
|
|
}
|
|
}
|
|
|
|
pageBtn.onclick = () => {
|
|
try {
|
|
chrome.runtime.sendMessage(
|
|
{
|
|
type: 'page:enqueue-ytdlp-url',
|
|
url: window.location.href,
|
|
referer: window.location.href,
|
|
},
|
|
(response) => {
|
|
const ok = Boolean(response?.ok)
|
|
status.textContent = ok ? '현재 페이지 전송 완료' : `실패: ${String(response?.error || 'unknown error')}`
|
|
status.style.color = ok ? '#8ff0a4' : '#ffaaaa'
|
|
}
|
|
)
|
|
} catch (error) {
|
|
status.textContent = `실패: ${String(error)}`
|
|
status.style.color = '#ffaaaa'
|
|
}
|
|
}
|
|
|
|
mdBtn.onclick = () => {
|
|
try {
|
|
chrome.runtime.sendMessage(
|
|
{
|
|
type: 'clip:export-current-page-md',
|
|
pageUrl: window.location.href,
|
|
pageTitle: document.title || window.location.href,
|
|
},
|
|
(response) => {
|
|
const ok = Boolean(response?.ok)
|
|
status.textContent = ok ? 'MD 내보내기 완료' : `실패: ${String(response?.error || 'unknown error')}`
|
|
status.style.color = ok ? '#8ff0a4' : '#ffaaaa'
|
|
}
|
|
)
|
|
} catch (error) {
|
|
status.textContent = `실패: ${String(error)}`
|
|
status.style.color = '#ffaaaa'
|
|
}
|
|
}
|
|
|
|
jsonBtn.onclick = () => {
|
|
try {
|
|
chrome.runtime.sendMessage(
|
|
{
|
|
type: 'clip:export-current-page-json',
|
|
pageUrl: window.location.href,
|
|
pageTitle: document.title || window.location.href,
|
|
},
|
|
(response) => {
|
|
const ok = Boolean(response?.ok)
|
|
status.textContent = ok ? 'JSON 내보내기 완료' : `실패: ${String(response?.error || 'unknown error')}`
|
|
status.style.color = ok ? '#8ff0a4' : '#ffaaaa'
|
|
}
|
|
)
|
|
} catch (error) {
|
|
status.textContent = `실패: ${String(error)}`
|
|
status.style.color = '#ffaaaa'
|
|
}
|
|
}
|
|
|
|
obsidianBtn.onclick = () => {
|
|
try {
|
|
chrome.runtime.sendMessage(
|
|
{
|
|
type: 'clip:send-obsidian-current-page',
|
|
pageUrl: window.location.href,
|
|
pageTitle: document.title || window.location.href,
|
|
},
|
|
(response) => {
|
|
const ok = Boolean(response?.ok && response?.uri)
|
|
if (ok) {
|
|
try {
|
|
window.open(String(response.uri), '_blank')
|
|
} catch {
|
|
window.location.href = String(response.uri)
|
|
}
|
|
status.textContent = 'Obsidian 전송 시도 완료'
|
|
status.style.color = '#8ff0a4'
|
|
return
|
|
}
|
|
status.textContent = `실패: ${String(response?.error || 'unknown error')}`
|
|
status.style.color = '#ffaaaa'
|
|
}
|
|
)
|
|
} catch (error) {
|
|
status.textContent = `실패: ${String(error)}`
|
|
status.style.color = '#ffaaaa'
|
|
}
|
|
}
|
|
|
|
closeBtn.onclick = () => {
|
|
root.remove()
|
|
}
|
|
|
|
root.appendChild(clipBtn)
|
|
root.appendChild(pageBtn)
|
|
root.appendChild(closeBtn)
|
|
root.appendChild(extras)
|
|
root.appendChild(status)
|
|
document.documentElement.appendChild(root)
|
|
window.setTimeout(() => {
|
|
root.remove()
|
|
}, 9000)
|
|
return { ok: true }
|
|
},
|
|
})
|
|
return Boolean((result?.[0]?.result as { ok?: boolean } | undefined)?.ok)
|
|
} catch {
|
|
return false
|
|
}
|
|
}
|
|
|
|
function makeClipId(): string {
|
|
try {
|
|
return crypto.randomUUID()
|
|
} catch {
|
|
return `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
|
|
}
|
|
}
|
|
|
|
function clipToMarkdownBlock(item: ClipItem, index: number): string {
|
|
const quoteRaw = String(item.quote || item.anchor?.exact || '').replace(/\r\n/g, '\n').trim()
|
|
const quote = quoteRaw.length > 4000 ? `${quoteRaw.slice(0, 4000)}\n...(truncated)` : quoteRaw
|
|
const lines = quote
|
|
.split('\n')
|
|
.map((line) => line.trimEnd())
|
|
.filter((line, idx, arr) => !(line === '' && arr[idx - 1] === ''))
|
|
const block = lines.length === 0 ? '> ' : lines.map((line) => `> ${line}`).join('\n')
|
|
return [
|
|
`### ${index + 1}. Clip`,
|
|
block,
|
|
'',
|
|
`- created: ${item.createdAt}`,
|
|
`- status: ${item.resolveStatus || 'ok'}`,
|
|
].join('\n')
|
|
}
|
|
|
|
function buildPageMarkdown(items: ClipItem[], pageUrl: string, pageTitle = ''): string {
|
|
const title = pageTitle || items[0]?.pageTitle || pageUrl || 'Untitled'
|
|
const lines: string[] = [
|
|
`# ${title}`,
|
|
`- source: ${pageUrl}`,
|
|
`- exportedAt: ${new Date().toISOString()}`,
|
|
`- clips: ${items.length}`,
|
|
'',
|
|
'---',
|
|
'',
|
|
]
|
|
for (let i = 0; i < items.length; i += 1) {
|
|
lines.push(clipToMarkdownBlock(items[i], i))
|
|
lines.push('')
|
|
}
|
|
return lines.join('\n')
|
|
}
|
|
|
|
function safeFileName(raw: string): string {
|
|
const title = String(raw || '')
|
|
.replace(/\s*[|\-–—]\s*(qiita|medium|youtube|x|twitter|tistory|velog|github)\s*$/i, '')
|
|
.replace(/\s*[-–—|]\s*(edge|chrome|firefox)\s*$/i, '')
|
|
.replace(/\[[^\]]{1,30}\]\s*$/g, '')
|
|
return title
|
|
.trim()
|
|
.replace(/[\\/:*?"<>|]/g, '_')
|
|
.replace(/[(){}[\]]/g, '')
|
|
.replace(/\s+/g, ' ')
|
|
.replace(/[._-]{2,}/g, '-')
|
|
.replace(/^[._\-\s]+|[._\-\s]+$/g, '')
|
|
.slice(0, 90) || 'clips'
|
|
}
|
|
|
|
function normalizeObsidianTarget(vaultRaw: string, folderRaw: string): { vault: string; folder: string } {
|
|
let vault = String(vaultRaw || '').trim()
|
|
let folder = String(folderRaw || '').trim()
|
|
|
|
// If user entered a filesystem path, use its basename as vault name.
|
|
if (vault.includes('/') || vault.includes('\\')) {
|
|
const parts = vault.split(/[\\/]+/).filter(Boolean)
|
|
vault = parts[parts.length - 1] || ''
|
|
}
|
|
|
|
// Ignore common placeholder values so we can fall back to default vault.
|
|
if (/^myvault$/i.test(vault) || /^example$/i.test(vault)) {
|
|
vault = ''
|
|
}
|
|
|
|
folder = folder.replace(/^\/+|\/+$/g, '')
|
|
return { vault, folder }
|
|
}
|
|
|
|
async function readLastObsidianVault(): Promise<string> {
|
|
try {
|
|
const raw = await browser.storage.local.get(OBSIDIAN_LAST_VAULT_KEY)
|
|
const value = String(raw?.[OBSIDIAN_LAST_VAULT_KEY] || '').trim()
|
|
return value
|
|
} catch {
|
|
return ''
|
|
}
|
|
}
|
|
|
|
async function writeLastObsidianVault(vaultRaw: string): Promise<void> {
|
|
const vault = String(vaultRaw || '').trim()
|
|
if (!vault) return
|
|
try {
|
|
await browser.storage.local.set({
|
|
[OBSIDIAN_LAST_VAULT_KEY]: vault,
|
|
})
|
|
} catch {
|
|
// ignored
|
|
}
|
|
}
|
|
|
|
async function downloadTextFile(filename: string, mime: string, content: string): Promise<{ ok: boolean; error?: string; downloadId?: number }> {
|
|
if (!filename.trim()) return { ok: false, error: 'filename is empty' }
|
|
const url = `data:${mime},${encodeURIComponent(content)}`
|
|
try {
|
|
const downloadId = await browser.downloads.download({
|
|
url,
|
|
filename: filename.trim(),
|
|
saveAs: true,
|
|
})
|
|
return { ok: true, downloadId }
|
|
} catch (error) {
|
|
return { ok: false, error: String(error) }
|
|
}
|
|
}
|
|
|
|
async function exportCurrentPageClipsAs(
|
|
pageUrlRaw: string,
|
|
pageTitleRaw: string,
|
|
kind: 'md' | 'json'
|
|
): Promise<{ ok: boolean; error?: string; count?: number; downloadId?: number }> {
|
|
const pageUrl = normalizePageUrl(String(pageUrlRaw || '').trim())
|
|
if (!pageUrl) return { ok: false, error: 'pageUrl is empty' }
|
|
const items = await listClipsByUrl(pageUrl)
|
|
if (items.length === 0) return { ok: false, error: 'no clips for current page' }
|
|
|
|
const pageTitle = String(pageTitleRaw || items[0]?.pageTitle || pageUrl).trim()
|
|
if (kind === 'md') {
|
|
const markdown = buildPageMarkdown(items, pageUrl, pageTitle)
|
|
const filename = `${safeFileName(pageTitle)}-clips.md`
|
|
const saved = await downloadTextFile(filename, 'text/markdown;charset=utf-8', markdown)
|
|
return { ok: saved.ok, error: saved.error, count: items.length, downloadId: saved.downloadId }
|
|
}
|
|
|
|
const payload = {
|
|
exportedAt: new Date().toISOString(),
|
|
version: 1,
|
|
count: items.length,
|
|
clips: items,
|
|
}
|
|
const filename = `${safeFileName(pageTitle)}-clips.json`
|
|
const saved = await downloadTextFile(filename, 'application/json;charset=utf-8', JSON.stringify(payload, null, 2))
|
|
return { ok: saved.ok, error: saved.error, count: items.length, downloadId: saved.downloadId }
|
|
}
|
|
|
|
async function buildObsidianUriForCurrentPage(pageUrlRaw: string, pageTitleRaw: string): Promise<{ ok: boolean; error?: string; uri?: string; count?: number }> {
|
|
const pageUrl = normalizePageUrl(String(pageUrlRaw || '').trim())
|
|
if (!pageUrl) return { ok: false, error: 'pageUrl is empty' }
|
|
const items = await listClipsByUrl(pageUrl)
|
|
if (items.length === 0) return { ok: false, error: 'no clips for current page' }
|
|
const settings = await getSettings()
|
|
const normalizedTarget = normalizeObsidianTarget(settings.obsidianVault, settings.obsidianFolder)
|
|
if (normalizedTarget.vault) {
|
|
await writeLastObsidianVault(normalizedTarget.vault)
|
|
}
|
|
const vault = normalizedTarget.vault || (await readLastObsidianVault())
|
|
const pageTitle = String(pageTitleRaw || items[0]?.pageTitle || pageUrl).trim()
|
|
const markdown = buildPageMarkdown(items, pageUrl, pageTitle)
|
|
const folder = normalizedTarget.folder
|
|
const noteBase = `${safeFileName(pageTitle)}-${new Date().toISOString().slice(0, 19).replace(/[:T]/g, '-')}`
|
|
const filePath = folder ? `${folder}/${noteBase}` : noteBase
|
|
const query =
|
|
`file=${encodeURIComponent(filePath)}` +
|
|
`&content=${encodeURIComponent(markdown)}`
|
|
const uri = vault
|
|
? `obsidian://new?vault=${encodeURIComponent(vault)}&${query}`
|
|
: `obsidian://new?${query}`
|
|
return { ok: true, uri, count: items.length }
|
|
}
|
|
|
|
async function revealClipByScriptingFallback(tabId: number, item: ClipItem): Promise<boolean> {
|
|
try {
|
|
const result = await browser.scripting.executeScript({
|
|
target: { tabId },
|
|
args: [item.quote || item.anchor?.exact || '', item.anchor?.prefix || '', item.anchor?.suffix || ''],
|
|
func: (quoteRaw: string, prefixRaw: string, suffixRaw: string) => {
|
|
const quote = String(quoteRaw || '').trim()
|
|
if (!quote) return { ok: false, error: 'quote is empty' }
|
|
const prefix = String(prefixRaw || '').trim()
|
|
const suffix = String(suffixRaw || '').trim()
|
|
const full = document.body?.innerText || document.documentElement?.innerText || ''
|
|
if (!full) return { ok: false, error: 'document text is empty' }
|
|
|
|
let idx = full.indexOf(quote)
|
|
let matchedIndex = -1
|
|
while (idx >= 0) {
|
|
const left = prefix ? full.slice(Math.max(0, idx - prefix.length), idx).trim() : ''
|
|
const right = suffix ? full.slice(idx + quote.length, idx + quote.length + suffix.length).trim() : ''
|
|
const prefixOk = !prefix || left === prefix
|
|
const suffixOk = !suffix || right === suffix
|
|
if (prefixOk && suffixOk) {
|
|
matchedIndex = idx
|
|
break
|
|
}
|
|
idx = full.indexOf(quote, idx + Math.max(1, Math.floor(quote.length / 2)))
|
|
}
|
|
if (matchedIndex < 0) return { ok: false, error: 'quote not found in page text' }
|
|
|
|
const walker = document.createTreeWalker(document.body || document.documentElement, NodeFilter.SHOW_TEXT)
|
|
let cursor = 0
|
|
let startNode: Text | null = null
|
|
let endNode: Text | null = null
|
|
let startOffset = 0
|
|
let endOffset = 0
|
|
const targetStart = matchedIndex
|
|
const targetEnd = matchedIndex + quote.length
|
|
let current = walker.nextNode()
|
|
while (current) {
|
|
if (current.nodeType === Node.TEXT_NODE) {
|
|
const text = current as Text
|
|
const value = text.nodeValue || ''
|
|
const next = cursor + value.length
|
|
if (!startNode && targetStart >= cursor && targetStart <= next) {
|
|
startNode = text
|
|
startOffset = Math.max(0, targetStart - cursor)
|
|
}
|
|
if (!endNode && targetEnd >= cursor && targetEnd <= next) {
|
|
endNode = text
|
|
endOffset = Math.max(0, targetEnd - cursor)
|
|
}
|
|
cursor = next
|
|
}
|
|
current = walker.nextNode()
|
|
}
|
|
if (!startNode || !endNode) return { ok: false, error: 'failed to map quote to text nodes' }
|
|
|
|
const range = document.createRange()
|
|
range.setStart(startNode, Math.min(startNode.length, startOffset))
|
|
range.setEnd(endNode, Math.min(endNode.length, endOffset))
|
|
const rect = range.getBoundingClientRect()
|
|
const marker = document.createElement('span')
|
|
marker.style.position = 'absolute'
|
|
marker.style.left = `${window.scrollX + rect.left - 2}px`
|
|
marker.style.top = `${window.scrollY + rect.top - 2}px`
|
|
marker.style.width = `${Math.max(8, rect.width + 4)}px`
|
|
marker.style.height = `${Math.max(14, rect.height + 4)}px`
|
|
marker.style.pointerEvents = 'none'
|
|
marker.style.borderRadius = '6px'
|
|
marker.style.background = 'rgba(255, 240, 130, 0.42)'
|
|
marker.style.border = '1px solid rgba(230, 190, 70, 0.72)'
|
|
marker.style.zIndex = '2147483647'
|
|
document.documentElement.appendChild(marker)
|
|
window.scrollTo({
|
|
top: Math.max(0, window.scrollY + rect.top - window.innerHeight * 0.35),
|
|
behavior: 'smooth',
|
|
})
|
|
window.setTimeout(() => marker.remove(), 1800)
|
|
return { ok: true }
|
|
},
|
|
})
|
|
return Boolean((result?.[0]?.result as { ok?: boolean } | undefined)?.ok)
|
|
} catch {
|
|
return false
|
|
}
|
|
}
|
|
|
|
async function createClipFromSelectionByScriptingFallback(
|
|
tabId: number,
|
|
fallbackTab?: { url?: string; title?: string }
|
|
): Promise<{ ok: boolean; item?: ClipItem; error?: string }> {
|
|
clipLog('createClipFromSelectionByScriptingFallback:start', { tabId })
|
|
const injected = await browser.scripting.executeScript({
|
|
target: { tabId },
|
|
func: () => {
|
|
const selection = window.getSelection()
|
|
if (!selection || selection.rangeCount === 0) return { ok: false, error: 'empty selection' }
|
|
const quote = String(selection.toString() || '').trim()
|
|
if (!quote) return { ok: false, error: 'empty selection' }
|
|
const range = selection.getRangeAt(0)
|
|
const startNode = range.startContainer
|
|
const endNode = range.endContainer
|
|
const startText = startNode.nodeType === Node.TEXT_NODE ? String((startNode as Text).nodeValue || '') : ''
|
|
const endText = endNode.nodeType === Node.TEXT_NODE ? String((endNode as Text).nodeValue || '') : ''
|
|
const prefix = startText ? startText.slice(Math.max(0, range.startOffset - 24), range.startOffset).trim() : ''
|
|
const suffix = endText ? endText.slice(range.endOffset, Math.min(endText.length, range.endOffset + 24)).trim() : ''
|
|
return {
|
|
ok: true,
|
|
quote,
|
|
quoteHtml: (() => {
|
|
try {
|
|
const div = document.createElement('div')
|
|
div.appendChild(range.cloneContents())
|
|
return div.innerHTML.trim()
|
|
} catch {
|
|
return ''
|
|
}
|
|
})(),
|
|
pageUrl: String(location.href || '').split('#')[0],
|
|
pageTitle: String(document.title || ''),
|
|
anchor: {
|
|
exact: quote,
|
|
prefix: prefix || undefined,
|
|
suffix: suffix || undefined,
|
|
},
|
|
}
|
|
},
|
|
})
|
|
|
|
const payload = injected?.[0]?.result as
|
|
| {
|
|
ok?: boolean
|
|
error?: string
|
|
quote?: string
|
|
quoteHtml?: string
|
|
pageUrl?: string
|
|
pageTitle?: string
|
|
anchor?: ClipItem['anchor']
|
|
}
|
|
| undefined
|
|
if (!payload?.ok) {
|
|
const error = payload?.error || 'selection capture fallback failed'
|
|
clipLog('createClipFromSelectionByScriptingFallback:fail', error)
|
|
return { ok: false, error }
|
|
}
|
|
|
|
const pageUrl = normalizePageUrl(String(payload.pageUrl || fallbackTab?.url || ''))
|
|
const pageTitle = String(payload.pageTitle || fallbackTab?.title || pageUrl).trim()
|
|
const quote = String(payload.quote || payload.anchor?.exact || '').trim()
|
|
const anchor = (payload.anchor || { exact: quote }) as ClipItem['anchor']
|
|
if (!pageUrl || !quote || !String(anchor?.exact || '').trim()) {
|
|
return { ok: false, error: 'invalid clip payload from fallback' }
|
|
}
|
|
|
|
const created: ClipItem = {
|
|
id: makeClipId(),
|
|
tabId,
|
|
pageUrl,
|
|
pageTitle: pageTitle || pageUrl,
|
|
quote,
|
|
quoteHtml: String(payload.quoteHtml || '').trim() || undefined,
|
|
createdAt: new Date().toISOString(),
|
|
color: 'yellow',
|
|
anchor,
|
|
}
|
|
const item = await insertClip(created)
|
|
clipLog('createClipFromSelectionByScriptingFallback:ok', { id: item.id, pageUrl: item.pageUrl })
|
|
return { ok: true, item }
|
|
}
|
|
|
|
async function findExistingTabIdByUrl(url: string): Promise<number | null> {
|
|
const target = normalizePageUrl(url)
|
|
const tabs = await browser.tabs.query({})
|
|
const hit = tabs.find((tab) => normalizePageUrl(String(tab.url || '')) === target)
|
|
return Number.isInteger(hit?.id) ? (hit?.id as number) : null
|
|
}
|
|
|
|
browser.runtime.onMessage.addListener((message: any, sender: any) => {
|
|
if (message?.type?.startsWith?.('clip:')) {
|
|
clipLog('runtime.onMessage', message?.type, {
|
|
senderTabId: Number(sender?.tab?.id),
|
|
senderUrl: String(sender?.tab?.url || ''),
|
|
})
|
|
}
|
|
|
|
if (message?.type === 'capture-link-download') {
|
|
const url = String(message?.url || '').trim()
|
|
if (!url) return Promise.resolve({ ok: false, error: 'url is empty' })
|
|
|
|
const senderTabId = Number(sender?.tab?.id)
|
|
return transferUrlToGdown(url, String(message?.referer || '')).then((result) => {
|
|
if (result.ok) {
|
|
rememberCapturedUrl(url)
|
|
rememberCapturedTab(senderTabId)
|
|
}
|
|
return result
|
|
})
|
|
}
|
|
|
|
if (message?.type === 'media:list') {
|
|
return listMediaCandidates().then((items) => ({ ok: true, items }))
|
|
}
|
|
|
|
if (message?.type === 'media:clear') {
|
|
return clearMediaCandidates().then(() => ({ ok: true }))
|
|
}
|
|
|
|
if (message?.type === 'media:enqueue') {
|
|
const url = String(message?.url || '').trim()
|
|
const kind = String(message?.kind || '').trim()
|
|
const suggestedOut = String(message?.suggestedOut || '').trim()
|
|
const referer = String(message?.referer || '').trim()
|
|
const cookie = String(message?.cookie || '').trim()
|
|
const userAgent = String(message?.userAgent || '').trim()
|
|
if (!url) return Promise.resolve({ ok: false, error: 'url is empty' })
|
|
const strategy = resolveStrategy(url, referer, kind)
|
|
return transferUrlToGdown(url, referer, strategy.extractor, strategy.format, suggestedOut, {
|
|
cookie,
|
|
userAgent,
|
|
}).then((result) => result)
|
|
}
|
|
|
|
if (message?.type === 'page:enqueue-ytdlp') {
|
|
return browser.tabs
|
|
.query({ active: true, currentWindow: true })
|
|
.then(async (tabs) => {
|
|
const tab = tabs[0]
|
|
const url = String(tab?.url || '').trim()
|
|
if (!url) return { ok: false, error: 'active tab url is empty' }
|
|
return transferUrlToGdown(url, url, 'yt-dlp')
|
|
})
|
|
}
|
|
|
|
if (message?.type === 'page:enqueue-ytdlp-url') {
|
|
const url = String(message?.url || '').trim()
|
|
const referer = String(message?.referer || url).trim()
|
|
if (!url) return Promise.resolve({ ok: false, error: 'url is empty' })
|
|
return transferUrlToGdown(url, referer || url, 'yt-dlp')
|
|
}
|
|
|
|
if (message?.type === 'file:download-text') {
|
|
const filename = String(message?.filename || '').trim()
|
|
const mime = String(message?.mime || 'text/plain;charset=utf-8').trim()
|
|
const content = String(message?.content || '')
|
|
return downloadTextFile(filename, mime, content)
|
|
}
|
|
|
|
if (message?.type === 'clip:export-current-page-md') {
|
|
return exportCurrentPageClipsAs(String(message?.pageUrl || ''), String(message?.pageTitle || ''), 'md')
|
|
}
|
|
|
|
if (message?.type === 'clip:export-current-page-json') {
|
|
return exportCurrentPageClipsAs(String(message?.pageUrl || ''), String(message?.pageTitle || ''), 'json')
|
|
}
|
|
|
|
if (message?.type === 'clip:send-obsidian-current-page') {
|
|
return buildObsidianUriForCurrentPage(String(message?.pageUrl || ''), String(message?.pageTitle || ''))
|
|
}
|
|
|
|
if (message?.type === 'clip:create') {
|
|
return getSettings().then(async (settings) => {
|
|
if (!settings.extensionStatus) return { ok: false, error: 'extension disabled' }
|
|
const pageUrl = normalizePageUrl(String(message?.pageUrl || sender?.tab?.url || ''))
|
|
const pageTitle = String(message?.pageTitle || sender?.tab?.title || '').trim()
|
|
const quote = String(message?.quote || message?.anchor?.exact || '').trim()
|
|
const quoteHtml = String(message?.quoteHtml || '').trim()
|
|
const anchor = message?.anchor as ClipItem['anchor']
|
|
if (!pageUrl) return { ok: false, error: 'pageUrl is empty' }
|
|
if (!anchor || !String(anchor.exact || '').trim()) return { ok: false, error: 'anchor is empty' }
|
|
|
|
const created: ClipItem = {
|
|
id: makeClipId(),
|
|
tabId: Number.isInteger(sender?.tab?.id) ? Number(sender.tab.id) : undefined,
|
|
pageUrl,
|
|
pageTitle: pageTitle || pageUrl,
|
|
quote: quote || String(anchor.exact || '').trim(),
|
|
quoteHtml: quoteHtml || undefined,
|
|
createdAt: new Date().toISOString(),
|
|
color: 'yellow',
|
|
anchor,
|
|
}
|
|
const item = await insertClip(created)
|
|
return { ok: true, item }
|
|
})
|
|
}
|
|
|
|
if (message?.type === 'clip:list') {
|
|
const pageUrl = String(message?.pageUrl || '').trim()
|
|
if (pageUrl) {
|
|
return listClipsByUrl(pageUrl).then((items) => ({ ok: true, items }))
|
|
}
|
|
return listClips().then((items) => ({ ok: true, items }))
|
|
}
|
|
|
|
if (message?.type === 'clip:export') {
|
|
return listClips().then((items) => ({ ok: true, items }))
|
|
}
|
|
|
|
if (message?.type === 'clip:import') {
|
|
const items = Array.isArray(message?.items) ? message.items : []
|
|
return importClips(items).then((result) => ({ ok: true, ...result }))
|
|
}
|
|
|
|
if (message?.type === 'clip:delete') {
|
|
const id = String(message?.id || '').trim()
|
|
if (!id) return Promise.resolve({ ok: false, error: 'id is empty' })
|
|
return deleteClip(id).then((deleted) => ({ ok: deleted }))
|
|
}
|
|
|
|
if (message?.type === 'clip:create-active-tab') {
|
|
return requestCreateClipOnActiveTab()
|
|
}
|
|
|
|
if (message?.type === 'clip:resolve-status') {
|
|
const id = String(message?.id || '').trim()
|
|
const status = String(message?.status || '').trim()
|
|
if (!id) return Promise.resolve({ ok: false, error: 'id is empty' })
|
|
if (status !== 'ok' && status !== 'broken') return Promise.resolve({ ok: false, error: 'invalid status' })
|
|
return updateClipResolveStatus(id, status).then((item) => ({ ok: !!item, item }))
|
|
}
|
|
|
|
if (message?.type === 'clip:reveal') {
|
|
const id = String(message?.id || '').trim()
|
|
if (!id) return Promise.resolve({ ok: false, error: 'id is empty' })
|
|
return getClipById(id).then(async (item) => {
|
|
if (!item) return { ok: false, error: 'clip not found' }
|
|
const tabId = Number.isInteger(item.tabId) && (item.tabId || 0) >= 0 ? (item.tabId as number) : await findExistingTabIdByUrl(item.pageUrl)
|
|
if (!Number.isInteger(tabId) || (tabId as number) < 0) {
|
|
const created = await browser.tabs.create({ url: item.pageUrl, active: true }).catch(() => null)
|
|
if (!Number.isInteger(created?.id)) return { ok: false, error: 'failed to open clip page' }
|
|
return { ok: true, opened: true }
|
|
}
|
|
await browser.tabs.update(tabId as number, { active: true }).catch(() => null)
|
|
const revealResult = (await browser.tabs
|
|
.sendMessage(tabId as number, {
|
|
type: 'clip:reveal',
|
|
id: item.id,
|
|
})
|
|
.catch(() => null)) as { ok?: boolean } | null
|
|
if (!revealResult?.ok) {
|
|
const fallbackOk = await revealClipByScriptingFallback(tabId as number, item)
|
|
if (fallbackOk) {
|
|
await updateClipResolveStatus(item.id, 'ok')
|
|
return { ok: true, fallback: 'scripting' }
|
|
}
|
|
await updateClipResolveStatus(item.id, 'broken')
|
|
return { ok: false, error: 'clip anchor not found in current dom' }
|
|
}
|
|
await updateClipResolveStatus(item.id, 'ok')
|
|
return { ok: true }
|
|
})
|
|
}
|
|
|
|
return undefined
|
|
})
|
|
|
|
browser.commands.onCommand.addListener((command) => {
|
|
clipLog('commands.onCommand', command)
|
|
if (command !== 'create_clip_from_selection') return
|
|
void (async () => {
|
|
const tabs = await browser.tabs.query({ active: true, currentWindow: true })
|
|
const tabId = Number(tabs[0]?.id)
|
|
if (Number.isInteger(tabId) && tabId >= 0) {
|
|
const shown = await browser.tabs
|
|
.sendMessage(tabId, { type: 'clip:show-action-bar' })
|
|
.then((v) => Boolean((v as any)?.ok))
|
|
.catch(() => false)
|
|
if (shown) return
|
|
const injectedShown = await showInlineActionBarByScripting(tabId)
|
|
if (injectedShown) return
|
|
}
|
|
|
|
const result = await requestCreateClipOnActiveTab()
|
|
if (result.ok) return
|
|
clipLog('commands.onCommand:fail', result)
|
|
await notify(`클립 생성 실패: ${result.error || 'unknown error'}`)
|
|
})()
|
|
})
|
|
|
|
browser.runtime.onInstalled.addListener(() => {
|
|
console.log('[gomdown-helper] onInstalled')
|
|
setupWebRequestInterceptor()
|
|
setupDownloadCancelHook()
|
|
setupContextMenuClickListener()
|
|
void createMenuItem()
|
|
void applyShelfVisibility()
|
|
})
|
|
|
|
browser.runtime.onStartup.addListener(() => {
|
|
console.log('[gomdown-helper] onStartup')
|
|
setupWebRequestInterceptor()
|
|
setupDownloadCancelHook()
|
|
setupContextMenuClickListener()
|
|
void createMenuItem()
|
|
void applyShelfVisibility()
|
|
})
|
|
|
|
browser.storage.onChanged.addListener((changes, areaName) => {
|
|
if (areaName !== 'sync') return
|
|
if (changes.hideChromeBar || changes.useNativeHost || changes.extensionStatus) {
|
|
void applyShelfVisibility()
|
|
void createMenuItem()
|
|
}
|
|
if (changes.showContextOption) {
|
|
void createMenuItem()
|
|
}
|
|
})
|
|
|
|
setupWebRequestInterceptor()
|
|
setupDownloadCancelHook()
|
|
setupContextMenuClickListener()
|
|
void createMenuItem()
|
|
void applyShelfVisibility()
|
|
console.log('[gomdown-helper] service worker initialized')
|