keybase-unofficial-local 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 73462754242f448627d5b1b94287a8a81eb39130
+  data.tar.gz: 592f7b342ae3c995516c7141004e9e8c472e375b
+SHA512:
+  metadata.gz: 00da9053ab49b2fc8b3ae1e8aa2c252ea67bcfee4257faf086068dec72f6a309594d81b5b7cf42681e1fa24f98bb540217fdcda55c3d71be1e62654611f7d121
+  data.tar.gz: 0fac2bfe282d57aac3c9a8aa66093f4406c03658853bcaff965a696d4b5b15c10fc14bccdaeefab95c539ebbceea234ea58a672060e2fd0b101524d9a6be4c7b

data/.yardopts

@@ -0,0 +1 @@
+--no-private --markup-provider=redcarpet --markup=markdown - *.md LICENSE

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 William Woodruff <william @ yossarian.net>
+
+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,15 @@
+keybase-unofficial-local
+========================
+
+An unofficial Ruby library for interacting with a local Keybase installation.
+
+### Installation
+
+```bash
+gem install keybase-unofficial-local
+```
+
+### Documentation
+
+Documentation for the current release can be found on
+[RubyDoc](http://www.rubydoc.info/gems/keybase-unofficial-local/).

data/lib/keybase/local.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "keybase/core"
+
+require_relative "local/exceptions"
+require_relative "local/config"
+require_relative "local/user"
+require_relative "local/kbfs"
+require_relative "local/chat"
+require_relative "local/team"
+
+# The primary namespace.
+module Keybase
+  # The namespace for `keybase-unofficial-local`.
+  module Local
+    # The current version of `keybase-unofficial-local`.
+    VERSION = "0.0.1"
+
+    extend Config
+  end
+end

data/lib/keybase/local/chat.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "open3"
+require "json"
+require "ostruct"
+
+module Keybase
+  module Local
+    # Represents Keybase's JSON chat API.
+    module Chat
+      # The initial arguments to pass when executing Keybase for chatting.
+      CHAT_EXEC_ARGS = %w[keybase chat api].freeze
+
+      class << self
+        # @param meth [Symbol] the chat method
+        # @param options [Hash] the options hash
+        # @return [String] the JSON serialized envelope
+        # @api private
+        def envelope(meth, options: {})
+          {
+            method: meth,
+            params: {
+              options: options,
+            },
+          }.to_json
+        end
+
+        # @param payload [String] the JSON payload to send to the chat API
+        # @return [OpenStruct] a struct mapping of the JSON response
+        # @api private
+        def chat_call(payload)
+          response = Open3.popen3(*CHAT_EXEC_ARGS) do |stdin, stdout, _, _|
+            stdin.write payload
+            stdin.close # close after writing to let keybase know we're done
+            stdout.read
+          end
+
+          JSON.parse response, object_class: OpenStruct
+        end
+
+        # List the user's inbox.
+        # @param topic_type [String] the topic type to list by
+        # @return [OpenStruct] a struct mapping of the JSON response
+        def list_inbox(topic_type: nil)
+          payload = envelope :list, options: {
+            topic_type: topic_type,
+          }
+
+          chat_call payload
+        end
+
+        # Read a conversation.
+        # @param users [Array<String>] a list of the users in the conversation
+        # @param peek [Boolean] whether to mark the conversation read
+        # @param unread_only [Boolean] whether to fetch unread messages only
+        # @return [OpenStruct] a struct mapping of the JSON response
+        def conversation(users, peek: false, unread_only: false)
+          payload = envelope :read, options: {
+            channel: {
+              name: Core::U[*users],
+            },
+            peek: peek,
+            unread_only: unread_only,
+          }
+
+          chat_call payload
+        end
+
+        # Send a message to a conversation.
+        # @param users [Array<String>] a list of the users in the conversation
+        # @param message [String] the message to send
+        # @param public [Boolean] whether to send the message to a public channel
+        # @return [OpenStruct] a struct mapping of the JSON response
+        def send_message(users, message, public: false)
+          payload = envelope :send, options: {
+            channel: {
+              name: Core::U[*users],
+              public: public,
+            },
+            message: {
+              body: message,
+            },
+          }
+
+          chat_call payload
+        end
+
+        # Delete a message from a conversation.
+        # @param users [Array<String>] a list of the users in the conversation
+        # @param id [Integer] the id of the message to delete
+        # @return [OpenStruct] a struct mapping of the JSON response
+        def delete_message(users, id)
+          payload = envelope :delete, options: {
+            channel: {
+              name: Core::U[*users],
+            },
+            message_id: id,
+          }
+
+          chat_call payload
+        end
+
+        # Edit a message in a conversation.
+        # @param users [Array<String>] a list of the users in the conversation
+        # @param id [Integer] the id of the message to delete
+        # @param message [String] the message to send
+        # @return [OpenStruct] a struct mapping of the JSON response
+        def edit_message(users, id, message)
+          payload = envelope :edit, options: {
+            channel: {
+              name: Core::U[*users],
+            },
+            message_id: id,
+            message: {
+              body: message,
+            },
+          }
+
+          chat_call payload
+        end
+
+        # Upload a file to a conversation.
+        # @param users [Array<String>] a list of the users in the conversation
+        # @param path [String] the pathname of the file to upload
+        # @param title [String] the uploaded file's title
+        # @return [OpenStruct] a struct mapping of the JSON response
+        def upload_attachment(users, path, title)
+          payload = envelope :attach, options: {
+            channel: {
+              name: Core::U[*users],
+            },
+            filename: path,
+            title: title,
+          }
+
+          chat_call payload
+        end
+
+        # Download a file from a conversation.
+        # @param users [Array<String>] a list of the users in the conversation
+        # @param id [Integer] the id of the message to download from
+        # @param path [String] the pathname to download to
+        # @return [OpenStruct] a struct mapping of the JSON response
+        def download_attachment(users, id, path)
+          payload = envelope :download, options: {
+            channel: {
+              name: Core::U[*users],
+            },
+            message_id: id,
+            output: path,
+          }
+
+          chat_call payload
+        end
+
+        # Make a conversation as read up to a specific ID.
+        # @param users [Array<String>] a list of the users in the conversation
+        # @param id [Integer] the id of the message to mark up to
+        # @return [OpenStruct] a struct mapping of the JSON response
+        def mark_conversation(users, id)
+          payload = envelope :mark, options: {
+            channel: {
+              name: Core::U[*users],
+            },
+            message_id: id,
+          }
+
+          chat_call payload
+        end
+
+        # Mute a conversation.
+        # @param users [Array<String>] a list of the users in the conversation
+        # @return [OpenStruct] a struct mapping of the JSON response
+        def mute_conversation(users)
+          payload = envelope :setstatus, options: {
+            channel: {
+              name: Core::U[*users],
+            },
+            status: "muted",
+          }
+
+          chat_call payload
+        end
+      end
+    end
+  end
+end

data/lib/keybase/local/config.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Keybase
+  module Local
+    # Methods and constants related to a local Keybase installation.
+    module Config
+      # The Keybase configuration directory.
+      CONFIG_DIR = if Gem.win_platform?
+                     File.expand_path("#{ENV["LOCALAPPDATA"]}/Keybase").freeze
+                   else
+                     File.expand_path("~/.config/keybase").freeze
+                   end
+
+      # The Keybase configuration file.
+      CONFIG_FILE = File.join(CONFIG_DIR, "config.json").freeze
+
+      # there's not much this library can do without a local config
+      raise Exceptions::KeybaseNotInstalledError unless File.file?(CONFIG_FILE)
+
+      # The hash from Keybase's configuration file.
+      CONFIG_HASH = JSON.parse(File.read(CONFIG_FILE)).freeze
+
+      # The mountpoint for KBFS.
+      KBFS_MOUNT = "/keybase"
+
+      # @return [String] the currently logged-in user
+      def current_user
+        CONFIG_HASH["current_user"]
+      end
+
+      # @return [Array<Keybase::Local::User>] a list of all local users known
+      #  to Keybase
+      def local_users
+        CONFIG_HASH["users"].map { |_, v| User.new(v) }
+      end
+
+      # @return [String] the user's private KBFS directory
+      def private_dir
+        File.join(KBFS_MOUNT, "private", current_user)
+      end
+
+      # @return [String] the user's public KBFS directory
+      def public_dir
+        File.join(KBFS_MOUNT, "public", current_user)
+      end
+
+      # @return [Boolean] whether or not Keybase is currently running
+      def running?
+        if Gem.win_platform?
+          !`tasklist | find "keybase.exe"`.empty?
+        else
+          # is there a more efficient way to do this that doesn't involve an exec?
+          Dir["/proc/[0-9]*/comm"].any? do |comm|
+            File.read(comm).chomp == "keybase" rescue false # hooray for TOCTOU
+          end
+        end
+      end
+
+      # @return [String] the running Keybase's version string
+      # @raise [Exceptions::KeybaseNotRunningError] if Keybase is not running
+      def running_version
+        raise Exceptions::KeybaseNotRunningError unless running?
+        `keybase --version`.split[2]
+      end
+    end
+  end
+end

data/lib/keybase/local/exceptions.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Keybase
+  module Local
+    # A namespace for all exceptions defined by {Keybase::Local}.
+    module Exceptions
+      # Raised if a Keybase installation can't be found.
+      class KeybaseNotInstalledError < Core::Exceptions::KeybaseError
+        def initialize
+          super "keybase needs to be installed"
+        end
+      end
+
+      # Raised whenever Keybase is not running locally.
+      class KeybaseNotRunningError < Core::Exceptions::KeybaseError
+        def initialize
+          super "keybase needs to be running"
+        end
+      end
+
+      # Raised whenever KBFS is not running locally.
+      class KBFSNotRunningError < Core::Exceptions::KeybaseError
+        def initialize
+          super "KBFS needs to be enabled and running"
+        end
+      end
+    end
+  end
+end

data/lib/keybase/local/kbfs.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Keybase
+  module Local
+    # Represents an interface to KBFS.
+    # @note This is a stub.
+    module KBFS
+      # stub
+    end
+  end
+end

data/lib/keybase/local/team.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Keybase
+  module Local
+    # Represents an interface to Keybase's teams.
+    # @note This is a stub.
+    module Team
+      # stub
+    end
+  end
+end

data/lib/keybase/local/user.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Keybase
+  module Local
+    # Represents a user known to the local Keybase process.
+    # These are (presumably) users that have been logged into locally.
+    class User
+      # @return [String] the device's unique identifier
+      attr_reader :device
+
+      # @return [String] the user's unique identifier
+      attr_reader :id
+
+      # @return [String] the user's Keybase username
+      attr_reader :name
+
+      # @return [String] some kind of salt
+      # @note I have no idea what this field does.
+      attr_reader :salt
+
+      # @param fields [Hash] the user's configuration fields
+      # @option fields device [String] the device's unique identifier
+      # @option fields id [String] the user's unique identifier
+      # @option fields name [String] the user's Keybase username
+      # @option fields salt [String] some kind of salt
+      def initialize(fields)
+        @device = fields["device"]
+        @id     = fields["id"]
+        @name   = fields["name"]
+        @salt   = fields["salt"]
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: keybase-unofficial-local
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- William Woodruff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: keybase-unofficial-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: |
+  This library provides access to Keybase's desktop utility from
+  Ruby.
+email: william@tuffbizz.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- LICENSE
+- README.md
+- lib/keybase/local.rb
+- lib/keybase/local/chat.rb
+- lib/keybase/local/config.rb
+- lib/keybase/local/exceptions.rb
+- lib/keybase/local/kbfs.rb
+- lib/keybase/local/team.rb
+- lib/keybase/local/user.rb
+homepage: https://github.com/woodruffw/keybase-unofficial-local
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: keybase-unofficial-local - Unofficial library for Keybase clients
+test_files: []