321 lines
11 KiB
TypeScript
321 lines
11 KiB
TypeScript
/**
|
|
* Verify social media handles exist via lightweight API checks.
|
|
* Each check runs independently — one failure doesn't block others.
|
|
*/
|
|
|
|
export interface VerifiedChannel {
|
|
handle: string;
|
|
verified: boolean | "unverifiable";
|
|
url?: string;
|
|
channelId?: string; // YouTube channel ID if resolved
|
|
}
|
|
|
|
export interface VerifiedChannels {
|
|
instagram: VerifiedChannel[];
|
|
youtube: VerifiedChannel | null;
|
|
facebook: VerifiedChannel | null;
|
|
naverBlog: VerifiedChannel | null;
|
|
gangnamUnni: VerifiedChannel | null;
|
|
tiktok: VerifiedChannel | null;
|
|
}
|
|
|
|
/**
|
|
* Verify an Instagram handle exists.
|
|
* Uses a lightweight fetch to the profile page.
|
|
*/
|
|
async function verifyInstagram(handle: string): Promise<VerifiedChannel> {
|
|
try {
|
|
const url = `https://www.instagram.com/${handle}/`;
|
|
const res = await fetch(url, {
|
|
method: 'GET',
|
|
headers: { 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)' },
|
|
redirect: 'manual', // Don't follow redirects — detect login page
|
|
});
|
|
|
|
// 302/301 to login page → Instagram blocks unauthenticated access
|
|
if (res.status === 301 || res.status === 302) {
|
|
const location = res.headers.get('location') || '';
|
|
if (location.includes('/accounts/login') || location.includes('/challenge')) {
|
|
return { handle, verified: 'unverifiable', url };
|
|
}
|
|
}
|
|
|
|
// 200 → profile exists; 404 → definitely not found
|
|
if (res.status === 200) {
|
|
// Double-check: some 200 responses are actually the login page
|
|
const bodySnippet = await res.text().then(t => t.slice(0, 2000)).catch(() => '');
|
|
if (bodySnippet.includes('/accounts/login') && !bodySnippet.includes(`"username":"${handle}"`)) {
|
|
return { handle, verified: 'unverifiable', url };
|
|
}
|
|
return { handle, verified: true, url };
|
|
}
|
|
|
|
if (res.status === 404) {
|
|
return { handle, verified: false, url };
|
|
}
|
|
|
|
// Any other status → unverifiable (don't assume it doesn't exist)
|
|
return { handle, verified: 'unverifiable', url };
|
|
} catch {
|
|
return { handle, verified: 'unverifiable' };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify a YouTube handle/channel exists using YouTube Data API v3.
|
|
*/
|
|
async function verifyYouTube(handle: string, apiKey: string): Promise<VerifiedChannel & { channelTitle?: string }> {
|
|
try {
|
|
const YT_BASE = 'https://www.googleapis.com/youtube/v3';
|
|
const cleanHandle = handle.replace(/^@/, '');
|
|
|
|
// Try forHandle first, then forUsername
|
|
for (const param of ['forHandle', 'forUsername']) {
|
|
const res = await fetch(`${YT_BASE}/channels?part=id,snippet&${param}=${cleanHandle}&key=${apiKey}`);
|
|
const data = await res.json();
|
|
const channel = data.items?.[0];
|
|
if (channel) {
|
|
return {
|
|
handle,
|
|
verified: true,
|
|
channelId: channel.id,
|
|
channelTitle: channel.snippet?.title || '',
|
|
url: `https://youtube.com/@${cleanHandle}`,
|
|
};
|
|
}
|
|
}
|
|
|
|
// Try as channel ID directly (starts with UC)
|
|
if (cleanHandle.startsWith('UC') && cleanHandle.length === 24) {
|
|
const res = await fetch(`${YT_BASE}/channels?part=id,snippet&id=${cleanHandle}&key=${apiKey}`);
|
|
const data = await res.json();
|
|
const channel = data.items?.[0];
|
|
if (channel) {
|
|
return {
|
|
handle: cleanHandle, verified: true, channelId: cleanHandle,
|
|
channelTitle: channel.snippet?.title || '',
|
|
url: `https://youtube.com/channel/${cleanHandle}`,
|
|
};
|
|
}
|
|
}
|
|
|
|
return { handle, verified: false };
|
|
} catch {
|
|
return { handle, verified: false };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify a Facebook page exists via HEAD request.
|
|
*/
|
|
async function verifyFacebook(handle: string): Promise<VerifiedChannel> {
|
|
try {
|
|
const url = `https://www.facebook.com/${handle}/`;
|
|
// Use GET instead of HEAD — Facebook blocks HEAD requests
|
|
const res = await fetch(url, {
|
|
method: 'GET',
|
|
headers: { 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)' },
|
|
redirect: 'follow',
|
|
});
|
|
|
|
if (res.status === 200) {
|
|
// Check if it's a real page or a redirect to login/error
|
|
const bodySnippet = await res.text().then(t => t.slice(0, 3000)).catch(() => '');
|
|
if (bodySnippet.includes('page_not_found') || bodySnippet.includes('This content isn')) {
|
|
return { handle, verified: false, url };
|
|
}
|
|
return { handle, verified: true, url };
|
|
}
|
|
|
|
if (res.status === 404) {
|
|
return { handle, verified: false, url };
|
|
}
|
|
|
|
// Facebook often blocks bots → unverifiable, not false
|
|
return { handle, verified: 'unverifiable', url };
|
|
} catch {
|
|
return { handle, verified: 'unverifiable' };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify Naver Blog exists.
|
|
*/
|
|
async function verifyNaverBlog(blogId: string): Promise<VerifiedChannel> {
|
|
try {
|
|
const url = `https://blog.naver.com/${blogId}`;
|
|
const res = await fetch(url, {
|
|
method: 'HEAD',
|
|
redirect: 'follow',
|
|
});
|
|
return { handle: blogId, verified: res.status === 200, url };
|
|
} catch {
|
|
return { handle: blogId, verified: false };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Find and verify gangnamunni hospital page using Firecrawl search.
|
|
*/
|
|
async function verifyGangnamUnni(
|
|
clinicName: string,
|
|
firecrawlKey: string,
|
|
hintUrl?: string,
|
|
): Promise<VerifiedChannel> {
|
|
try {
|
|
// If we already have a URL hint from Perplexity, just verify it
|
|
if (hintUrl && hintUrl.includes('gangnamunni.com/hospitals/')) {
|
|
const res = await fetch(hintUrl, { method: 'HEAD', redirect: 'follow' });
|
|
if (res.status === 200) {
|
|
return { handle: clinicName, verified: true, url: hintUrl };
|
|
}
|
|
}
|
|
|
|
// Otherwise, search with multiple fallback queries
|
|
const shortName = clinicName.replace(/성형외과|의원|병원|클리닉|피부과/g, '').trim();
|
|
const queries = [
|
|
`${clinicName} site:gangnamunni.com`,
|
|
`${shortName} 성형외과 site:gangnamunni.com`,
|
|
`${clinicName} 강남언니`,
|
|
];
|
|
|
|
for (const query of queries) {
|
|
const searchRes = await fetch('https://api.firecrawl.dev/v1/search', {
|
|
method: 'POST',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
Authorization: `Bearer ${firecrawlKey}`,
|
|
},
|
|
body: JSON.stringify({ query, limit: 5 }),
|
|
});
|
|
const data = await searchRes.json();
|
|
const url = (data.data || [])
|
|
.map((r: Record<string, string>) => r.url)
|
|
.find((u: string) => u?.includes('gangnamunni.com/hospitals/'));
|
|
|
|
if (url) {
|
|
return { handle: clinicName, verified: true, url };
|
|
}
|
|
}
|
|
|
|
return { handle: clinicName, verified: false };
|
|
} catch {
|
|
return { handle: clinicName, verified: false };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify all discovered handles in parallel.
|
|
*/
|
|
export async function verifyAllHandles(
|
|
candidates: {
|
|
instagram: string[];
|
|
youtube: string[];
|
|
facebook: string[];
|
|
naverBlog: string[];
|
|
tiktok: string[];
|
|
},
|
|
clinicName: string,
|
|
gangnamUnniHintUrl?: string,
|
|
): Promise<VerifiedChannels> {
|
|
const YOUTUBE_API_KEY = Deno.env.get('YOUTUBE_API_KEY') || '';
|
|
const FIRECRAWL_API_KEY = Deno.env.get('FIRECRAWL_API_KEY') || '';
|
|
|
|
const tasks: Promise<void>[] = [];
|
|
const result: VerifiedChannels = {
|
|
instagram: [],
|
|
youtube: null,
|
|
facebook: null,
|
|
naverBlog: null,
|
|
gangnamUnni: null,
|
|
tiktok: null,
|
|
};
|
|
|
|
// Instagram — verify each candidate, keep unverified as fallback
|
|
for (const handle of candidates.instagram.slice(0, 5)) {
|
|
tasks.push(
|
|
verifyInstagram(handle).then(v => { result.instagram.push(v); })
|
|
);
|
|
}
|
|
|
|
// YouTube — verify ALL candidates, pick the best match by clinic name
|
|
if (candidates.youtube.length > 0) {
|
|
const ytCandidates = candidates.youtube.slice(0, 5);
|
|
const ytResults: (VerifiedChannel & { channelTitle?: string })[] = [];
|
|
const ytTasks = ytCandidates.map(handle =>
|
|
verifyYouTube(handle, YOUTUBE_API_KEY).then(v => { if (v.verified) ytResults.push(v); })
|
|
);
|
|
tasks.push(
|
|
Promise.allSettled(ytTasks).then(() => {
|
|
if (ytResults.length === 0) {
|
|
// None verified — use first candidate as unverified
|
|
result.youtube = { handle: ytCandidates[0], verified: false };
|
|
return;
|
|
}
|
|
// Pick best match: channel title containing clinic name
|
|
const nameL = clinicName.toLowerCase().replace(/성형외과|병원|의원|클리닉/g, '').trim();
|
|
const nameWords = [clinicName.toLowerCase(), nameL].filter(w => w.length >= 2);
|
|
const bestMatch = ytResults.find(r =>
|
|
nameWords.some(w => (r.channelTitle || '').toLowerCase().includes(w))
|
|
);
|
|
result.youtube = bestMatch || ytResults[0];
|
|
if (bestMatch) {
|
|
console.log(`[verify] YouTube matched: "${bestMatch.channelTitle}" for "${clinicName}"`);
|
|
} else {
|
|
console.warn(`[verify] YouTube no name match — using first verified: "${ytResults[0].channelTitle}"`);
|
|
}
|
|
})
|
|
);
|
|
}
|
|
|
|
// Facebook — try all candidates, also try clinic name as fallback
|
|
const fbCandidates = [...candidates.facebook];
|
|
// Fallback: try common Facebook page name patterns from clinic name
|
|
if (clinicName) {
|
|
const domain = fbCandidates.length > 0 ? '' : clinicName.toLowerCase()
|
|
.replace(/성형외과|병원|의원|클리닉|피부과/g, '').trim().replace(/\s+/g, '');
|
|
// Try English brand name patterns (e.g. "아이디병원" → site URL "idhospital")
|
|
// This is handled by extractSocialLinks from siteLinks already
|
|
if (domain && !fbCandidates.includes(domain)) fbCandidates.push(domain);
|
|
}
|
|
if (fbCandidates.length > 0) {
|
|
tasks.push(
|
|
(async () => {
|
|
for (const handle of fbCandidates.slice(0, 3)) {
|
|
const v = await verifyFacebook(handle);
|
|
if (v.verified === true || v.verified === 'unverifiable') {
|
|
result.facebook = v;
|
|
return;
|
|
}
|
|
}
|
|
// All failed — store first as unverified
|
|
result.facebook = { handle: fbCandidates[0], verified: false };
|
|
})()
|
|
);
|
|
}
|
|
|
|
// Naver Blog — first candidate
|
|
if (candidates.naverBlog.length > 0) {
|
|
tasks.push(
|
|
verifyNaverBlog(candidates.naverBlog[0]).then(v => { result.naverBlog = v; })
|
|
);
|
|
}
|
|
|
|
// 강남언니 — always try if clinicName exists
|
|
if (clinicName && FIRECRAWL_API_KEY) {
|
|
tasks.push(
|
|
verifyGangnamUnni(clinicName, FIRECRAWL_API_KEY, gangnamUnniHintUrl)
|
|
.then(v => { result.gangnamUnni = v; })
|
|
);
|
|
}
|
|
|
|
// TikTok — skip verification for now (TikTok blocks HEAD requests)
|
|
if (candidates.tiktok.length > 0) {
|
|
const tkHandle = candidates.tiktok[0].replace(/^@/, '');
|
|
result.tiktok = { handle: tkHandle, verified: false, url: `https://tiktok.com/@${tkHandle}` };
|
|
}
|
|
|
|
await Promise.allSettled(tasks);
|
|
return result;
|
|
}
|