viruagent-cli 0.3.4 → 0.3.6

package/src/providers/naver/editorConvert.js

@@ -0,0 +1,198 @@
+const crypto = require('crypto');
+
+const seId = () => `SE-${crypto.randomUUID()}`;
+
+const createTextComponent = (text, { fontSize = 'fs16', bold = 'false', align = 'left', lineHeight = '1.8', ctype = 'text' } = {}) => ({
+  id: seId(),
+  layout: 'default',
+  value: [{
+    id: seId(),
+    nodes: [{
+      id: seId(),
+      value: text,
+      style: {
+        fontColor: '#333333',
+        fontSizeCode: fontSize,
+        bold,
+        '@ctype': 'nodeStyle',
+      },
+      '@ctype': 'textNode',
+    }],
+    style: {
+      align,
+      lineHeight,
+      '@ctype': 'paragraphStyle',
+    },
+    '@ctype': 'paragraph',
+  }],
+  '@ctype': ctype,
+});
+
+const createImageComponent = (imgData) => ({
+  id: seId(),
+  layout: 'default',
+  align: 'center',
+  src: `https://blogfiles.pstatic.net/${imgData.url}?type=w1`,
+  internalResource: 'true',
+  represent: imgData.represent || 'false',
+  path: imgData.url,
+  domain: 'https://blogfiles.pstatic.net',
+  fileSize: imgData.fileSize,
+  width: imgData.width,
+  widthPercentage: 0,
+  height: imgData.height,
+  originalWidth: imgData.width,
+  originalHeight: imgData.height,
+  fileName: imgData.fileName,
+  caption: null,
+  format: 'normal',
+  displayFormat: 'normal',
+  imageLoaded: 'true',
+  contentMode: 'normal',
+  origin: {
+    srcFrom: 'local',
+    '@ctype': 'imageOrigin',
+  },
+  ai: 'false',
+  '@ctype': 'image',
+});
+
+const stripHtmlTags = (html) => html.replace(/<[^>]*>/g, '');
+
+/**
+ * HTML을 네이버 에디터 컴포넌트 배열로 변환한다.
+ * Primary: 네이버 API (upconvert.editor.naver.com)
+ * Fallback: 커스텀 파싱
+ */
+const convertHtmlToEditorComponents = async (naverApi, html, imageComponents = []) => {
+  // 1. 네이버 API 변환 시도
+  const apiComponents = await naverApi.convertHtmlToComponents(html);
+  if (Array.isArray(apiComponents) && apiComponents.length > 0) {
+    // 이미지를 글 맨 위에 배치 (티스토리 스타일)
+    return [...imageComponents, ...apiComponents];
+  }
+
+  // 2. Fallback: 커스텀 파싱 (이미지를 글 맨 위에 배치)
+  const textComponents = parseHtmlToComponents(html, []);
+  return [...imageComponents, ...textComponents];
+};
+
+/**
+ * HTML을 수동으로 파싱하여 네이버 에디터 컴포넌트로 변환한다.
+ * Python의 process_html_to_components() 포팅
+ */
+const parseHtmlToComponents = (html, imageComponents = []) => {
+  // heading(h1-h6) 또는 strong 태그 기준으로 분할
+  const segments = html.split(/(<h[1-6][^>]*>.*?<\/h[1-6]>|<strong>.*?<\/strong>)/is);
+  const components = [];
+  const images = [...imageComponents];
+  let firstHeadingSeen = false;
+
+  for (const segment of segments) {
+    const trimmed = segment.trim();
+    if (!trimmed) continue;
+
+    const isHeading = /^<h[1-6]/i.test(trimmed);
+    const isStrong = /<strong>/i.test(trimmed);
+    const isBoldSection = isHeading || isStrong;
+
+    // heading 태그 자체는 건너뛰기 (Python 코드의 continue와 동일)
+    if (/^<h[1-6][^>]*>.*<\/h[1-6]>$/is.test(trimmed)) {
+      const text = stripHtmlTags(trimmed);
+      if (!text.trim()) continue;
+
+      if (!firstHeadingSeen) {
+        firstHeadingSeen = true;
+        components.push(createTextComponent(text, {
+          fontSize: 'fs38',
+          bold: 'true',
+          align: 'center',
+          lineHeight: '2.1',
+          ctype: 'text',
+        }));
+      } else {
+        // 이미지 삽입
+        if (images.length > 0) {
+          components.push(images.shift());
+        }
+        components.push(createTextComponent(text, {
+          fontSize: 'fs24',
+          bold: 'true',
+          align: 'center',
+          ctype: 'quotation',
+        }));
+      }
+      continue;
+    }
+
+    // 일반 텍스트 세그먼트
+    const text = stripHtmlTags(trimmed);
+    if (!text.trim()) continue;
+
+    if (isBoldSection && !firstHeadingSeen) {
+      firstHeadingSeen = true;
+      components.push(createTextComponent(text, {
+        fontSize: 'fs24',
+        bold: 'true',
+        lineHeight: '2.1',
+      }));
+    } else if (isBoldSection) {
+      if (images.length > 0) {
+        components.push(images.shift());
+      }
+      components.push(createTextComponent(text, {
+        fontSize: 'fs24',
+        bold: 'true',
+        ctype: 'quotation',
+      }));
+    } else {
+      // 일반 단락: <p> 또는 <br> 기준으로 분할
+      const paragraphs = text.split(/\n+/).filter((p) => p.trim());
+      for (const para of paragraphs) {
+        components.push(createTextComponent(para.trim()));
+      }
+    }
+  }
+
+  // 남은 이미지 append
+  for (const img of images) {
+    components.push(img);
+  }
+
+  return components;
+};
+
+/**
+ * API 반환 컴포넌트 사이에 이미지를 삽입한다.
+ */
+const intersperse = (components, imageComponents) => {
+  if (!imageComponents.length) return components;
+
+  const result = [];
+  const images = [...imageComponents];
+  let headingCount = 0;
+
+  for (const comp of components) {
+    const isQuotation = comp['@ctype'] === 'quotation';
+    if (isQuotation && headingCount > 0 && images.length > 0) {
+      result.push(images.shift());
+    }
+    if (isQuotation) headingCount++;
+    result.push(comp);
+  }
+
+  // 남은 이미지 append
+  for (const img of images) {
+    result.push(img);
+  }
+
+  return result;
+};
+
+module.exports = {
+  convertHtmlToEditorComponents,
+  parseHtmlToComponents,
+  createTextComponent,
+  createImageComponent,
+  seId,
+};

package/src/providers/naver/imageUpload.js

@@ -0,0 +1,111 @@
+const fs = require('fs');
+const path = require('path');
+const { createImageComponent } = require('./editorConvert');
+const { buildKeywordImageCandidates } = require('../tistory/imageSources');
+
+/**
+ * 이미지 URL 또는 로컬 경로에서 이미지 버퍼를 가져온다.
+ */
+const fetchImageBuffer = async (source) => {
+  if (fs.existsSync(source)) {
+    return {
+      buffer: fs.readFileSync(source),
+      filename: path.basename(source),
+    };
+  }
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 20000);
+  try {
+    const response = await fetch(source, {
+      redirect: 'follow',
+      signal: controller.signal,
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
+        Accept: 'image/avif,image/webp,image/apng,image/*,*/*;q=0.8',
+      },
+    });
+    if (!response.ok) {
+      throw new Error(`이미지 다운로드 실패: ${response.status} — ${source}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const urlPath = new URL(response.url || source).pathname;
+    const filename = path.basename(urlPath) || 'image.jpg';
+    return {
+      buffer: Buffer.from(arrayBuffer),
+      filename,
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+};
+
+/**
+ * 이미지 소스들을 네이버에 업로드하고 에디터 컴포넌트 배열로 반환한다.
+ */
+const uploadAndCreateImageComponents = async (naverApi, imageSources, token) => {
+  const components = [];
+  const errors = [];
+
+  for (let i = 0; i < imageSources.length; i++) {
+    const source = imageSources[i];
+    try {
+      const { buffer, filename } = await fetchImageBuffer(source);
+      const imgData = await naverApi.uploadImage(buffer, filename, token);
+      if (imgData) {
+        imgData.represent = i === 0 ? 'true' : 'false';
+        components.push(createImageComponent(imgData));
+      }
+    } catch (error) {
+      errors.push({ source, error: error.message });
+    }
+  }
+
+  return { components, errors };
+};
+
+/**
+ * relatedImageKeywords에서 이미지를 검색하고, imageUrls와 합쳐서 업로드한다.
+ * 티스토리 imageSources.js의 buildKeywordImageCandidates를 재사용한다.
+ */
+const collectAndUploadImages = async (naverApi, {
+  imageUrls = [],
+  relatedImageKeywords = [],
+  token,
+  imageUploadLimit = 2,
+}) => {
+  const collectedUrls = [...imageUrls];
+
+  // 키워드에서 이미지 URL 검색
+  const normalizedKeywords = Array.isArray(relatedImageKeywords)
+    ? relatedImageKeywords.map((k) => String(k || '').trim()).filter(Boolean)
+    : String(relatedImageKeywords || '').split(',').map((k) => k.trim()).filter(Boolean);
+
+  for (const keyword of normalizedKeywords) {
+    if (collectedUrls.length >= imageUploadLimit) break;
+    try {
+      const candidates = await buildKeywordImageCandidates(keyword);
+      for (const candidate of candidates) {
+        if (collectedUrls.length >= imageUploadLimit) break;
+        if (!collectedUrls.includes(candidate)) {
+          collectedUrls.push(candidate);
+        }
+      }
+    } catch {
+      // 검색 실패 시 무시
+    }
+  }
+
+  const limitedUrls = collectedUrls.slice(0, imageUploadLimit);
+  if (limitedUrls.length === 0) {
+    return { components: [], errors: [] };
+  }
+
+  return uploadAndCreateImageComponents(naverApi, limitedUrls, token);
+};
+
+module.exports = {
+  fetchImageBuffer,
+  uploadAndCreateImageComponents,
+  collectAndUploadImages,
+};

package/src/providers/naver/index.js

@@ -0,0 +1,253 @@
+const { saveProviderMeta, clearProviderMeta, getProviderMeta } = require('../../storage/sessionStore');
+const createNaverApiClient = require('../../services/naverApiClient');
+const {
+  readNaverCredentials,
+  normalizeNaverTagList,
+  mapNaverVisibility,
+} = require('./utils');
+const { convertHtmlToEditorComponents } = require('./editorConvert');
+const { collectAndUploadImages } = require('./imageUpload');
+const { createNaverWithProviderSession } = require('./session');
+const { importSessionFromChrome } = require('./chromeImport');
+const { createAskForAuthentication } = require('./auth');
+
+const createNaverProvider = ({ sessionPath }) => {
+  const naverApi = createNaverApiClient({ sessionPath });
+
+  const askForAuthentication = createAskForAuthentication({
+    sessionPath,
+    naverApi,
+  });
+
+  const withProviderSession = createNaverWithProviderSession(askForAuthentication);
+
+  return {
+    id: 'naver',
+    name: 'Naver',
+
+    async authStatus() {
+      return withProviderSession(async () => {
+        try {
+          const blogId = await naverApi.initBlog();
+          return {
+            provider: 'naver',
+            loggedIn: true,
+            blogId,
+            blogUrl: `https://blog.naver.com/${blogId}`,
+            sessionPath,
+            metadata: getProviderMeta('naver') || {},
+          };
+        } catch (error) {
+          return {
+            provider: 'naver',
+            loggedIn: false,
+            sessionPath,
+            error: error.message,
+            metadata: getProviderMeta('naver') || {},
+          };
+        }
+      });
+    },
+
+    async login({
+      headless = false,
+      manual = false,
+      username,
+      password,
+      fromChrome,
+      profile,
+    } = {}) {
+      if (fromChrome) {
+        await importSessionFromChrome(sessionPath, profile || 'Default');
+        naverApi.resetState();
+        const blogId = await naverApi.initBlog();
+        const result = {
+          provider: 'naver',
+          loggedIn: true,
+          blogId,
+          blogUrl: `https://blog.naver.com/${blogId}`,
+          sessionPath,
+          source: 'chrome-import',
+        };
+        saveProviderMeta('naver', { loggedIn: true, blogId, blogUrl: result.blogUrl, sessionPath });
+        return result;
+      }
+
+      const creds = readNaverCredentials();
+      const resolved = {
+        headless,
+        manual,
+        username: username || creds.username,
+        password: password || creds.password,
+      };
+
+      if (!resolved.manual && (!resolved.username || !resolved.password)) {
+        throw new Error('네이버 자동 로그인을 진행하려면 username/password가 필요합니다. 환경변수 NAVER_USERNAME / NAVER_PASSWORD를 설정하거나 --manual 모드를 사용해 주세요.');
+      }
+
+      const result = await askForAuthentication(resolved);
+      saveProviderMeta('naver', {
+        loggedIn: result.loggedIn,
+        blogId: result.blogId,
+        blogUrl: result.blogUrl,
+        sessionPath: result.sessionPath,
+      });
+      return result;
+    },
+
+    async publish(payload) {
+      return withProviderSession(async () => {
+        const title = payload.title || '제목 없음';
+        const rawContent = payload.content || '';
+        const openType = mapNaverVisibility(payload.visibility);
+        const tags = normalizeNaverTagList(payload.tags);
+        const imageUrls = payload.imageUrls || [];
+        const relatedImageKeywords = payload.relatedImageKeywords || [];
+        const autoUploadImages = payload.autoUploadImages !== false;
+        const imageUploadLimit = Number(payload.imageUploadLimit) || 2;
+
+        await naverApi.initBlog();
+        const rawCategories = await naverApi.getCategories();
+        const categories = Object.entries(rawCategories).map(([name, id]) => ({ name, id: Number(id) })).sort((a, b) => a.id - b.id);
+
+        // 카테고리 결정
+        let categoryNo = payload.category;
+        if (categoryNo === undefined || categoryNo === null || String(categoryNo).trim() === '') {
+          if (categories.length === 0) {
+            categoryNo = '0';
+          } else if (categories.length === 1) {
+            categoryNo = String(categories[0].id);
+          } else {
+            return {
+              provider: 'naver',
+              mode: 'publish',
+              status: 'need_category',
+              loggedIn: true,
+              title,
+              openType,
+              tags,
+              message: '발행을 위해 카테고리가 필요합니다. categories를 확인하고 category를 지정해 주세요.',
+              categories,
+            };
+          }
+        }
+        categoryNo = String(categoryNo);
+
+        // 이미지 업로드 (imageUrls + relatedImageKeywords 기반 자동 검색)
+        let imageComponents = [];
+        const hasImageSources = imageUrls.length > 0 || relatedImageKeywords.length > 0;
+        if (autoUploadImages && hasImageSources) {
+          const token = await naverApi.getToken(categoryNo);
+          const uploadResult = await collectAndUploadImages(naverApi, {
+            imageUrls,
+            relatedImageKeywords,
+            token,
+            imageUploadLimit,
+          });
+          imageComponents = uploadResult.components;
+        }
+
+        // HTML → 에디터 컴포넌트 변환
+        const contentComponents = await convertHtmlToEditorComponents(naverApi, rawContent, imageComponents);
+
+        const result = await naverApi.publishPost({
+          title,
+          content: contentComponents,
+          categoryNo,
+          tags,
+          openType,
+        });
+
+        return {
+          provider: 'naver',
+          mode: 'publish',
+          title,
+          category: categoryNo,
+          openType,
+          tags,
+          imageCount: imageComponents.length,
+          url: result.entryUrl || null,
+          raw: result,
+        };
+      });
+    },
+
+    async saveDraft(payload) {
+      // 네이버는 임시저장 API가 없으므로 비공개(openType: 0)로 발행
+      return this.publish({
+        ...payload,
+        visibility: 'private',
+      });
+    },
+
+    async listCategories() {
+      return withProviderSession(async () => {
+        await naverApi.initBlog();
+        const rawCategories = await naverApi.getCategories();
+        return {
+          provider: 'naver',
+          categories: Object.entries(rawCategories).map(([name, id]) => ({
+            name,
+            id: Number(id),
+          })),
+        };
+      });
+    },
+
+    async listPosts({ limit = 20 } = {}) {
+      return withProviderSession(async () => {
+        await naverApi.initBlog();
+        const result = await naverApi.getPosts({ countPerPage: Math.max(1, Number(limit) || 20) });
+        const items = Array.isArray(result?.items) ? result.items : [];
+        return {
+          provider: 'naver',
+          totalCount: result.totalCount || items.length,
+          posts: items.slice(0, Math.max(1, Number(limit) || 20)),
+        };
+      });
+    },
+
+    async getPost({ postId } = {}) {
+      return withProviderSession(async () => {
+        const resolvedPostId = String(postId || '').trim();
+        if (!resolvedPostId) {
+          return {
+            provider: 'naver',
+            mode: 'post',
+            status: 'invalid_post_id',
+            message: 'postId가 필요합니다.',
+          };
+        }
+
+        await naverApi.initBlog();
+        const post = await naverApi.getPost({ postId: resolvedPostId });
+        if (!post) {
+          return {
+            provider: 'naver',
+            mode: 'post',
+            status: 'not_found',
+            postId: resolvedPostId,
+            message: '해당 postId의 글을 찾을 수 없습니다.',
+          };
+        }
+        return {
+          provider: 'naver',
+          mode: 'post',
+          postId: resolvedPostId,
+          post,
+        };
+      });
+    },
+
+    async logout() {
+      clearProviderMeta('naver');
+      return {
+        provider: 'naver',
+        loggedOut: true,
+        sessionPath,
+      };
+    },
+  };
+};
+
+module.exports = createNaverProvider;

package/src/providers/naver/selectors.js

@@ -0,0 +1,23 @@
+const NAVER_LOGIN_SELECTORS = {
+  username: '#id',
+  password: '#pw',
+  submit: '#log\\.login',
+  keepLogin: '.keep_check',
+};
+
+const NAVER_LOGIN_ERROR_PATTERNS = {
+  wrongPassword: '비밀번호가 잘못',
+  accountProtected: '회원님의 아이디를 보호',
+  phoneNumberMismatch: '등록된 정보와 일치하지',
+  regionBlocked: '허용하지 않은 지역에서',
+  captcha: ['자동입력 방지 문자', '자동입력 방지문자', 'captcha'],
+  usageRestricted: '비정상적인 활동이 감지되어',
+  twoFactor: '2단계 인증 알림',
+  operationViolation: '운영원칙 위반',
+  newDevice: '새로운 기기(브라우저)에서 로그인되었습니다.',
+};
+
+module.exports = {
+  NAVER_LOGIN_SELECTORS,
+  NAVER_LOGIN_ERROR_PATTERNS,
+};

package/src/providers/naver/session.js

@@ -0,0 +1,119 @@
+const fs = require('fs');
+const path = require('path');
+const { saveProviderMeta } = require('../../storage/sessionStore');
+const { readNaverCredentials, parseNaverSessionError, buildLoginErrorMessage } = require('./utils');
+
+const NAVER_COOKIE_DOMAINS = ['https://www.naver.com', 'https://nid.naver.com', 'https://blog.naver.com'];
+
+const isLoggedInByCookies = async (context) => {
+  for (const domain of NAVER_COOKIE_DOMAINS) {
+    const cookies = await context.cookies(domain);
+    const hasAuth = cookies.some((c) => c.name === 'NID_AUT' || c.name === 'NID_SES');
+    if (hasAuth) return true;
+  }
+  return false;
+};
+
+const persistNaverSession = async (context, targetSessionPath) => {
+  const allCookies = [];
+  for (const domain of NAVER_COOKIE_DOMAINS) {
+    const cookies = await context.cookies(domain);
+    allCookies.push(...cookies);
+  }
+
+  // 중복 제거 (name+domain 기준)
+  const seen = new Set();
+  const unique = allCookies.filter((c) => {
+    const key = `${c.name}@${c.domain}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+
+  const sanitized = unique.map((cookie) => ({
+    ...cookie,
+    expires: Number(cookie.expires || -1),
+    size: undefined,
+    partitionKey: undefined,
+    sourcePort: undefined,
+    sourceScheme: undefined,
+  }));
+
+  const payload = {
+    cookies: sanitized,
+    updatedAt: new Date().toISOString(),
+  };
+  await fs.promises.mkdir(path.dirname(targetSessionPath), { recursive: true });
+  await fs.promises.writeFile(targetSessionPath, JSON.stringify(payload, null, 2), 'utf-8');
+};
+
+const validateNaverSession = async (sessionPath) => {
+  if (!fs.existsSync(sessionPath)) return false;
+
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
+  } catch {
+    return false;
+  }
+
+  const cookies = Array.isArray(raw?.cookies) ? raw.cookies : [];
+  return cookies.some((c) => c.name === 'NID_AUT' && c.value) &&
+    cookies.some((c) => c.name === 'NID_SES' && c.value);
+};
+
+const createNaverWithProviderSession = (askForAuthentication) => async (fn) => {
+  const credentials = readNaverCredentials();
+  const hasCredentials = Boolean(credentials.username && credentials.password);
+
+  try {
+    const result = await fn();
+    saveProviderMeta('naver', {
+      loggedIn: true,
+      lastValidatedAt: new Date().toISOString(),
+    });
+    return result;
+  } catch (error) {
+    if (!parseNaverSessionError(error) || !hasCredentials) {
+      throw error;
+    }
+
+    try {
+      const loginResult = await askForAuthentication({
+        headless: false,
+        manual: false,
+        username: credentials.username,
+        password: credentials.password,
+      });
+
+      saveProviderMeta('naver', {
+        loggedIn: loginResult.loggedIn,
+        blogId: loginResult.blogId,
+        blogUrl: loginResult.blogUrl,
+        sessionPath: loginResult.sessionPath,
+        lastRefreshedAt: new Date().toISOString(),
+        lastError: null,
+      });
+
+      if (!loginResult.loggedIn) {
+        throw new Error(loginResult.message || '세션 갱신 후 로그인 상태가 확인되지 않았습니다.');
+      }
+
+      return fn();
+    } catch (reloginError) {
+      saveProviderMeta('naver', {
+        loggedIn: false,
+        lastError: buildLoginErrorMessage(reloginError),
+        lastValidatedAt: new Date().toISOString(),
+      });
+      throw reloginError;
+    }
+  }
+};
+
+module.exports = {
+  isLoggedInByCookies,
+  persistNaverSession,
+  validateNaverSession,
+  createNaverWithProviderSession,
+};