skriptorium 0.1.1

data/lib/skriptorium/blogger/destination.rb

@@ -0,0 +1,98 @@
+require 'faraday'
+
+module Skriptorium
+  module Blogger
+    class Destination < BaseDestination
+      API_BASE = 'https://www.googleapis.com/blogger/v3'
+      TOKEN_URL = 'https://oauth2.googleapis.com/token'
+
+      def initialize(config)
+        super
+        @blog_id = config['blog_id']
+        @api_key = config['api_key']
+        @client_id = config['client_id']
+        @client_secret = config['client_secret']
+        @refresh_token = config['refresh_token']
+      end
+
+      def exists?(article, force: false)
+        response = with_cache(:articles, force: force) do
+          with_client(url: API_BASE) do |client|
+            client.get("blogs/#{@blog_id}/posts", {
+                         'key' => @api_key,
+                         'fetchBodies' => 'false',
+                         'maxResults' => 50
+                       })
+          end
+        end
+
+        return false unless response.success?
+
+        items = JSON.parse(response.body)['items'] || []
+
+        articles = items.map(&:with_indifferent_access).map(&self.class.method(:to_article))
+
+        articles.any? do |a|
+          article.same?(a)
+        end
+      end
+
+      def publish(article)
+        access_token = refresh_access_token
+        html_content = article.to_html
+
+        client = Faraday.new(url: API_BASE) do |builder|
+          builder.headers['Authorization'] = "Bearer #{access_token}"
+          builder.headers['Content-Type'] = 'application/json'
+          builder.adapter Faraday.default_adapter
+        end
+
+        payload = {
+          'kind' => 'blogger#post',
+          'blog' => { 'id' => @blog_id },
+          'title' => article.title,
+          'content' => html_content
+        }
+        payload['labels'] = article.tags if article.tags&.any?
+
+        response = client.post("blogs/#{@blog_id}/posts", JSON.generate(payload))
+
+        raise "Blogger publish error: #{response.status} - #{response.body}" unless response.success?
+
+        post = JSON.parse(response.body)
+        puts "  Published to Blogger: #{post['url']}"
+      end
+
+      private
+
+      def refresh_access_token
+        response = Faraday.post(TOKEN_URL, {
+                                  'grant_type' => 'refresh_token',
+                                  'refresh_token' => @refresh_token,
+                                  'client_id' => @client_id,
+                                  'client_secret' => @client_secret
+                                })
+
+        raise "Blogger OAuth refresh error: #{response.status} - #{response.body}" unless response.success?
+
+        JSON.parse(response.body)['access_token']
+      end
+
+      def with_client(*args, **kwargs, &block)
+        Faraday.new(*args, **kwargs) do |builder|
+          builder.headers['key'] = @api_key
+          builder.adapter Faraday.default_adapter
+        end.then(&block)
+      end
+
+      def self.to_article(item)
+        Article.new(
+          id: item['id'].to_s,
+          title: item['title'],
+          published_at: Article.parse_date(item['published']),
+          markdown: false
+        )
+      end
+    end
+  end
+end

data/lib/skriptorium/config.rb

@@ -0,0 +1,18 @@
+module Skriptorium
+  class Config
+    attr_reader :source, :destinations
+
+    def initialize(source, destinations)
+      @source = source
+      @destinations = destinations
+    end
+
+    def self.load(path)
+      content = File.read(path)
+      content = content.gsub(/\$\{(\w+)\}/) { ENV[$1] || raise("Environment variable #{$1} not set") }
+      data = YAML.safe_load(content, permitted_classes: [Date, DateTime, Time, Symbol])
+
+      new(data['source'], data['destinations'])
+    end
+  end
+end

data/lib/skriptorium/dev_to/destination.rb

@@ -0,0 +1,62 @@
+require 'faraday'
+
+module Skriptorium
+  module DevTo
+    class Destination < BaseDestination
+      def initialize(config)
+        super
+        @api_key = config['api_key']
+        @organization_id = config['organization_id']
+      end
+
+      def exists?(article, force: false)
+        response = with_cache(:articles, force: force) do
+          with_client(url: 'https://dev.to/api/') do |client|
+            client.get('articles/me.json', { 'per_page' => 20 })
+          end
+        end
+
+        return false unless response.success?
+
+        articles = JSON.parse(response.body).map(&:with_indifferent_access).map(&DevTo::Source.method(:to_article))
+
+        articles.any? do |a|
+          article.same?(a)
+        end
+      end
+
+      def publish(article)
+        raise 'Article already published!' if exists?(article, force: true)
+
+        with_client(url: 'https://dev.to/api/') do |client|
+          payload = {
+            article: {
+              title: article.title,
+              body_markdown: article.to_markdown(published: true),
+              tags: article.tags,
+              canonical_url: article.canonical_url,
+              slug: article.stable_slug,
+              published: true
+            }
+          }
+
+          payload[:article][:organization_id] = @organization_id if @organization_id
+
+          response = client.post('articles.json', JSON.generate(payload))
+
+          raise "Dev.to publish error: #{response.status} - #{response.body}" unless response.success?
+
+          puts "  Published to Dev.to: #{JSON.parse(response.body)['url']}"
+        end
+      end
+
+      def with_client(*args, **kwargs, &block)
+        Faraday.new(*args, **kwargs) do |builder|
+          builder.headers['api-key'] = @api_key
+          builder.headers['Content-Type'] = 'application/json'
+          builder.adapter Faraday.default_adapter
+        end.then(&block)
+      end
+    end
+  end
+end

data/lib/skriptorium/dev_to/source.rb

@@ -0,0 +1,71 @@
+require 'faraday'
+
+module Skriptorium
+  module DevTo
+    class Source < BaseSource
+      def initialize(config)
+        super
+        @username = config['username']
+        @api_key = config['api_key']
+      end
+
+      def fetch
+        items = if @api_key
+                  fetch_me_articles
+                else
+                  fetch_public_articles
+                end
+
+        Enumerator.new do |y|
+          items.each do |item|
+            y << self.class.to_article(item)
+          end
+        end
+      end
+
+      private
+
+      def fetch_me_articles
+        client = Faraday.new(url: 'https://dev.to/api/') do |builder|
+          builder.headers['api-key'] = @api_key
+          builder.adapter Faraday.default_adapter
+        end
+
+        response = client.get('articles/me.json', { 'per_page' => 20 })
+
+        raise "Dev.to API error: #{response.status} - #{response.body}" unless response.success?
+
+        JSON.parse(response.body)
+      end
+
+      def fetch_public_articles
+        client = Faraday.new(url: 'https://dev.to/api/')
+
+        list_response = client.get('articles.json', { 'username' => @username, 'per_page' => 20 })
+        raise "Dev.to API error: #{list_response.status} - #{list_response.body}" unless list_response.success?
+
+        list = JSON.parse(list_response.body)
+        list.map do |item|
+          full_response = client.get("articles/#{item['id']}.json")
+          raise "Dev.to API error fetching article #{item['id']}: #{full_response.status}" unless full_response.success?
+
+          JSON.parse(full_response.body)
+        end
+      end
+
+      def self.to_article(item)
+        Article.new(
+          id: item['id'].to_s,
+          title: item['title'],
+          content: item['body_markdown'],
+          tags: item['tags'] || item['tag_list'] || [],
+          canonical_url: item['canonical_url'] || item['url'],
+          published_at: Article.parse_date(item['published_at'] || item['published_timestamp']),
+          cover_image: item['cover_image'],
+          slug: item['slug'],
+          markdown: true
+        )
+      end
+    end
+  end
+end

data/lib/skriptorium/github_pages/destination.rb

@@ -0,0 +1,69 @@
+require 'faraday'
+require 'base64'
+
+module Skriptorium
+  module GitHubPages
+    class Destination < BaseDestination
+      def initialize(config)
+        super
+        @repo = config['repo']
+        @token = config['token']
+        @branch = config['branch'] || 'master'
+        @path = config['path'] || '_posts'
+      end
+
+      def exists?(article)
+        filename = generate_filename(article)
+
+        with_client(url: "https://api.github.com/repos/#{@repo}/contents/#{@path}/#{filename}") do |client|
+          client.get('').success?
+        end
+      end
+
+      def publish(article)
+        filename = generate_filename(article)
+        content = article.to_markdown(layout: 'post', date: article.published_at.strftime('%Y-%m-%d %H:%M:%S %z'))
+
+        with_client(url: "https://api.github.com/repos/#{@repo}/contents/#{@path}/#{filename}") do |client|
+          payload = {
+            message: "Add post: #{article.title}",
+            content: Base64.strict_encode64(content),
+            branch: @branch
+          }
+
+          response = client.put('', JSON.generate(payload))
+
+          # Если файл уже существует — GitHub требует sha для обновления
+          if !response.success? && response.status == 422
+            get_resp = client.get('')
+            if get_resp.success?
+              sha = JSON.parse(get_resp.body)['sha']
+              payload[:sha] = sha
+              payload[:message] = "Update post: #{article.title}"
+              response = client.put('', JSON.generate(payload))
+            end
+          end
+
+          raise "GitHub publish error: #{response.status} - #{response.body}" unless response.success?
+
+          puts "  Published to GitHub Pages: #{JSON.parse(response.body)['html_url']}"
+        end
+      end
+
+      private
+
+      def generate_filename(article)
+        "#{article.published_at.strftime('%Y-%m-%d')}-#{article.stable_slug}.md"
+      end
+
+      def with_client(*args, **kwargs, &block)
+        Faraday.new(*args, **kwargs) do |builder|
+          builder.headers['Authorization'] = "token #{@token}"
+          builder.headers['Content-Type'] = 'application/json'
+          builder.headers['Accept'] = 'application/vnd.github.v3+json'
+          builder.adapter Faraday.default_adapter
+        end.then(&block)
+      end
+    end
+  end
+end

data/lib/skriptorium/hashnode/destination.rb

@@ -0,0 +1,188 @@
+begin
+  require 'playwright'
+rescue LoadError
+  # playwright-ruby-client is an optional dependency
+end
+require 'faraday'
+
+module Skriptorium
+  module Hashnode
+    class Destination < BaseDestination
+      HASHNODE_DRAFTS_URL = 'https://hashnode.com/drafts'.freeze
+
+      def initialize(config)
+        super
+        @storage_state_path = config['storage_state_path']
+        @username = config['username']
+        @playwright_cli_path = config['playwright_cli_executable_path']
+      end
+
+      def exists?(article)
+        url = article_url(article)
+        puts 1111
+        puts url
+        response = Faraday.head(url, nil, { 'User-Agent' => 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36' })
+        puts response.body
+        puts response.status
+        puts 2222
+        response.success? && response.status == 200
+      rescue StandardError
+        false
+      end
+
+      def publish(article)
+        raise 'Article already published!' if exists?(article)
+
+        with_page do |page|
+          publish_via_browser(page, article)
+        end
+      end
+
+      private
+
+      def article_url(article)
+        slug = article.slug || article.stable_slug
+        "https://#{@username}.hashnode.dev/#{slug}"
+      end
+
+      def with_page
+        Playwright.create(playwright_cli_executable_path: @playwright_cli_path) do |playwright|
+          playwright.chromium.launch(headless: true) do |browser|
+            context = browser.new_context(storageState: @storage_state_path)
+            page = context.new_page
+            yield page
+          end
+        end
+      end
+
+      def publish_via_browser(page, article)
+        page.goto(HASHNODE_DRAFTS_URL)
+        page.wait_for_load_state(state: 'networkidle')
+
+        click_new(page)
+        page.wait_for_url(/\/draft\//, timeout: 15000)
+        wait_for_editor(page)
+
+        fill_title(page, article.title)
+        fill_content(page, article.content)
+
+        click_publish(page)
+
+        # Configure Discovery settings
+        configure_discovery(page, article)
+
+        puts "  Published to Hashnode: #{article_url(article)}"
+      end
+
+      def click_new(page)
+        new_btn = page.locator('button:has-text("New")').first
+        new_btn.wait_for(state: 'visible', timeout: 10000)
+        new_btn.click
+      rescue Playwright::TimeoutError
+        raise 'Hashnode: Could not find "New" button on drafts page. Check if you are logged in.'
+      end
+
+      def wait_for_editor(page)
+        page.locator('textarea[placeholder="Article Title..."]').wait_for(state: 'visible', timeout: 15000)
+      rescue Playwright::TimeoutError
+        raise 'Hashnode: Editor did not load after clicking New. Check your connection.'
+      end
+
+      def fill_title(page, title)
+        title_input = page.locator('textarea[placeholder="Article Title..."]').first
+        title_input.wait_for(state: 'visible', timeout: 10000)
+        title_input.fill(title)
+      rescue Playwright::TimeoutError
+        raise 'Hashnode: Could not find title input field. Check if you are logged in and the editor loaded correctly.'
+      end
+
+      def fill_content(page, content)
+        editor = page.locator('textarea[placeholder="Start writing markdown..."]').first
+        editor.wait_for(state: 'visible', timeout: 10000)
+        editor.fill(content)
+      rescue Playwright::TimeoutError
+        raise 'Hashnode: Could not find content editor. Check if the studio page loaded correctly.'
+      end
+
+      def click_publish(page)
+        # Click toolbar Publish to open Draft settings panel
+        toolbar_publish = page.locator('header button:has-text("Publish")').first
+        toolbar_publish.wait_for(state: 'visible', timeout: 10000)
+        toolbar_publish.click
+
+        page.wait_for_timeout(2000)
+      rescue Playwright::TimeoutError
+        raise 'Hashnode: Could not find or click publish button.'
+      end
+
+      def configure_discovery(page, article)
+        # Click Discovery tab
+        discovery_tab = page.locator('button:has-text("Discovery")').first
+        discovery_tab.wait_for(state: 'visible', timeout: 10000)
+        discovery_tab.click
+        page.wait_for_timeout(1500)
+
+        # Set slug
+        fill_slug(page, article.slug || article.stable_slug)
+
+        # Fill tags
+        fill_tags_in_panel(page, article.tags) if article.tags&.any?
+
+        # Click final Publish in panel
+        panel_publish = page.locator('button:has-text("Publish")').last
+        panel_publish.wait_for(state: 'visible', timeout: 10000)
+        panel_publish.click
+
+        # Wait for post-publish navigation
+        page.wait_for_timeout(5000)
+      rescue Playwright::TimeoutError
+        raise 'Hashnode: Could not complete Discovery/Publish flow.'
+      end
+
+      def fill_slug(page, slug)
+        # Click Edit next to slug
+        edit_btn = page.locator('button:has-text("Edit")').first
+        edit_btn.wait_for(state: 'visible', timeout: 5000)
+        edit_btn.click
+        page.wait_for_timeout(1000)
+
+        # Find slug input via JavaScript (CSS selectors don't match default type="text")
+        page.evaluate(<<~JS)
+          (function() {
+            var inputs = Array.from(document.querySelectorAll('input'));
+            var slugInput = inputs.find(function(i) {
+              return i.type === 'text' && !i.placeholder && i.offsetParent !== null;
+            });
+            if (slugInput) {
+              slugInput.setAttribute('data-testid', 'slug-input');
+            }
+          })()
+        JS
+
+        slug_input = page.locator('[data-testid="slug-input"]').first
+        slug_input.wait_for(state: 'visible', timeout: 5000)
+        slug_input.fill(slug)
+
+        # Click Save
+        save_btn = page.locator('button:has-text("Save")').first
+        save_btn.click
+        page.wait_for_timeout(1000)
+      rescue Playwright::TimeoutError
+        # Slug is optional, ignore errors
+      end
+
+      def fill_tags_in_panel(page, tags)
+        tags_input = page.locator('input[placeholder="Type to add tags"]').first
+        return unless tags_input.visible?
+
+        tags.each do |tag|
+          tags_input.fill(tag)
+          tags_input.press('Enter')
+          page.wait_for_timeout(500)
+        end
+      rescue Playwright::TimeoutError
+        # Tags are optional, ignore errors
+      end
+    end
+  end
+end

data/lib/skriptorium/local/destination.rb

@@ -0,0 +1,34 @@
+require 'fileutils'
+
+module Skriptorium
+  module Local
+    class Destination < BaseDestination
+      def initialize(config)
+        super
+        @path = config['path']
+        @format = config.fetch('format', 'html')
+      end
+
+      def exists?(article)
+        File.exist?(filepath(article))
+      end
+
+      def publish(article)
+        FileUtils.mkdir_p(@path)
+
+        if @format == 'html'
+          File.write(filepath(article), article.to_html)
+        else
+          File.write(filepath(article), article.to_markdown)
+        end
+        puts "  Saved to Local: #{filepath(article)}"
+      end
+
+      private
+
+      def filepath(article)
+        File.join(@path, "#{article.stable_slug}.#{@format}")
+      end
+    end
+  end
+end

data/lib/skriptorium/rss/source.rb

@@ -0,0 +1,50 @@
+require 'faraday'
+require 'reverse_markdown'
+
+module Skriptorium
+  module RSS
+    class Source < BaseSource
+      def initialize(config)
+        super
+        @url = config['url']
+      end
+
+      def fetch
+        client = Faraday.new
+        response = client.get(@url)
+        raise "RSS fetch error: #{response.status} - #{response.body}" unless response.success?
+
+        feed = ::RSS::Parser.parse(response.body)
+
+        Enumerator.new do |y|
+          feed.items.each do |item|
+            y << self.class.to_article(item)
+          end
+        end
+      end
+
+      def self.to_article(item)
+        content = if item.respond_to?(:content_encoded) && item.content_encoded
+                    item.content_encoded
+                  elsif item.respond_to?(:description) && item.description
+                    item.description
+                  else
+                    ''
+                  end
+
+        Article.new(
+          id: item.guid&.content || item.link,
+          title: item.title,
+          content: content,
+          tags: [],
+          canonical_url: item.link,
+          published_at: Article.parse_date(item.pubDate || item.dc_date),
+          cover_image: nil,
+          slug: nil,
+          markdown: false,
+          html: true
+        )
+      end
+    end
+  end
+end

data/lib/skriptorium/version.rb

@@ -0,0 +1,3 @@
+module Skriptorium
+  VERSION = '0.1.1'
+end

data/lib/skriptorium.rb

@@ -0,0 +1,83 @@
+require 'yaml'
+require 'date'
+require 'faraday'
+require 'reverse_markdown'
+require 'json'
+require 'base64'
+require 'rss'
+
+require_relative 'skriptorium/version'
+require_relative 'skriptorium/config'
+require_relative 'skriptorium/article'
+require_relative 'skriptorium/base_source'
+require_relative 'skriptorium/base_destination'
+require_relative 'skriptorium/dev_to/source'
+require_relative 'skriptorium/dev_to/destination'
+require_relative 'skriptorium/rss/source'
+require_relative 'skriptorium/github_pages/destination'
+require_relative 'skriptorium/blogger/destination'
+require_relative 'skriptorium/local/destination'
+require_relative 'skriptorium/hashnode/destination'
+
+module Skriptorium
+  class Error < StandardError; end
+
+  def self.run(config_path, dry_run: false, verbose: false)
+    config = Config.load(config_path)
+
+    source = build_source(config.source)
+    destinations = config.destinations.map { |d| build_destination(d) }.compact
+
+    articles = source.fetch_latest
+
+    if verbose
+      puts "Found #{articles.length} article(s) from source:"
+      articles.each do |article|
+        puts "  => #{article.title}"
+      end
+    end
+
+    destinations.each do |destination|
+      puts "[SCAN] #{destination.class.name}"
+
+      to_publish = articles.take_while do |a|
+        if !destination.exists?(a)
+          puts "  [TAKE] Article '#{a.title}'"
+          true
+        else
+          puts "  [SKIP] Article '#{a.title}' already exists in #{destination.class.name}"
+          false
+        end
+      end
+
+      to_publish.sort_by(&:published_at).each do |article|
+        puts "  [PUBLISH] Publishing '#{article.title}' to #{destination.class.name}"
+        if dry_run
+          puts '    (dry-run mode, not actually publishing)'
+        else
+          destination.publish(article)
+        end
+      end
+    end
+  end
+
+  def self.build_source(source_config)
+    case source_config['type']
+    when 'dev_to' then DevTo::Source.new(source_config)
+    when 'rss' then RSS::Source.new(source_config)
+    else raise Error, "Unknown source type: #{source_config['type']}"
+    end
+  end
+
+  def self.build_destination(dest_config)
+    case dest_config['type']
+    when 'dev_to' then DevTo::Destination.new(dest_config)
+    when 'hashnode' then Hashnode::Destination.new(dest_config)
+    when 'github_pages' then GitHubPages::Destination.new(dest_config)
+    when 'blogger' then Blogger::Destination.new(dest_config)
+    when 'local' then Local::Destination.new(dest_config)
+    #else raise Error, "Unknown destination type: #{dest_config['type']}"
+    else nil
+    end
+  end
+end