viruagent-cli 0.2.0

package/src/runner.js

@@ -0,0 +1,175 @@
+const fs = require('fs');
+const path = require('path');
+
+const os = require('os');
+
+const { createProviderManager } = require('./services/providerManager');
+
+const parseList = (value) =>
+  String(value || '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+
+const parseIntOrNull = (value) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? Math.trunc(parsed) : null;
+};
+
+const readContent = (opts) => {
+  if (opts.contentFile) {
+    const fullPath = path.resolve(process.cwd(), String(opts.contentFile));
+    if (!fs.existsSync(fullPath)) {
+      const err = new Error(`File not found: ${opts.contentFile}`);
+      err.code = 'FILE_NOT_FOUND';
+      throw err;
+    }
+    return fs.readFileSync(fullPath, 'utf-8');
+  }
+  return String(opts.content || '');
+};
+
+const createError = (code, message, hint) => {
+  const err = new Error(message);
+  err.code = code;
+  if (hint) err.hint = hint;
+  return err;
+};
+
+// Write commands that support --dry-run
+const WRITE_COMMANDS = new Set(['publish', 'save-draft', 'login', 'logout']);
+
+const runCommand = async (command, opts = {}) => {
+  // --dry-run support for write commands
+  if (opts.dryRun && WRITE_COMMANDS.has(command)) {
+    return { dryRun: true, command, params: { ...opts, dryRun: undefined } };
+  }
+
+  if (command === 'install-skill') {
+    const skillSrc = path.resolve(__dirname, '..', 'skills', 'viruagent.md');
+    if (!fs.existsSync(skillSrc)) {
+      throw createError('FILE_NOT_FOUND', 'Skill file not found in package');
+    }
+
+    // Detect target: Claude Code (~/.claude/commands/) or custom
+    const targetDir = opts.target
+      || path.join(os.homedir(), '.claude', 'commands');
+    fs.mkdirSync(targetDir, { recursive: true });
+
+    const dest = path.join(targetDir, 'viruagent.md');
+    fs.copyFileSync(skillSrc, dest);
+    return { installed: true, path: dest };
+  }
+
+  const manager = createProviderManager();
+
+  if (command === 'list-providers') {
+    return { providers: manager.getAvailableProviders() };
+  }
+
+  const providerName = opts.provider || 'tistory';
+  let provider;
+  try {
+    provider = manager.getProvider(providerName);
+  } catch {
+    throw createError(
+      'PROVIDER_NOT_FOUND',
+      `Unknown provider: ${providerName}`,
+      'viruagent-cli list-providers'
+    );
+  }
+
+  const withProvider = (fn) => async () => {
+    const result = await fn();
+    return { provider: providerName, ...result };
+  };
+
+  switch (command) {
+    case 'status':
+    case 'auth-status':
+      return withProvider(() => provider.authStatus())();
+
+    case 'login':
+      return withProvider(() =>
+        provider.login({
+          headless: Boolean(opts.headless),
+          manual: Boolean(opts.manual),
+          username: opts.username || undefined,
+          password: opts.password || undefined,
+          twoFactorCode: opts.twoFactorCode || undefined,
+        })
+      )();
+
+    case 'publish': {
+      const content = readContent(opts);
+      if (!content) {
+        throw createError('MISSING_CONTENT', 'publish requires --content or --content-file', 'viruagent-cli publish --spec');
+      }
+      return withProvider(() =>
+        provider.publish({
+          title: opts.title || '',
+          content,
+          visibility: opts.visibility || 'public',
+          category: parseIntOrNull(opts.category),
+          tags: opts.tags || '',
+          thumbnail: opts.thumbnail || undefined,
+          relatedImageKeywords: parseList(opts.relatedImageKeywords),
+          enforceSystemPrompt: opts.enforceSystemPrompt !== false,
+          imageUrls: parseList(opts.imageUrls),
+          imageUploadLimit: parseIntOrNull(opts.imageUploadLimit) || 1,
+          minimumImageCount: parseIntOrNull(opts.minimumImageCount) || 1,
+          autoUploadImages: opts.autoUploadImages !== false,
+        })
+      )();
+    }
+
+    case 'save-draft': {
+      const content = readContent(opts);
+      if (!content) {
+        throw createError('MISSING_CONTENT', 'save-draft requires --content or --content-file', 'viruagent-cli save-draft --spec');
+      }
+      return withProvider(() =>
+        provider.saveDraft({
+          title: opts.title || '',
+          content,
+          relatedImageKeywords: parseList(opts.relatedImageKeywords),
+          enforceSystemPrompt: opts.enforceSystemPrompt !== false,
+          imageUrls: parseList(opts.imageUrls),
+          imageUploadLimit: parseIntOrNull(opts.imageUploadLimit) || 1,
+          minimumImageCount: parseIntOrNull(opts.minimumImageCount) || 1,
+          autoUploadImages: opts.autoUploadImages !== false,
+          tags: opts.tags || '',
+          category: parseIntOrNull(opts.category),
+        })
+      )();
+    }
+
+    case 'list-categories':
+      return withProvider(() => provider.listCategories())();
+
+    case 'list-posts':
+      return withProvider(() =>
+        provider.listPosts({ limit: parseIntOrNull(opts.limit) || 20 })
+      )();
+
+    case 'read-post': {
+      if (!opts.postId) {
+        throw createError('INVALID_POST_ID', 'read-post requires --post-id', 'viruagent-cli read-post --spec');
+      }
+      return withProvider(() =>
+        provider.getPost({
+          postId: opts.postId,
+          includeDraft: Boolean(opts.includeDraft),
+        })
+      )();
+    }
+
+    case 'logout':
+      return withProvider(() => provider.logout())();
+
+    default:
+      throw createError('UNKNOWN_COMMAND', `Unknown command: ${command}`, 'viruagent-cli --spec');
+  }
+};
+
+module.exports = { runCommand };

package/src/services/providerManager.js

@@ -0,0 +1,43 @@
+const path = require('path');
+const { getSessionPath } = require('../storage/sessionStore');
+const createTistoryProvider = require('../providers/tistoryProvider');
+const createNaverProvider = require('../providers/naverProvider');
+
+const providerFactory = {
+  tistory: createTistoryProvider,
+  naver: createNaverProvider,
+};
+
+const providers = ['tistory', 'naver'];
+
+const createProviderManager = () => {
+  const cache = new Map();
+
+  const getProvider = (provider = 'tistory') => {
+    const normalized = String(provider || 'tistory').toLowerCase();
+    if (!providerFactory[normalized]) {
+      throw new Error(`지원하지 않는 provider입니다: ${provider}. 가능한 값: ${providers.join(', ')}`);
+    }
+
+    if (!cache.has(normalized)) {
+      const sessionPath = getSessionPath(normalized);
+      const options = {
+        provider: normalized,
+        sessionPath,
+      };
+      const providerInstance = providerFactory[normalized](options);
+      cache.set(normalized, providerInstance);
+    }
+
+    return cache.get(normalized);
+  };
+
+  const getAvailableProviders = () => providers.map((provider) => ({
+    id: provider,
+    name: provider === 'tistory' ? 'Tistory' : 'Naver Blog',
+  }));
+
+  return { getProvider, getAvailableProviders };
+};
+
+module.exports = { createProviderManager };

package/src/services/tistoryApiClient.js

@@ -0,0 +1,330 @@
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+
+const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36';
+const API_HOST = 'https://www.tistory.com';
+
+const getTimeout = () => 20000;
+
+const normalizeCookies = (session) => {
+  if (!session) {
+    return [];
+  }
+
+  const rawCookies = Array.isArray(session)
+    ? session
+    : Array.isArray(session.cookies)
+      ? session.cookies
+      : [];
+
+  return rawCookies
+    .filter((cookie) => cookie && typeof cookie === 'object')
+    .filter((cookie) => cookie.name && cookie.value !== undefined && cookie.value !== null)
+    .filter((cookie) => {
+      if (!cookie.domain) return true;
+      return String(cookie.domain).includes('tistory') || String(cookie.domain).includes('tistory.com');
+    })
+    .map((cookie) => `${cookie.name}=${cookie.value}`);
+};
+
+const readSessionCookies = (sessionPath) => {
+  const resolvedPath = path.resolve(sessionPath);
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`세션 파일이 없습니다. ${resolvedPath}에 로그인 정보를 먼저 저장하세요.`);
+  }
+
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(resolvedPath, 'utf-8'));
+  } catch (error) {
+    throw new Error(`세션 파일 파싱 실패: ${error.message}`);
+  }
+
+  const cookies = normalizeCookies(raw);
+  if (!cookies.length) {
+    throw new Error('세션에 유효한 쿠키가 없습니다. 다시 로그인해 주세요.');
+  }
+
+  return cookies.join('; ');
+};
+
+const buildReferer = (base) => `${base}/newpost`;
+
+const createFetchController = () => {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), getTimeout());
+  return { controller, timeout };
+};
+
+const createTistoryApiClient = ({ sessionPath }) => {
+  let blogName = null;
+  let blogInfo = null;
+
+  const resetState = () => {
+    blogName = null;
+    blogInfo = null;
+  };
+
+  const getSessionCookies = () => readSessionCookies(sessionPath);
+
+  const getBase = () => {
+    if (!blogName) {
+      throw new Error('블로그 이름이 초기화되지 않았습니다. initBlog()를 먼저 호출하세요.');
+    }
+    return `https://${blogName}.tistory.com/manage`;
+  };
+
+  const getHeaders = (baseOverride) => {
+    const base = baseOverride || getBase();
+    return {
+      Cookie: getSessionCookies(),
+      'Content-Type': 'application/json;charset=UTF-8',
+      'User-Agent': USER_AGENT,
+      Referer: buildReferer(base),
+      'X-Requested-With': 'XMLHttpRequest',
+    };
+  };
+
+  const normalizeTagPayload = (value = '') => {
+    const values = Array.isArray(value)
+      ? value
+      : String(value || '').replace(/\r?\n/g, ',').split(',');
+
+    return values
+      .map((tag) => String(tag || '').trim())
+      .filter(Boolean)
+      .map((tag) => tag.replace(/["']/g, '').trim())
+      .filter(Boolean)
+      .slice(0, 10)
+      .join(',');
+  };
+
+  const normalizeThumbnail = (value = '') => {
+    const normalized = String(value || '').trim().replace(/^kage@/i, '').split(/[?#]/)[0].trim();
+    if (!normalized) return null;
+    if (/^https?:\/\//i.test(normalized)) {
+      return normalized;
+    }
+
+    if (/\/[^/]+\.[A-Za-z0-9]+$/u.test(normalized)) {
+      return `kage@${normalized}`;
+    }
+
+    const suffix = normalized.endsWith('/') ? 'img.jpg' : '/img.jpg';
+    return `kage@${normalized}${suffix}`;
+  };
+
+  const requestJson = async (url, options = {}) => {
+    const { controller, timeout } = createFetchController();
+    try {
+      const response = await fetch(url, {
+        redirect: 'follow',
+        signal: controller.signal,
+        ...options,
+      });
+      if (!response.ok) {
+        let detail = '';
+        try {
+          detail = await response.text();
+          detail = detail ? `: ${detail.slice(0, 200)}` : '';
+        } catch {
+          detail = '';
+        }
+        throw new Error(`요청 실패: ${response.status} ${response.statusText}${detail}`);
+      }
+      return response.json();
+    } finally {
+      clearTimeout(timeout);
+    }
+  };
+
+  const requestText = async (url, options = {}) => {
+    const { controller, timeout } = createFetchController();
+    try {
+      const response = await fetch(url, {
+        redirect: 'follow',
+        signal: controller.signal,
+        ...options,
+      });
+      if (!response.ok) {
+        throw new Error(`요청 실패: ${response.status} ${response.statusText}`);
+      }
+      return response.text();
+    } finally {
+      clearTimeout(timeout);
+    }
+  };
+
+  const flattenCategories = (tree = [], collector = {}) => {
+    for (const item of tree) {
+      if (!item || typeof item !== 'object') continue;
+      collector[item.label] = Number(item.id);
+      if (Array.isArray(item.children) && item.children.length > 0) {
+        flattenCategories(item.children, collector);
+      }
+    }
+    return collector;
+  };
+
+  const initBlog = async () => {
+    if (blogName) return blogName;
+
+    const headers = {
+      Cookie: getSessionCookies(),
+      'User-Agent': USER_AGENT,
+      Referer: `${API_HOST}/manage`,
+    };
+
+    const response = await fetch(`${API_HOST}/legacy/member/blog/api/myBlogs`, {
+      headers,
+      redirect: 'follow',
+    });
+    if (!response.ok) {
+      throw new Error(`블로그 정보 조회 실패: ${response.status}`);
+    }
+
+    const contentType = response.headers.get('content-type') || '';
+    if (!contentType.includes('application/json')) {
+      throw new Error('세션이 만료되었습니다. /auth/login으로 다시 로그인하세요.');
+    }
+
+    const json = await response.json();
+    const defaultBlog = (json?.data || []).find((blog) => blog?.defaultBlog) || (json?.data || [])[0];
+    if (!defaultBlog) {
+      throw new Error('블로그를 찾을 수 없습니다.');
+    }
+
+    blogName = defaultBlog.name;
+    blogInfo = defaultBlog;
+    return blogName;
+  };
+
+  const publishPost = async ({ title, content, visibility = 20, category = 0, tag = '', thumbnail = null }) => {
+    const base = getBase();
+    const normalizedTag = normalizeTagPayload(tag);
+    const normalizedThumbnail = normalizeThumbnail(thumbnail);
+    const body = {
+      id: '0',
+      title,
+      content,
+      visibility,
+      category,
+      tag: normalizedTag,
+      published: 1,
+      type: 'post',
+      uselessMarginForEntry: 1,
+      cclCommercial: 0,
+      cclDerive: 0,
+      attachments: [],
+      recaptchaValue: '',
+      draftSequence: null,
+      ...(normalizedThumbnail ? { thumbnail: normalizedThumbnail } : {}),
+    };
+
+    return requestJson(`${base}/post.json`, {
+      method: 'POST',
+      headers: getHeaders(base),
+      body: JSON.stringify(body),
+    });
+  };
+
+  const saveDraft = async ({ title, content }) => {
+    const base = getBase();
+    return requestJson(`${base}/drafts`, {
+      method: 'POST',
+      headers: getHeaders(base),
+      body: JSON.stringify({ title, content }),
+    });
+  };
+
+  const getPosts = async () => {
+    const base = getBase();
+    return requestJson(`${base}/posts.json`, {
+      method: 'GET',
+      headers: getHeaders(base),
+    });
+  };
+
+  const getCategories = async () => {
+    const base = getBase();
+    const html = await requestText(`${base}/newpost`, {
+      method: 'GET',
+      headers: getHeaders(base),
+    });
+
+    const match = html.match(/window\.Config\s*=\s*(\{[\s\S]*?\})\s*(?:\n|;)/);
+    if (!match) {
+      throw new Error('카테고리 파싱 실패');
+    }
+
+    const sandbox = {};
+    vm.runInNewContext(`var result = ${match[1]};`, sandbox);
+    const rootCategories = sandbox?.result?.blog?.categories;
+    if (!Array.isArray(rootCategories)) {
+      throw new Error('카테고리 파싱 실패');
+    }
+
+    return flattenCategories(rootCategories, {});
+  };
+
+  const uploadImage = async (imageBuffer, filename = 'image.jpg') => {
+    const base = getBase();
+    const formData = new FormData();
+    const blob = new Blob([imageBuffer], { type: 'image/jpeg' });
+    formData.append('file', blob, filename);
+
+    const response = await fetch(`${base}/post/attach.json`, {
+      method: 'POST',
+      headers: {
+        Cookie: getSessionCookies(),
+        'User-Agent': USER_AGENT,
+        Referer: buildReferer(base),
+        Accept: 'application/json, text/plain, */*',
+      },
+      body: formData,
+    });
+
+    if (!response.ok) {
+      const text = await response.text().catch(() => '');
+      throw new Error(`이미지 업로드 실패: ${response.status} ${text ? `: ${text.slice(0, 500)}` : ''}`);
+    }
+
+    const uploaded = await response.json();
+    if (!uploaded?.url) {
+      throw new Error('이미지 업로드 응답에 URL이 없습니다.');
+    }
+    return uploaded;
+  };
+
+  const getPost = async ({ postId, includeDraft = false } = {}) => {
+    const normalizedPostId = String(postId || '').trim();
+    if (!normalizedPostId) {
+      return null;
+    }
+
+    const result = await getPosts();
+    const candidates = [];
+    if (Array.isArray(result?.items)) {
+      candidates.push(...result.items);
+    }
+    if (includeDraft && Array.isArray(result?.drafts)) {
+      candidates.push(...result.drafts);
+    }
+
+    return candidates.find((item) => String(item.id) === normalizedPostId) || null;
+  };
+
+  return {
+    initBlog,
+    publishPost,
+    saveDraft,
+    getPosts,
+    getCategories,
+    uploadImage,
+    getPost,
+    resetState,
+  };
+};
+
+module.exports = createTistoryApiClient;

package/src/storage/sessionStore.js

@@ -0,0 +1,67 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const BASE_DIR = path.join(os.homedir(), '.viruagent-cli');
+const SESSION_DIR = path.join(BASE_DIR, 'sessions');
+const META_FILE = path.join(BASE_DIR, 'providers.json');
+
+const ensureDir = (target) => {
+  if (!fs.existsSync(target)) fs.mkdirSync(target, { recursive: true });
+};
+
+const normalizeProvider = (provider) => String(provider || 'tistory').toLowerCase();
+
+const readJson = (target) => {
+  if (!fs.existsSync(target)) return {};
+  try {
+    const raw = fs.readFileSync(target, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+};
+
+const writeJson = (target, data) => {
+  ensureDir(path.dirname(target));
+  fs.writeFileSync(target, JSON.stringify(data, null, 2), 'utf-8');
+};
+
+const getSessionPath = (provider) => {
+  ensureDir(SESSION_DIR);
+  return path.join(SESSION_DIR, `${normalizeProvider(provider)}-session.json`);
+};
+
+const getProvidersMeta = () => {
+  ensureDir(BASE_DIR);
+  return readJson(META_FILE);
+};
+
+const saveProviderMeta = (provider, patch) => {
+  const meta = getProvidersMeta();
+  meta[normalizeProvider(provider)] = {
+    ...(meta[normalizeProvider(provider)] || {}),
+    ...patch,
+    provider: normalizeProvider(provider),
+    updatedAt: new Date().toISOString(),
+  };
+  writeJson(META_FILE, meta);
+};
+
+const getProviderMeta = (provider) => {
+  const meta = getProvidersMeta();
+  return meta[normalizeProvider(provider)] || null;
+};
+
+const clearProviderMeta = (provider) => {
+  const meta = getProvidersMeta();
+  delete meta[normalizeProvider(provider)];
+  writeJson(META_FILE, meta);
+};
+
+module.exports = {
+  getSessionPath,
+  getProviderMeta,
+  saveProviderMeta,
+  clearProviderMeta,
+};