agentgif 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 38350f34e4505421da41f46084837dd32f4f974945ac39975b25aafc954b0bf8
+  data.tar.gz: 1c4677ec2565fd4b206a4119833c2e2548aa8c022c76dffc05add30754e50cda
+SHA512:
+  metadata.gz: 121c69206afd5327e4f287d327021e688affb48bbeab430bcef8e7e8b24782e3bd7726a9ed7fd7e9f808f65d5dfac72a08b53ac15c5b0ff56d305e989134700e
+  data.tar.gz: 9e6951b9977b210074a530aab5dd6070a145b8a0996d423f547eecb1461bef8b2ad4f5cdf4a4e834f09735f3fb2fd0d841793c773c61165e42bd32391a41fe7f

data/bin/agentgif

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/agentgif/cli"
+
+AgentGIF::CLI.check_for_updates
+AgentGIF::CLI.run(ARGV.dup)

data/lib/agentgif/cli.rb

@@ -0,0 +1,522 @@
+# frozen_string_literal: true
+
+# AgentGIF CLI (Ruby) — GIF for humans. Cast for agents.
+#
+# Install: gem install agentgif
+# Usage:   agentgif login | upload | search | badge
+#
+# Full documentation: https://agentgif.com/docs/cli/
+
+require_relative "config"
+require_relative "client"
+
+module AgentGIF
+  VERSION = "0.2.0"
+
+  module CLI
+    HELP = <<~TEXT
+      AgentGIF — GIF for humans. Cast for agents.
+
+      Usage: agentgif <command> [options]
+
+      Commands:
+        login                Open browser to authenticate
+        logout               Remove stored credentials
+        whoami               Show current user info
+
+        upload <gif>         Upload a GIF
+        search <query>       Search public GIFs
+        list                 List your GIFs
+        info <gifId>         Show GIF details (JSON)
+        embed <gifId>        Show embed codes
+        update <gifId>       Update GIF metadata
+        delete <gifId>       Delete a GIF
+
+        generate <url>       Generate GIFs from a README or package docs
+        generate-status <id> Check status of a generate job
+        record <tape>        Record a VHS tape and upload the GIF
+
+        badge url            Generate badge URL + embed codes
+        badge themes         List available terminal themes
+
+        version              Show version
+
+      Docs: https://agentgif.com/docs/cli/
+    TEXT
+
+    module_function
+
+    def run(args)
+      command = args.shift
+      case command
+      when "login"          then cmd_login
+      when "logout"         then cmd_logout
+      when "whoami"         then cmd_whoami
+      when "upload"         then cmd_upload(args)
+      when "search"         then cmd_search(args)
+      when "list"           then cmd_list(args)
+      when "info"           then cmd_info(args)
+      when "embed"          then cmd_embed(args)
+      when "update"         then cmd_update(args)
+      when "delete"         then cmd_delete(args)
+      when "generate"       then cmd_generate(args)
+      when "generate-status" then cmd_generate_status(args)
+      when "record"         then cmd_record(args)
+      when "badge"          then cmd_badge(args)
+      when "version", "--version", "-v"
+        puts "agentgif #{VERSION}"
+      when "help", "--help", "-h", nil
+        puts HELP
+      else
+        warn "Unknown command: #{command}"
+        warn "Run 'agentgif help' for usage."
+        exit 1
+      end
+    rescue AgentGIF::ApiError => e
+      warn "Error: #{e.message}"
+      exit 1
+    rescue Errno::ECONNREFUSED, SocketError => e
+      warn "Connection error: #{e.message}"
+      exit 1
+    end
+
+    # --- Authentication ---
+
+    def cmd_login
+      client = Client.new
+      data = client.device_auth
+      code = data["user_code"]
+      url = data["verification_url"]
+      device_code = data["device_code"]
+      interval = (data["interval"] || 5).to_i
+
+      puts "  Code: #{code}"
+      puts "  Open: #{url}"
+      puts ""
+
+      open_browser(url)
+
+      puts "Waiting for authentication..."
+      loop do
+        sleep(interval)
+        body, status = client.device_token(device_code)
+        if status == 200 && body && body["api_key"]
+          Config.save_credentials(body["api_key"], body["username"] || "")
+          puts "Logged in as #{body['username']}"
+          return
+        elsif status == 400
+          detail = body && body["detail"]
+          if detail == "authorization_pending"
+            next
+          else
+            warn "Auth failed: #{detail || 'unknown error'}"
+            exit 1
+          end
+        else
+          warn "Unexpected response (#{status})"
+          exit 1
+        end
+      end
+    end
+
+    def cmd_logout
+      Config.clear_credentials
+      puts "Logged out."
+    end
+
+    def cmd_whoami
+      require_auth
+      data = client.whoami
+      puts "  Username: #{data['username']}"
+      puts "  Email:    #{data['email']}" if data["email"]
+    end
+
+    # --- GIF Management ---
+
+    def cmd_upload(args)
+      require_auth
+      opts = parse_opts(args, %w[-t --title -d --description -c --command --tags --cast --theme], %w[--unlisted --no-repo])
+      gif_path = opts[:positional].first
+      abort "Usage: agentgif upload <gif> [options]" unless gif_path
+      abort "File not found: #{gif_path}" unless File.exist?(gif_path)
+
+      fields = {}
+      fields["title"] = opts["-t"] || opts["--title"] if opts["-t"] || opts["--title"]
+      fields["description"] = opts["-d"] || opts["--description"] if opts["-d"] || opts["--description"]
+      fields["command"] = opts["-c"] || opts["--command"] if opts["-c"] || opts["--command"]
+      fields["tags"] = opts["--tags"] if opts["--tags"]
+      fields["cast_path"] = opts["--cast"] if opts["--cast"]
+      fields["theme"] = opts["--theme"] if opts["--theme"]
+      fields["unlisted"] = "true" if opts["--unlisted"]
+
+      unless opts["--no-repo"]
+        repo = detect_repo
+        fields["repo"] = repo if repo
+      end
+
+      data = client.upload(gif_path, fields)
+      gif_id = data["id"]
+      puts "Uploaded: #{Client::BASE_URL}/g/#{gif_id}"
+    end
+
+    def cmd_search(args)
+      query = args.join(" ")
+      abort "Usage: agentgif search <query>" if query.empty?
+      data = Client.new.search(query)
+      results = data["results"] || []
+      if results.empty?
+        puts "No results."
+        return
+      end
+      results.each do |gif|
+        cmd = gif["command"] ? "  (#{gif['command']})" : ""
+        puts "  #{gif['id']}  #{gif['title']}#{cmd}"
+      end
+    end
+
+    def cmd_list(args)
+      require_auth
+      opts = parse_opts(args, %w[--repo], [])
+      repo = opts["--repo"] || ""
+      data = client.list_gifs(repo: repo)
+      gifs = data.is_a?(Array) ? data : (data["results"] || [])
+      if gifs.empty?
+        puts "No GIFs found."
+        return
+      end
+      gifs.each do |gif|
+        puts "  #{gif['id']}  #{gif['title']}"
+      end
+    end
+
+    def cmd_info(args)
+      gif_id = args.first
+      abort "Usage: agentgif info <gifId>" unless gif_id
+      data = client.get_gif(gif_id)
+      puts JSON.pretty_generate(data)
+    end
+
+    def cmd_embed(args)
+      opts = parse_opts(args, %w[-f --format], [])
+      gif_id = opts[:positional].first
+      abort "Usage: agentgif embed <gifId> [-f format]" unless gif_id
+      fmt = opts["-f"] || opts["--format"] || "all"
+
+      data = client.embed_codes(gif_id)
+      if fmt == "all"
+        data.each do |key, code|
+          puts "--- #{key} ---"
+          puts code
+          puts ""
+        end
+      else
+        code = data[fmt]
+        if code
+          puts code
+        else
+          warn "Unknown format: #{fmt}. Available: #{data.keys.join(', ')}"
+          exit 1
+        end
+      end
+    end
+
+    def cmd_update(args)
+      require_auth
+      opts = parse_opts(args, %w[-t --title -d --description -c --command --tags], [])
+      gif_id = opts[:positional].first
+      abort "Usage: agentgif update <gifId> [options]" unless gif_id
+
+      fields = {}
+      fields["title"] = opts["-t"] || opts["--title"] if opts["-t"] || opts["--title"]
+      fields["description"] = opts["-d"] || opts["--description"] if opts["-d"] || opts["--description"]
+      fields["command"] = opts["-c"] || opts["--command"] if opts["-c"] || opts["--command"]
+      fields["tags"] = opts["--tags"] if opts["--tags"]
+
+      if fields.empty?
+        warn "No fields to update. Use -t, -d, -c, or --tags."
+        exit 1
+      end
+
+      data = client.update_gif(gif_id, fields)
+      puts "Updated: #{data['id']}"
+    end
+
+    def cmd_delete(args)
+      opts = parse_opts(args, [], %w[-y --yes])
+      gif_id = opts[:positional].first
+      abort "Usage: agentgif delete <gifId> [-y]" unless gif_id
+      require_auth
+
+      unless opts["-y"] || opts["--yes"]
+        print "Delete #{gif_id}? [y/N] "
+        answer = $stdin.gets&.strip
+        unless answer&.downcase == "y"
+          puts "Cancelled."
+          return
+        end
+      end
+
+      client.delete_gif(gif_id)
+      puts "Deleted: #{gif_id}"
+    end
+
+    # --- Generate ---
+
+    def cmd_generate(args)
+      require_auth
+      opts = parse_opts(args, %w[--max --max-gifs --source-type --pypi --npm], %w[--no-wait])
+
+      source_url = opts[:positional].first || ""
+      source_type = opts["--source-type"] || ""
+      max_gifs = (opts["--max"] || opts["--max-gifs"] || "5").to_i
+
+      if opts["--pypi"]
+        pkg = opts["--pypi"]
+        source_url = "https://pypi.org/project/#{pkg}/"
+        source_type = "pypi"
+      elsif opts["--npm"]
+        pkg = opts["--npm"]
+        source_url = "https://www.npmjs.com/package/#{pkg}"
+        source_type = "npm"
+      elsif !source_url.empty? && source_type.empty?
+        source_type = detect_source_type(source_url)
+      end
+
+      abort "Usage: agentgif generate <url> [--pypi PKG] [--npm PKG] [--max N] [--no-wait]" if source_url.empty?
+
+      job = client.generate_tape(source_url: source_url, source_type: source_type, max_gifs: max_gifs)
+      job_id = job["job_id"]
+
+      if opts["--no-wait"]
+        puts "Job created: #{job_id}"
+        puts "  Check: agentgif generate-status #{job_id}"
+        return
+      end
+
+      puts "Generating GIFs..."
+      poll_generate_job(job_id)
+    end
+
+    def cmd_generate_status(args)
+      require_auth
+      opts = parse_opts(args, [], %w[--poll])
+      job_id = opts[:positional].first
+      abort "Usage: agentgif generate-status <job_id> [--poll]" unless job_id
+
+      if opts["--poll"]
+        poll_generate_job(job_id)
+      else
+        data = client.generate_status(job_id)
+        puts "  Status:         #{data['status']}"
+        puts "  Commands found: #{data['commands_found']}" if data["commands_found"]
+        puts "  GIFs created:   #{data['gifs_created']}" if data["gifs_created"]
+        puts "  Error:          #{data['error_message']}" if data["error_message"]
+        gifs = data["gifs"] || []
+        unless gifs.empty?
+          puts "  GIFs:"
+          gifs.each do |gif|
+            puts "    #{gif['id']}  #{gif['title']}  #{gif['url']}"
+          end
+        end
+      end
+    end
+
+    def cmd_record(args)
+      require_auth
+      opts = parse_opts(args, %w[-t --title -d --description -c --command --tags --theme], %w[--unlisted --no-repo])
+      tape_file = opts[:positional].first
+      abort "Usage: agentgif record <tape_file> [upload options...]" unless tape_file
+      abort "File not found: #{tape_file}" unless File.exist?(tape_file)
+
+      unless system("which", "vhs", out: File::NULL, err: File::NULL)
+        abort "Error: VHS not found. Install from https://github.com/charmbracelet/vhs"
+      end
+
+      puts "Running VHS: #{tape_file}"
+      unless system("vhs", tape_file)
+        abort "VHS recording failed."
+      end
+
+      # Parse tape file for Output line to find GIF path
+      gif_path = nil
+      File.readlines(tape_file).each do |line|
+        if line.strip.match(/\AOutput\s+(.+)/i)
+          gif_path = $1.strip.gsub(/["']/, "")
+          break
+        end
+      end
+
+      gif_path ||= tape_file.sub(/\.[^.]+\z/, ".gif")
+      abort "GIF not found: #{gif_path}" unless File.exist?(gif_path)
+
+      puts "Uploading: #{gif_path}"
+      # Reuse upload logic by building args and calling cmd_upload
+      upload_args = [gif_path]
+      upload_args.push("-t", opts["-t"] || opts["--title"]) if opts["-t"] || opts["--title"]
+      upload_args.push("-d", opts["-d"] || opts["--description"]) if opts["-d"] || opts["--description"]
+      upload_args.push("-c", opts["-c"] || opts["--command"]) if opts["-c"] || opts["--command"]
+      upload_args.push("--tags", opts["--tags"]) if opts["--tags"]
+      upload_args.push("--theme", opts["--theme"]) if opts["--theme"]
+      upload_args.push("--unlisted") if opts["--unlisted"]
+      upload_args.push("--no-repo") if opts["--no-repo"]
+      cmd_upload(upload_args)
+    end
+
+    # --- Badge ---
+
+    def cmd_badge(args)
+      subcmd = args.shift
+      case subcmd
+      when "url"    then cmd_badge_url(args)
+      when "themes" then cmd_badge_themes
+      else
+        puts "Usage: agentgif badge <url|themes>"
+      end
+    end
+
+    def cmd_badge_url(args)
+      opts = parse_opts(args, %w[-p --provider -k --package -m --metric --theme --style -f --format], [])
+      provider = opts["-p"] || opts["--provider"]
+      package = opts["-k"] || opts["--package"]
+      abort "Usage: agentgif badge url -p <provider> -k <package>" unless provider && package
+
+      extra = {}
+      extra["metric"] = opts["-m"] || opts["--metric"] if opts["-m"] || opts["--metric"]
+      extra["theme"] = opts["--theme"] if opts["--theme"]
+      extra["style"] = opts["--style"] if opts["--style"]
+      fmt = opts["-f"] || opts["--format"] || "all"
+
+      data = Client.new.badge_url(provider, package, extra)
+      if fmt == "all"
+        data.each do |key, val|
+          puts "#{key}: #{val}"
+        end
+      else
+        val = data[fmt] || data["url"]
+        puts val if val
+      end
+    end
+
+    def cmd_badge_themes
+      data = Client.new.badge_themes
+      themes = data.is_a?(Array) ? data : (data["themes"] || [])
+      themes.each { |t| puts "  #{t}" }
+    end
+
+    # --- Helpers ---
+
+    def require_auth
+      key = Config.get_api_key
+      if key.empty?
+        warn "Not logged in. Run: agentgif login"
+        exit 1
+      end
+    end
+
+    def client
+      @client ||= Client.new
+    end
+
+    def detect_source_type(url)
+      case url
+      when /github\.com/  then "github"
+      when /pypi\.org/    then "pypi"
+      when /npmjs\.com/   then "npm"
+      else ""
+      end
+    end
+
+    def poll_generate_job(job_id)
+      start = Time.now
+      prev_status = ""
+      loop do
+        if Time.now - start > 300
+          warn "Timed out after 5 minutes. Check status:"
+          warn "  agentgif generate-status #{job_id}"
+          exit 1
+        end
+
+        sleep(2)
+
+        begin
+          data = client.generate_status(job_id)
+        rescue AgentGIF::ApiError => e
+          next if e.status >= 500
+          raise
+        end
+
+        current = data["status"] || ""
+        if current != prev_status
+          puts "  Status: #{current}"
+          prev_status = current
+        end
+
+        case current
+        when "completed"
+          gifs = data["gifs"] || []
+          count = data["gifs_created"] || gifs.length
+          puts "Done! #{count} GIFs generated."
+          gifs.each do |gif|
+            puts "  #{gif['id']}  #{gif['title']}  #{gif['url']}"
+          end
+          return
+        when "failed"
+          warn "Generation failed: #{data['error_message'] || 'Unknown error'}"
+          exit 1
+        end
+      end
+    end
+
+    def detect_repo
+      remote = `git remote get-url origin 2>/dev/null`.strip
+      return nil if remote.empty?
+
+      # git@github.com:user/repo.git → user/repo
+      if remote.match?(%r{git@github\.com:(.+?)(?:\.git)?$})
+        remote.match(%r{git@github\.com:(.+?)(?:\.git)?$})[1]
+      elsif remote.match?(%r{github\.com/(.+?)(?:\.git)?$})
+        remote.match(%r{github\.com/(.+?)(?:\.git)?$})[1]
+      end
+    end
+
+    def open_browser(url)
+      case RUBY_PLATFORM
+      when /darwin/  then system("open", url)
+      when /linux/   then system("xdg-open", url)
+      when /mswin|mingw/ then system("start", url)
+      end
+    end
+
+    def parse_opts(args, value_flags, bool_flags)
+      result = { positional: [] }
+      i = 0
+      while i < args.length
+        arg = args[i]
+        if value_flags.include?(arg)
+          i += 1
+          result[arg] = args[i]
+        elsif bool_flags.include?(arg)
+          result[arg] = true
+        else
+          result[:positional] << arg
+        end
+        i += 1
+      end
+      result
+    end
+
+    def check_for_updates
+      data = Client.new.cli_version
+      latest = data["latest"]
+      return unless latest
+
+      current_parts = VERSION.split(".").map(&:to_i)
+      latest_parts = latest.split(".").map(&:to_i)
+      return unless (latest_parts <=> current_parts) == 1
+
+      warn "Update available: #{VERSION} → #{latest}  (gem install agentgif)"
+    rescue StandardError
+      # Silently ignore update check failures
+    end
+  end
+end

data/lib/agentgif/client.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+# HTTP client for the AgentGIF API.
+
+require "json"
+require "net/http"
+require "uri"
+
+module AgentGIF
+  class ApiError < StandardError
+    attr_reader :status
+
+    def initialize(message, status)
+      @status = status
+      super("API error #{status}: #{message}")
+    end
+  end
+
+  class Client
+    BASE_URL = "https://agentgif.com"
+
+    def initialize(base_url: nil, api_key: nil)
+      @base_url = base_url || BASE_URL
+      @api_key = api_key || Config.get_api_key
+    end
+
+    # --- Auth ---
+
+    def whoami
+      get("/users/me/")
+    end
+
+    def device_auth
+      post("/auth/device/", {})
+    end
+
+    def device_token(device_code)
+      uri = URI("#{@base_url}/api/v1/auth/device/token/")
+      req = Net::HTTP::Post.new(uri)
+      req["Content-Type"] = "application/json"
+      req.body = JSON.generate({ device_code: device_code })
+      resp = execute_raw(uri, req)
+      body = parse_body(resp.body)
+      [body, resp.code.to_i]
+    end
+
+    # --- GIFs ---
+
+    def search(query)
+      get("/search/?q=#{encode(query)}")
+    end
+
+    def list_gifs(repo: nil)
+      path = repo && !repo.empty? ? "/gifs/me/?repo=#{encode(repo)}" : "/gifs/me/"
+      get(path)
+    end
+
+    def get_gif(gif_id)
+      get("/gifs/#{gif_id}/")
+    end
+
+    def embed_codes(gif_id)
+      data = get_gif(gif_id)
+      data["embed"] || {}
+    end
+
+    def update_gif(gif_id, fields)
+      patch("/gifs/#{gif_id}/", fields)
+    end
+
+    def delete_gif(gif_id)
+      response = request(:delete, "/gifs/#{gif_id}/")
+      return if response.code.to_i < 400
+
+      raise ApiError.new(response.body, response.code.to_i)
+    end
+
+    def upload(gif_path, opts = {})
+      boundary = "AgentGIF#{rand(10**16)}"
+      body = build_multipart(gif_path, opts, boundary)
+
+      uri = URI("#{@base_url}/api/v1/gifs/")
+      req = Net::HTTP::Post.new(uri)
+      req["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+      req["Authorization"] = "Token #{@api_key}" unless @api_key.empty?
+      req.body = body
+
+      resp = execute_raw(uri, req)
+      handle_response(resp)
+    end
+
+    # --- Badges ---
+
+    def badge_url(provider, package, opts = {})
+      params = ["provider=#{encode(provider)}", "package=#{encode(package)}"]
+      opts.each { |k, v| params << "#{encode(k.to_s)}=#{encode(v)}" unless v.to_s.empty? }
+      get("/badge-url/?#{params.join('&')}")
+    end
+
+    def badge_themes
+      get("/themes/badges/")
+    end
+
+    # --- Generate ---
+
+    def generate_tape(source_url: "", source_type: "", max_gifs: 5, raw_markdown: "")
+      payload = { "max_gifs" => max_gifs }
+      payload["source_url"] = source_url unless source_url.empty?
+      payload["source_type"] = source_type unless source_type.empty?
+      if !raw_markdown.empty?
+        payload["source_type"] = "raw"
+        payload["raw_markdown"] = raw_markdown
+      end
+      post("/gifs/generate/", payload)
+    end
+
+    def generate_status(job_id)
+      get("/gifs/generate/#{job_id}/")
+    end
+
+    # --- Version ---
+
+    def cli_version
+      get("/cli/version/")
+    end
+
+    private
+
+    def get(path)
+      resp = request(:get, path)
+      handle_response(resp)
+    end
+
+    def post(path, body)
+      resp = request(:post, path, JSON.generate(body))
+      handle_response(resp)
+    end
+
+    def patch(path, body)
+      resp = request(:patch, path, JSON.generate(body))
+      handle_response(resp)
+    end
+
+    def request(method, path, body = nil)
+      uri = URI("#{@base_url}/api/v1#{path}")
+      klass = {
+        get: Net::HTTP::Get,
+        post: Net::HTTP::Post,
+        patch: Net::HTTP::Patch,
+        delete: Net::HTTP::Delete
+      }.fetch(method)
+
+      req = klass.new(uri)
+      req["Content-Type"] = "application/json"
+      req["Authorization"] = "Token #{@api_key}" unless @api_key.empty?
+      req.body = body if body
+
+      execute_raw(uri, req)
+    end
+
+    def execute_raw(uri, req)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = 30
+      http.read_timeout = 60
+      http.request(req)
+    end
+
+    def handle_response(resp)
+      status = resp.code.to_i
+      body = resp.body || ""
+      if status >= 400
+        msg = begin
+          obj = JSON.parse(body)
+          obj["error"] || obj["detail"] || body
+        rescue JSON::ParserError
+          body
+        end
+        raise ApiError.new(msg, status)
+      end
+      parse_body(body)
+    end
+
+    def parse_body(body)
+      return nil if body.nil? || body.empty?
+
+      JSON.parse(body)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def encode(s)
+      URI.encode_www_form_component(s.to_s)
+    end
+
+    def build_multipart(gif_path, opts, boundary)
+      parts = []
+
+      # GIF file part
+      file_data = File.binread(gif_path)
+      file_name = File.basename(gif_path)
+      parts << "--#{boundary}\r\n" \
+               "Content-Disposition: form-data; name=\"gif\"; filename=\"#{file_name}\"\r\n" \
+               "Content-Type: image/gif\r\n\r\n" \
+               "#{file_data}\r\n"
+
+      # Text fields
+      opts.each do |key, value|
+        next if value.to_s.empty?
+        next if key.to_s == "cast_path"
+
+        parts << "--#{boundary}\r\n" \
+                 "Content-Disposition: form-data; name=\"#{key}\"\r\n\r\n" \
+                 "#{value}\r\n"
+      end
+
+      # Cast file (optional)
+      cast_path = opts["cast_path"] || opts[:cast_path]
+      if cast_path && !cast_path.empty? && File.exist?(cast_path)
+        cast_data = File.binread(cast_path)
+        cast_name = File.basename(cast_path)
+        parts << "--#{boundary}\r\n" \
+                 "Content-Disposition: form-data; name=\"cast\"; filename=\"#{cast_name}\"\r\n" \
+                 "Content-Type: application/octet-stream\r\n\r\n" \
+                 "#{cast_data}\r\n"
+      end
+
+      parts << "--#{boundary}--\r\n"
+      parts.join
+    end
+  end
+end

data/lib/agentgif/config.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Config storage at ~/.config/agentgif/config.json
+
+require "json"
+require "fileutils"
+
+module AgentGIF
+  module Config
+    CONFIG_DIR = File.join(
+      ENV.fetch("XDG_CONFIG_HOME", File.join(Dir.home, ".config")),
+      "agentgif"
+    )
+    CONFIG_PATH = File.join(CONFIG_DIR, "config.json")
+
+    module_function
+
+    def load_config
+      return {} unless File.exist?(CONFIG_PATH)
+
+      JSON.parse(File.read(CONFIG_PATH))
+    rescue JSON::ParserError
+      {}
+    end
+
+    def save_config(cfg)
+      FileUtils.mkdir_p(CONFIG_DIR)
+      File.write(CONFIG_PATH, "#{JSON.pretty_generate(cfg)}\n")
+    end
+
+    def get_api_key
+      load_config["api_key"] || ""
+    end
+
+    def save_credentials(api_key, username)
+      cfg = load_config
+      cfg["api_key"] = api_key
+      cfg["username"] = username
+      save_config(cfg)
+    end
+
+    def clear_credentials
+      cfg = load_config
+      cfg.delete("api_key")
+      cfg.delete("username")
+      save_config(cfg)
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: agentgif
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- AgentGIF
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Upload, search, and manage terminal demo GIFs on AgentGIF.com. Generate
+  terminal-themed package badges.
+email:
+- hello@agentgif.com
+executables:
+- agentgif
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/agentgif
+- lib/agentgif/cli.rb
+- lib/agentgif/client.rb
+- lib/agentgif/config.rb
+homepage: https://agentgif.com
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/agentgif/cli-ruby
+  bug_tracker_uri: https://github.com/agentgif/cli-ruby/issues
+  documentation_uri: https://agentgif.com/docs/cli/
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: CLI for AgentGIF — upload, manage, and share terminal GIFs
+test_files: []