pagecord-cli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a1e156f74ff6f6b5860f2a21cae283aaccf1d3bec27ef02ed5bfc02002a1bdb3
+  data.tar.gz: d05ee18c97ee613d5903e76bf3508c20ed6536b8120a3a3f60dc279539048203
+SHA512:
+  metadata.gz: f02588d28a65bfd183cd5830f96d88395523960ef7a0ab4584be5e7e386b0f15530a1b5fa8b2c169b629a5cbabac138d77d428cffaeabaada09c2ffbe7a4d105
+  data.tar.gz: 5057321b2a894a091ab7f7e76cb8fb0e9724f3576b9c435f83dc06dac38e59cb78f0e240f942297f34fd4479b2caf8a9de3887b4bd1e7593c2f0f89b796b8e65

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pagecord
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,131 @@
+# Pagecord CLI
+
+Publish local Markdown and HTML files to [Pagecord](https://pagecord.com).
+
+## Install
+
+```bash
+gem install pagecord-cli
+```
+
+## Login
+
+Generate an API key from **Settings > API** in Pagecord, then save it locally:
+
+```bash
+pagecord login myblog
+```
+
+The name should be your Pagecord subdomain. The API key is stored in
+`~/.pagecord.yml`.
+
+For local testing there is an undocumented `--base-url` option:
+
+```bash
+pagecord login myblog --base-url http://localhost:3000
+```
+
+## Publishing
+
+Publish a file:
+
+```bash
+pagecord publish hello.md
+```
+
+Save or update a draft:
+
+```bash
+pagecord draft notes/idea.md
+```
+
+The first publish creates a post and writes Pagecord metadata back into the
+file. Later publishes update the same post.
+
+If you have one blog configured, `publish`, `draft`, and `logout` can omit the
+subdomain. If you have more than one, pass the subdomain as the final argument:
+
+```bash
+pagecord publish hello.md myblog
+```
+
+See configured blogs:
+
+```bash
+pagecord list
+```
+
+Remove a saved blog:
+
+```bash
+pagecord logout myblog
+```
+
+## Options
+
+`publish` and `draft` accept:
+
+```bash
+--title TITLE
+--slug SLUG
+--published-at TIME
+--tags TAGS
+--canonical-url URL
+--hidden
+--locale LOCALE
+```
+
+## Front Matter
+
+Markdown files can include Pagecord-compatible front matter:
+
+```yaml
+---
+title: My Post
+slug: my-post
+tags:
+  - ruby
+  - cli
+published_at: 2026-01-02T03:04:05Z
+canonical_url: https://example.com/original
+hidden: false
+locale: en
+---
+```
+
+If `title` is omitted, the CLI uses the filename. Use `title:` or
+`title: ""` to publish without a title.
+
+After publishing, the CLI manages the same front matter fields as the Obsidian
+plugin:
+
+```yaml
+pagecord_token: 65b82933
+pagecord_blog_fingerprint: c92376aeb770
+pagecord_attachments:
+status: published
+```
+
+`pagecord_token` links the file to the remote post. Delete it if you want the
+next publish to create a new post.
+
+## Images
+
+Markdown image references to local files are uploaded to Pagecord and sent as
+Action Text attachments:
+
+```markdown
+![Alt text](photo.jpg)
+![[photo.jpg]]
+```
+
+Supported local image types are JPEG, PNG, GIF, and WebP. External image URLs
+and HTML `<img>` tags are left alone.
+
+## Development
+
+```bash
+rake test
+ruby -Ilib bin/pagecord help
+gem build pagecord-cli.gemspec
+```

data/bin/pagecord

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "pagecord_cli"
+
+exit PagecordCLI::CLI.new(ARGV).run

data/lib/pagecord_cli/cli.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "io/console"
+require "optparse"
+
+module PagecordCLI
+  class CLI
+    attr_reader :argv, :config, :input, :output, :error
+
+    def initialize(argv, config: Config.new, input: $stdin, output: $stdout, error: $stderr)
+      @argv = argv.dup
+      @config = config
+      @input = input
+      @output = output
+      @error = error
+    end
+
+    def run
+      command = argv.shift
+
+      case command
+      when "login" then login
+      when "logout" then logout
+      when "list" then list
+      when "publish" then publish("published")
+      when "draft" then publish("draft")
+      when "help", nil, "-h", "--help" then help
+      else
+        fail_with("Unknown command: #{command}")
+      end
+    rescue Client::Error => e
+      fail_with(api_error_message(e))
+    rescue Config::Error => e
+      fail_with(e.message)
+    rescue Errno::ENOENT => e
+      fail_with(e.message)
+    rescue Interrupt
+      error.puts
+      fail_with("Cancelled")
+    end
+
+    private
+
+      def login
+        options = { base_url: Config::DEFAULT_BASE_URL }
+        parser = OptionParser.new do |opts|
+          opts.on("--base-url URL") { |value| options[:base_url] = value }
+        end
+        parser.parse!(argv)
+
+        subdomain = argv.shift
+        return fail_with("Usage: pagecord login SUBDOMAIN") unless subdomain
+
+        base_url = Config.normalize_base_url(options[:base_url])
+        api_key = prompt_api_key
+        client = Client.new(api_key: api_key, base_url: base_url)
+        client.verify!
+        config.save_blog(subdomain, api_key: api_key, base_url: base_url)
+
+        output.puts "Saved #{subdomain}"
+        0
+      end
+
+      def logout
+        subdomain = resolve_blog(argv.shift)
+        return fail_with("No blogs are configured") if config.blogs.empty?
+        return fail_with("Please specify a subdomain") unless subdomain
+        return fail_with("Unknown blog: #{subdomain}") unless config.blog(subdomain)
+
+        config.delete_blog(subdomain)
+        output.puts "Removed #{subdomain}"
+        0
+      end
+
+      def list
+        return fail_with("No blogs are configured") if config.blogs.empty?
+
+        config.blogs.each do |subdomain, details|
+          suffix = details["base_url"] == Config::DEFAULT_BASE_URL ? "" : " (#{details["base_url"]})"
+          output.puts "#{subdomain}#{suffix}"
+        end
+
+        0
+      end
+
+      def publish(status)
+        options = publish_options
+        parser = OptionParser.new do |opts|
+          opts.on("--title TITLE") { |value| options[:title] = value }
+          opts.on("--slug SLUG") { |value| options[:slug] = value }
+          opts.on("--published-at TIME") { |value| options[:published_at] = value }
+          opts.on("--tags TAGS") { |value| options[:tags] = value }
+          opts.on("--canonical-url URL") { |value| options[:canonical_url] = value }
+          opts.on("--hidden") { options[:hidden] = true }
+          opts.on("--locale LOCALE") { |value| options[:locale] = value }
+        end
+        parser.parse!(argv)
+
+        file_path = argv.shift
+        subdomain = resolve_blog(argv.shift)
+
+        return fail_with("Usage: pagecord #{status == "draft" ? "draft" : "publish"} FILE [SUBDOMAIN]") unless file_path
+        return fail_with("No blogs are configured. Run pagecord login SUBDOMAIN first.") if config.blogs.empty?
+        return fail_with("Please specify a subdomain") unless subdomain
+        return fail_with("Unknown blog: #{subdomain}") unless config.blog(subdomain)
+
+        post_file = PostFile.new(file_path)
+        return fail_with("Unsupported file type: #{file_path}") unless post_file.supported?
+
+        blog_config = config.blog(subdomain)
+        api_key = blog_config.fetch("api_key")
+        return fail_with("This file is linked to another configured blog.") if post_file.wrong_blog?(subdomain, api_key)
+
+        client = Client.new(api_key: blog_config.fetch("api_key"), base_url: blog_config.fetch("base_url", Config::DEFAULT_BASE_URL))
+        params = post_file.params.merge(options.compact).merge(
+          content: post_file.content_for(subdomain, client: client),
+          status: status
+        )
+        params[:content_format] = post_file.content_format if post_file.content_format
+
+        result = if (token = post_file.token_for(subdomain))
+          client.update_post(token, params)
+        else
+          client.create_post(params)
+        end
+
+        post_file.write_token(subdomain, result.fetch("token"), api_key: api_key, status: status)
+        output.puts "#{status == "draft" ? "Saved draft" : "Published"} #{file_path} to #{subdomain}"
+        0
+      end
+
+      def publish_options
+        {
+          title: nil,
+          slug: nil,
+          published_at: nil,
+          tags: nil,
+          canonical_url: nil,
+          hidden: nil,
+          locale: nil
+        }
+      end
+
+      def resolve_blog(name)
+        return name if name
+        return config.blogs.keys.first if config.blogs.size == 1
+
+        nil
+      end
+
+      def prompt_api_key
+        output.print "API key: "
+
+        if input.tty?
+          key = input.noecho(&:gets).to_s.strip
+          output.puts
+          key
+        else
+          input.gets.to_s.strip
+        end
+      end
+
+      def api_error_message(api_error)
+        if api_error.status == 404
+          "#{api_error.message}. If this file should create a new post, remove its saved Pagecord token."
+        else
+          api_error.message
+        end
+      end
+
+      def help
+        output.puts <<~HELP
+          Usage:
+            pagecord login SUBDOMAIN
+            pagecord logout [SUBDOMAIN]
+            pagecord list
+            pagecord publish FILE [SUBDOMAIN] [options]
+            pagecord draft FILE [SUBDOMAIN] [options]
+
+          Publish options:
+            --title TITLE
+            --slug SLUG
+            --published-at TIME
+            --tags TAGS
+            --canonical-url URL
+            --hidden
+            --locale LOCALE
+        HELP
+        0
+      end
+
+      def fail_with(message)
+        error.puts message
+        1
+      end
+  end
+end

data/lib/pagecord_cli/client.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module PagecordCLI
+  class Client
+    class Error < StandardError
+      attr_reader :status
+
+      def initialize(status, message)
+        @status = status
+        super(message)
+      end
+    end
+
+    attr_reader :api_key, :base_url
+    OPEN_TIMEOUT = 10
+    READ_TIMEOUT = 30
+    WRITE_TIMEOUT = 30
+
+    def initialize(api_key:, base_url:)
+      @api_key = api_key
+      @base_url = base_url
+    end
+
+    def verify!
+      request(Net::HTTP::Get.new(uri_for("/posts")))
+      true
+    end
+
+    def create_post(params)
+      request(json_request(Net::HTTP::Post, "/posts", params))
+    end
+
+    def update_post(token, params)
+      request(json_request(Net::HTTP::Patch, "/posts/#{token}", params))
+    end
+
+    def upload_attachment(path)
+      uri = uri_for("/attachments")
+      http_request = Net::HTTP::Post.new(uri)
+      http_request["Authorization"] = "Bearer #{api_key}"
+      http_request.set_form([
+        [
+          "file",
+          File.open(path, "rb"),
+          { filename: File.basename(path), content_type: content_type(path) }
+        ]
+      ], "multipart/form-data")
+
+      request(http_request)
+    end
+
+    private
+
+      def json_request(klass, path, params)
+        request = klass.new(uri_for(path))
+        request["Content-Type"] = "application/json"
+        request.body = JSON.dump(params)
+        request
+      end
+
+      def request(http_request)
+        http_request["Authorization"] ||= "Bearer #{api_key}"
+        response = Net::HTTP.start(http_request.uri.hostname, http_request.uri.port, use_ssl: http_request.uri.scheme == "https") do |http|
+          http.open_timeout = OPEN_TIMEOUT
+          http.read_timeout = READ_TIMEOUT
+          http.write_timeout = WRITE_TIMEOUT if http.respond_to?(:write_timeout=)
+          http.request(http_request)
+        end
+
+        handle_response(response)
+      ensure
+        http_request.body_stream&.close if http_request.respond_to?(:body_stream)
+      end
+
+      def handle_response(response)
+        body = response.body.to_s
+        parsed = body.empty? ? {} : JSON.parse(body)
+
+        case response
+        when Net::HTTPSuccess
+          parsed
+        else
+          raise Error.new(response.code.to_i, error_message(parsed, response.code))
+        end
+      rescue JSON::ParserError
+        raise Error.new(response.code.to_i, "Unexpected response from Pagecord")
+      end
+
+      def error_message(parsed, status)
+        return parsed["error"] if parsed["error"]
+        return parsed["errors"].join(", ") if parsed["errors"].is_a?(Array)
+
+        "Pagecord API returned #{status}"
+      end
+
+      def uri_for(path)
+        URI.join(base_url.end_with?("/") ? base_url : "#{base_url}/", path.delete_prefix("/"))
+      end
+
+      def content_type(path)
+        case File.extname(path).downcase
+        when ".jpg", ".jpeg" then "image/jpeg"
+        when ".png" then "image/png"
+        when ".gif" then "image/gif"
+        when ".webp" then "image/webp"
+        when ".mp4" then "video/mp4"
+        when ".mov" then "video/quicktime"
+        when ".mp3" then "audio/mpeg"
+        when ".wav" then "audio/wav"
+        else "application/octet-stream"
+        end
+      end
+  end
+end

data/lib/pagecord_cli/config.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "date"
+require "uri"
+require "yaml"
+
+module PagecordCLI
+  class Config
+    class Error < StandardError; end
+
+    DEFAULT_PATH = File.expand_path("~/.pagecord.yml")
+    DEFAULT_BASE_URL = "https://api.pagecord.com"
+
+    attr_reader :path
+
+    def initialize(path = DEFAULT_PATH)
+      @path = path
+    end
+
+    def self.normalize_base_url(url)
+      uri = URI(url.match?(%r{\Ahttps?://}) ? url : "https://#{url}")
+      return uri.to_s.delete_suffix("/") if api_or_local_host?(uri.host)
+
+      uri.host = "api.#{uri.host}"
+      uri.to_s.delete_suffix("/")
+    end
+
+    def blogs
+      data.fetch("blogs", {})
+    end
+
+    def blog(name)
+      blogs[name]
+    end
+
+    def save_blog(name, api_key:, base_url: DEFAULT_BASE_URL)
+      new_data = data
+      new_data["blogs"] ||= {}
+      new_data["blogs"][name] = {
+        "api_key" => api_key,
+        "base_url" => base_url
+      }
+      write(new_data)
+    end
+
+    def delete_blog(name)
+      new_data = data
+      new_data.fetch("blogs", {}).delete(name)
+      write(new_data)
+    end
+
+    def resolve_blog(name = nil)
+      return name if name && blog(name)
+      return name if name
+
+      return blogs.keys.first if blogs.size == 1
+
+      nil
+    end
+
+    def data
+      return { "blogs" => {} } unless File.exist?(path)
+
+      YAML.safe_load_file(path, permitted_classes: [ Time, Date ], aliases: false) || { "blogs" => {} }
+    rescue Psych::Exception => e
+      raise Error, "Could not read #{path}: #{e.message}"
+    end
+
+    private
+
+      def self.api_or_local_host?(host)
+        host.start_with?("api.") || %w[localhost 127.0.0.1 ::1].include?(host)
+      end
+
+      def write(new_data)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, YAML.dump(new_data))
+        File.chmod(0o600, path)
+      rescue NotImplementedError
+        true
+      end
+  end
+end

data/lib/pagecord_cli/image_uploads.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module PagecordCLI
+  class ImageUploads
+    MARKDOWN_IMAGE = /!\[([^\]]*)\]\(([^)]+)\)/
+    OBSIDIAN_IMAGE = /!\[\[([^\]]+)\]\]/
+    IMAGE_EXTENSIONS = /\.(jpe?g|png|gif|webp)\z/i
+
+    attr_reader :content, :file_path, :metadata, :blog, :client
+
+    def initialize(content, file_path:, metadata:, blog:, client:)
+      @content = content
+      @file_path = file_path
+      @metadata = metadata
+      @blog = blog
+      @client = client
+    end
+
+    def process
+      with_markdown_images = content.gsub(MARKDOWN_IMAGE) do |match|
+        path = Regexp.last_match(2)
+        local_path?(path) ? attachment_tag_for(path) : match
+      end
+
+      with_markdown_images.gsub(OBSIDIAN_IMAGE) do |match|
+        path = Regexp.last_match(1)
+        local_path?(path) ? attachment_tag_for(path) : match
+      end
+    end
+
+    private
+
+      def attachment_tag_for(path)
+        sgid = cached_sgid(path) || upload(path)
+        %(<action-text-attachment sgid="#{sgid}"></action-text-attachment>)
+      end
+
+      def cached_sgid(path)
+        cache = attachment_cache[filename(path)]
+        return unless cache
+        return unless cache["hash"] == checksum(absolute_path(path))
+
+        cache["sgid"]
+      end
+
+      def upload(path)
+        result = client.upload_attachment(absolute_path(path))
+        sgid = result.fetch("attachable_sgid")
+
+        attachment_cache[filename(path)] = {
+          "hash" => checksum(absolute_path(path)),
+          "sgid" => sgid
+        }
+
+        sgid
+      end
+
+      def attachment_cache
+        metadata["pagecord_attachments"] ||= {}
+      end
+
+      def local_path?(path)
+        return false if path.match?(%r{\A[a-z][a-z0-9+.-]*:}i)
+        return false if path.start_with?("#", "/")
+        return false unless path.match?(IMAGE_EXTENSIONS)
+
+        File.file?(absolute_path(path))
+      end
+
+      def absolute_path(path)
+        File.expand_path(path, File.dirname(file_path))
+      end
+
+      def checksum(path)
+        Digest::SHA256.file(path).hexdigest[0, 16]
+      end
+
+      def filename(path)
+        File.basename(path)
+      end
+  end
+end

data/lib/pagecord_cli/post_file.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "date"
+require "digest"
+
+module PagecordCLI
+  class PostFile
+    MARKDOWN_EXTENSIONS = [ ".md", ".markdown" ].freeze
+    HTML_EXTENSIONS = [ ".html", ".htm" ].freeze
+    FRONT_MATTER = /\A---[ \t]*\n(.*?)\n---[ \t]*\n?/m
+    HTML_METADATA = /\A\s*<!--\s*pagecord:\s*\n(.*?)\n-->\s*/m
+
+    attr_reader :path, :content, :metadata, :body
+
+    def initialize(path)
+      @path = path
+      @content = File.read(path)
+      @metadata, @body = extract_metadata
+    end
+
+    def markdown?
+      MARKDOWN_EXTENSIONS.include?(File.extname(path).downcase)
+    end
+
+    def html?
+      HTML_EXTENSIONS.include?(File.extname(path).downcase)
+    end
+
+    def token_for(blog)
+      if markdown?
+        metadata["pagecord_token"]
+      else
+        metadata.dig(blog, "token") || metadata[blog]
+      end
+    end
+
+    def content_for(blog, client:)
+      return body unless markdown?
+
+      ImageUploads.new(
+        body,
+        file_path: path,
+        metadata: metadata,
+        blog: blog,
+        client: client
+      ).process
+    end
+
+    def write_token(blog, token, api_key: nil, status: nil)
+      if markdown?
+        metadata["pagecord_token"] = token
+        metadata["pagecord_blog_fingerprint"] = self.class.blog_fingerprint(api_key) if api_key
+        metadata["status"] = status if status
+        write_markdown
+      else
+        metadata[blog] = token
+        write_html
+      end
+    end
+
+    def content_format
+      markdown? ? "markdown" : nil
+    end
+
+    def params
+      publish_params = { title: title_from_metadata }
+
+      %w[slug published_at canonical_url locale].each do |key|
+        value = frontmatter_string(metadata[key])
+        publish_params[key.to_sym] = value if value
+      end
+
+      tags = tags_from_metadata
+      publish_params[:tags] = tags if tags
+
+      hidden = frontmatter_boolean(metadata["hidden"])
+      publish_params[:hidden] = hidden unless hidden.nil?
+
+      publish_params
+    end
+
+    def wrong_blog?(blog, api_key)
+      return false unless markdown?
+      return false unless metadata["pagecord_token"]
+      return false unless metadata["pagecord_blog_fingerprint"]
+
+      metadata["pagecord_blog_fingerprint"].to_s != self.class.blog_fingerprint(api_key)
+    end
+
+    def self.blog_fingerprint(api_key)
+      Digest::SHA256.hexdigest(api_key)[0, 12]
+    end
+
+    def default_title
+      title = File.basename(path, File.extname(path)).tr("_-", " ").squeeze(" ").strip
+      title.empty? ? "" : title[0].upcase + title[1..].to_s
+    end
+
+    def supported?
+      markdown? || html?
+    end
+
+    private
+
+      def extract_metadata
+        if markdown?
+          extract_markdown_metadata
+        elsif html?
+          extract_html_metadata
+        else
+          [ {}, content ]
+        end
+      end
+
+      def extract_markdown_metadata
+        match = content.match(FRONT_MATTER)
+        return [ {}, content ] unless match
+
+        yaml = YAML.safe_load(match[1], permitted_classes: [ Date, Time ], aliases: false) || {}
+        [ stringify_keys(yaml), content[match[0].length..] || "" ]
+      rescue Psych::Exception
+        [ {}, content ]
+      end
+
+      def extract_html_metadata
+        match = content.match(HTML_METADATA)
+        return [ {}, content ] unless match
+
+        data = YAML.safe_load(match[1], aliases: false) || {}
+        [ normalize_html_metadata(data), content[match[0].length..] || "" ]
+      rescue Psych::Exception
+        [ {}, content ]
+      end
+
+      def title_from_metadata
+        return default_title unless metadata.key?("title")
+        return "" if metadata["title"].nil?
+
+        frontmatter_string(metadata["title"]).to_s
+      end
+
+      def tags_from_metadata
+        tags = metadata["tags"]
+        return if tags.nil?
+
+        if tags.is_a?(Array)
+          tags.map { |tag| frontmatter_string(tag).to_s }.join(", ")
+        else
+          frontmatter_string(tags)
+        end
+      end
+
+      def frontmatter_string(value)
+        return if value.nil?
+
+        value = value.to_s
+        quoted = value.match(/\A(['"])(.*)\1\z/)
+        quoted ? quoted[2] : value
+      end
+
+      def frontmatter_boolean(value)
+        return if value.nil?
+        return value if value == true || value == false
+
+        normalized = frontmatter_string(value).to_s.strip.downcase
+        return true if normalized == "true"
+        return false if normalized == "false"
+
+        !!value
+      end
+
+      def write_markdown
+        File.write(path, "#{YAML.dump(metadata)}---\n#{body}")
+      end
+
+      def write_html
+        File.write(path, "<!-- pagecord:\n#{YAML.dump(flat_html_metadata).delete_prefix("---\n")}-->\n#{body}")
+      end
+
+      def flat_html_metadata
+        metadata.transform_values { |value| value.is_a?(Hash) ? value["token"] : value }
+      end
+
+      def normalize_html_metadata(data)
+        stringify_keys(data).transform_values do |value|
+          value.is_a?(Hash) ? value : { "token" => value }
+        end
+      end
+
+      def stringify_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) { |(key, item), hash| hash[key.to_s] = stringify_keys(item) }
+        when Array
+          value.map { |item| stringify_keys(item) }
+        else
+          value
+        end
+      end
+  end
+end

data/lib/pagecord_cli/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PagecordCLI
+  VERSION = "0.1.0"
+end

data/lib/pagecord_cli.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "pagecord_cli/client"
+require_relative "pagecord_cli/cli"
+require_relative "pagecord_cli/config"
+require_relative "pagecord_cli/image_uploads"
+require_relative "pagecord_cli/post_file"
+require_relative "pagecord_cli/version"

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: pagecord-cli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Olly Headey
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+email:
+- olly@pagecord.com
+executables:
+- pagecord
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/pagecord
+- lib/pagecord_cli.rb
+- lib/pagecord_cli/cli.rb
+- lib/pagecord_cli/client.rb
+- lib/pagecord_cli/config.rb
+- lib/pagecord_cli/image_uploads.rb
+- lib/pagecord_cli/post_file.rb
+- lib/pagecord_cli/version.rb
+homepage: https://pagecord.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://pagecord.com
+  source_code_uri: https://github.com/lylo/pagecord-cli
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Publish local files to Pagecord
+test_files: []