shai-cli 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d4d5f46776b74f36b7f259d6edb67489f519dbc98b5ae5b0e44be82fed60d2d
-  data.tar.gz: 9669269dd3ac52f2161a488e68364da7e58ecb0d32328ca901ed18014b7ed8ef
+  metadata.gz: 1ea758284c9ecb5985d8789033ee4368ec95757ac056a0b5870f9d8f523d9282
+  data.tar.gz: 046a439279ef5a6c2cf32eeb9f5d00f7656887cb310168c334306796cd73f713
 SHA512:
-  metadata.gz: a4d113fbd60fbd071f71d47ece7aba4848e9160f41feda7bcdfe39612d0c029f96a85dc31ebe473121b964459d20d2264ce080cb83a4ada5238e619273a1590c
-  data.tar.gz: 768577aecf1ec1e52301dededa606b7f2864fab148f1ad620bcc027a9fbc648e9559dedd1cbcea629fdaf3ad46c99830d99175307fd10a03f611f455003ef953
+  metadata.gz: 3f158f9131a3d10a7717b4d2109e9ae37682b4c2d2f68de5ab516c0c4e789ad86556dff17b973c7a8daa23527486064057c1ef1b72c0064d206141a3f87bc204
+  data.tar.gz: e266d13cb6135d0530f5363e1f568a57fb2558a0a0b747b1b2820c4e921247d5114624727f4865711f44758d619f22bd233cd6464326612f2944aaba1b2514cc

data/README.md

@@ -89,11 +89,48 @@ shai uninstall anthropic/claude-expert
 
 ### Authentication
 
-| Command       | Description                           |
-| ------------- | ------------------------------------- |
-| `shai login`  | Log in to shaicli.dev                 |
-| `shai logout` | Log out and remove stored credentials |
-| `shai whoami` | Show current authentication status    |
+| Command                | Description                                    |
+| ---------------------- | ---------------------------------------------- |
+| `shai login`           | Log in via browser (device flow, recommended)  |
+| `shai login --password`| Log in with email/password directly            |
+| `shai logout`          | Log out and remove stored credentials          |
+| `shai whoami`          | Show current authentication status             |
+
+**Device Flow (default):**
+
+The default login uses OAuth 2.0 Device Authorization Grant - a secure flow that doesn't require entering your password in the terminal:
+
+```bash
+$ shai login
+Starting device authorization...
+
+To authorize this device:
+
+  1. Visit: https://shaicli.dev/device
+  2. Enter code: ABCD-1234
+
+Open browser automatically? (Y/n) y
+
+[⠋] Waiting for authorization...
+
+✓ Logged in as johndoe
+  Token expires: March 11, 2026
+  Token stored in ~/.config/shai/credentials
+```
+
+**Password Flow (legacy):**
+
+If you prefer to enter credentials directly:
+
+```bash
+$ shai login --password
+Email or username: johndoe
+Password: ********
+
+✓ Logged in as johndoe
+```
+
+**Check Status:**
 
 ```bash
 $ shai whoami

data/lib/shai/api_client.rb

@@ -20,6 +20,21 @@ module Shai
       })
     end
 
+    # Device Flow Authentication (RFC 8628)
+    def device_authorize(client_name: nil)
+      client_name ||= default_client_name
+      post_without_auth("/api/v1/device/authorize", {
+        client_name: client_name
+      })
+    end
+
+    def device_token(device_code:)
+      response = @connection.post("/api/v1/device/token") do |req|
+        req.body = {device_code: device_code}
+      end
+      handle_device_token_response(response)
+    end
+
     # Configurations
     def list_configurations
       get("/api/v1/configurations")
@@ -64,6 +79,10 @@ module Shai
       put("/api/v1/configurations/#{encode_identifier(identifier)}/tree", {tree: tree})
     end
 
+    def record_install(identifier)
+      post_without_auth("/api/v1/configurations/#{encode_identifier(identifier)}/install", {})
+    end
+
     # Encode identifier for URL (handles owner/slug format)
     def encode_identifier(identifier)
       URI.encode_www_form_component(identifier)
@@ -94,6 +113,13 @@ module Shai
       handle_response(response)
     end
 
+    def post_without_auth(path, body)
+      response = @connection.post(path) do |req|
+        req.body = body
+      end
+      handle_response(response)
+    end
+
     def put(path, body)
       response = @connection.put(path) do |req|
         add_auth_header(req)
@@ -126,6 +152,29 @@ module Shai
         raise NotFoundError, response.body&.dig("error") || "Not found"
       when 422
         raise InvalidConfigurationError, response.body&.dig("error") || "Invalid request"
+      when 429
+        retry_after = response.headers["Retry-After"]&.to_i
+        raise RateLimitError.new(
+          response.body&.dig("error") || "Too many requests. Please try again later.",
+          retry_after: retry_after
+        )
+      else
+        raise Error, response.body&.dig("error") || "Request failed with status #{response.status}"
+      end
+    rescue Faraday::ConnectionFailed, Faraday::TimeoutError
+      raise NetworkError, "Could not connect to #{Shai.configuration.api_url}. Check your internet connection."
+    end
+
+    def handle_device_token_response(response)
+      case response.status
+      when 200
+        response.body
+      when 400
+        error_code = response.body&.dig("error")
+        interval = response.body&.dig("interval")
+        raise DeviceFlowError.new(error_code, interval: interval)
+      when 429
+        raise DeviceFlowError.new("slow_down", interval: 10)
       else
         raise Error, response.body&.dig("error") || "Request failed with status #{response.status}"
       end

data/lib/shai/cli.rb

@@ -26,13 +26,15 @@ module Shai
       shell.say "  shai <command> [options]"
       shell.say ""
       shell.say "AUTHENTICATION:"
-      shell.say "  login              Log in to shaicli.dev"
+      shell.say "  login              Log in via browser (device flow)"
+      shell.say "  login --password   Log in with email/password directly"
       shell.say "  logout             Log out and remove stored credentials"
       shell.say "  whoami             Show current authentication status"
       shell.say ""
       shell.say "DISCOVERY:"
       shell.say "  list               List your configurations"
       shell.say "  search <query>     Search public configurations"
+      shell.say "  open <config>      Open a configuration in the browser"
       shell.say ""
       shell.say "USING CONFIGURATIONS (install to current project):"
       shell.say "  install <config>   Install a configuration to local project"
@@ -56,6 +58,7 @@ module Shai
       shell.say "EXAMPLES:"
       shell.say "  shai login"
       shell.say "  shai search \"claude code\""
+      shell.say "  shai open anthropic/claude-expert"
       shell.say "  shai install anthropic/claude-expert"
       shell.say "  shai init"
       shell.say "  shai push"

data/lib/shai/commands/auth.rb

@@ -1,38 +1,21 @@
 # frozen_string_literal: true
 
+require "launchy"
+
 module Shai
   module Commands
     module Auth
+      DEVICE_FLOW_TIMEOUT = 600 # 10 minutes
+
       def self.included(base)
         base.class_eval do
           desc "login", "Log in to shaicli.dev"
+          option :password, type: :boolean, default: false, desc: "Use password authentication instead of device flow"
           def login
-            identifier = ui.ask("Email or username:")
-            password = ui.mask("Password:")
-
-            ui.blank
-
-            begin
-              response = ui.spinner("Logging in...") do
-                api.login(identifier: identifier, password: password)
-              end
-
-              data = response["data"]
-              credentials.save(
-                token: data["token"],
-                expires_at: data["expires_at"],
-                user: data["user"]
-              )
-
-              ui.success("Logged in as #{data.dig("user", "username")}")
-              ui.indent("Token expires: #{format_date(data["expires_at"])}")
-              ui.indent("Token stored in #{Shai.configuration.credentials_path}")
-            rescue AuthenticationError
-              ui.error("Invalid credentials")
-              exit EXIT_AUTH_REQUIRED
-            rescue NetworkError => e
-              ui.error(e.message)
-              exit EXIT_NETWORK_ERROR
+            if options[:password]
+              login_with_password
+            else
+              login_with_device_flow
             end
           end
 
@@ -52,6 +35,151 @@ module Shai
               ui.info("Not logged in. Run `shai login` to authenticate.")
             end
           end
+
+          no_commands do
+            def login_with_password
+              identifier = ui.ask("Email or username:")
+              password = ui.mask("Password:")
+
+              ui.blank
+
+              begin
+                response = ui.spinner("Logging in...") do
+                  api.login(identifier: identifier, password: password)
+                end
+
+                save_credentials_from_response(response)
+              rescue AuthenticationError
+                ui.error("Invalid credentials")
+                exit EXIT_AUTH_REQUIRED
+              rescue RateLimitError
+                ui.error("Too many login attempts. Please try again later.")
+                exit EXIT_GENERAL_ERROR
+              rescue NetworkError => e
+                ui.error(e.message)
+                exit EXIT_NETWORK_ERROR
+              end
+            end
+
+            def login_with_device_flow
+              ui.info("Starting device authorization...")
+              ui.blank
+
+              begin
+                response = api.device_authorize
+              rescue RateLimitError => e
+                retry_msg = e.retry_after ? " Try again in #{e.retry_after} seconds." : ""
+                ui.error("Too many authorization attempts.#{retry_msg}")
+                exit EXIT_GENERAL_ERROR
+              rescue NetworkError => e
+                ui.error(e.message)
+                exit EXIT_NETWORK_ERROR
+              end
+
+              device_code = response["device_code"]
+              user_code = response["user_code"]
+              verification_uri = response["verification_uri"]
+              verification_uri_complete = response["verification_uri_complete"]
+              interval = response["interval"] || 5
+
+              display_device_code_instructions(
+                user_code: user_code,
+                verification_uri: verification_uri
+              )
+
+              ui.blank
+              if ui.yes?("Open browser automatically?", default: true)
+                open_browser(verification_uri_complete || verification_uri)
+              end
+
+              ui.blank
+              poll_for_authorization(device_code: device_code, interval: interval)
+            end
+
+            def display_device_code_instructions(user_code:, verification_uri:)
+              ui.info("To authorize this device:")
+              ui.blank
+              ui.indent("1. Visit: #{ui.cyan(verification_uri)}")
+              ui.indent("2. Enter code: #{ui.bold(user_code)}")
+            end
+
+            def open_browser(url)
+              Launchy.open(url)
+            rescue Launchy::CommandNotFoundError
+              ui.warning("Could not open browser automatically. Please visit the URL manually.")
+            end
+
+            def poll_for_authorization(device_code:, interval:)
+              start_time = Time.now
+              current_interval = interval
+
+              spinner = TTY::Spinner.new("[:spinner] Waiting for authorization...", format: :dots)
+              spinner.auto_spin
+
+              loop do
+                elapsed = Time.now - start_time
+                if elapsed > DEVICE_FLOW_TIMEOUT
+                  spinner.error
+                  ui.error("Authorization timed out. Please try again.")
+                  exit EXIT_AUTH_REQUIRED
+                end
+
+                sleep(current_interval)
+
+                begin
+                  response = api.device_token(device_code: device_code)
+
+                  # Success - we got a token
+                  spinner.success
+                  save_credentials_from_response(response)
+                  return
+                rescue DeviceFlowError => e
+                  case e.error_code
+                  when "authorization_pending"
+                    # Keep polling
+                    next
+                  when "slow_down"
+                    current_interval = e.interval || (current_interval + 5)
+                    next
+                  when "access_denied"
+                    spinner.error
+                    ui.blank
+                    ui.error("Authorization denied by user.")
+                    exit EXIT_AUTH_REQUIRED
+                  when "expired_token"
+                    spinner.error
+                    ui.blank
+                    ui.error("Device code expired. Please try again.")
+                    exit EXIT_AUTH_REQUIRED
+                  else
+                    spinner.error
+                    ui.blank
+                    ui.error("Authorization failed: #{e.error_code}")
+                    exit EXIT_AUTH_REQUIRED
+                  end
+                rescue NetworkError => e
+                  spinner.error
+                  ui.blank
+                  ui.error(e.message)
+                  exit EXIT_NETWORK_ERROR
+                end
+              end
+            end
+
+            def save_credentials_from_response(response)
+              data = response["data"]
+              credentials.save(
+                token: data["token"],
+                expires_at: data["expires_at"],
+                user: data["user"]
+              )
+
+              ui.blank
+              ui.success("Logged in as #{data.dig("user", "username")}")
+              ui.indent("Token expires: #{format_date(data["expires_at"])}")
+              ui.indent("Token stored in #{Shai.configuration.credentials_path}")
+            end
+          end
         end
       end
 

data/lib/shai/commands/configurations.rb

@@ -5,8 +5,6 @@ require "time"
 module Shai
   module Commands
     module Configurations
-      INSTALLED_FILE = ".shai-installed"
-
       def self.included(base)
         base.class_eval do
           desc "list", "List your configurations"
@@ -82,37 +80,31 @@ module Shai
             display_name = owner ? "#{owner}/#{slug}" : slug
             base_path = File.expand_path(options[:path])
             shairc_path = File.join(base_path, ".shairc")
-            installed_path = File.join(base_path, Shai::Commands::Configurations::INSTALLED_FILE)
 
-            # Check if a configuration is already installed/initialized
-            unless options[:force]
-              existing_slug = nil
+            installed = InstalledProjects.new(base_path)
 
-              if File.exist?(installed_path)
-                existing_config = begin
-                  YAML.safe_load_file(installed_path)
-                rescue
-                  {}
-                end
-                existing_slug = existing_config["slug"]
-              elsif File.exist?(shairc_path)
-                existing_config = begin
-                  YAML.safe_load_file(shairc_path)
-                rescue
-                  {}
-                end
-                existing_slug = existing_config["slug"]
+            # Check if this exact project is already installed
+            if installed.has_project?(display_name) && !options[:force]
+              ui.error("'#{display_name}' is already installed in this directory.")
+              ui.info("Use --force to reinstall, or run `shai uninstall #{display_name}` first.")
+              exit EXIT_INVALID_INPUT
+            end
+
+            # Check if a .shairc exists (authored config)
+            if File.exist?(shairc_path) && !options[:force]
+              existing_config = begin
+                YAML.safe_load_file(shairc_path)
+              rescue
+                {}
               end
+              existing_slug = existing_config["slug"]
 
               if existing_slug
-                ui.error("A configuration is already present in this directory.")
+                ui.error("This directory contains an authored configuration (.shairc).")
                 ui.indent("Existing: #{existing_slug}")
                 ui.blank
-                ui.info("To install a different configuration:")
-                ui.indent("1. Run `shai uninstall #{existing_slug}` to remove the current configuration")
-                ui.indent("2. Then run `shai install #{display_name}`")
-                ui.blank
-                ui.info("Or use --force to install anyway (may cause conflicts)")
+                ui.info("Installing here may cause conflicts with your authored config.")
+                ui.info("Use --force to install anyway.")
                 exit EXIT_INVALID_INPUT
               end
             end
@@ -127,39 +119,65 @@ module Shai
               # Security: Validate all paths before any file operations
               validate_tree_paths!(tree, base_path)
 
-              # Check for conflicts
-              conflicts = []
+              # Get file paths from tree (excluding folders)
+              new_files = tree.reject { |n| n["kind"] == "folder" }.map { |n| n["path"] }
+
+              # Check for conflicts with existing local files
+              local_conflicts = []
               tree.each do |node|
                 next if node["kind"] == "folder"
-
                 local_path = File.join(base_path, node["path"])
-                conflicts << node["path"] if File.exist?(local_path)
+                local_conflicts << node["path"] if File.exist?(local_path)
               end
 
+              # Check for conflicts with other installed projects
+              project_conflicts = installed.find_conflicts(new_files)
+
               if options[:dry_run]
                 ui.header("Would install:")
                 tree.each { |node| ui.display_file_operation(:would_create, node["path"]) }
+
+                if project_conflicts.any?
+                  ui.blank
+                  ui.warning("Would conflict with installed projects:")
+                  project_conflicts.each do |file, owner|
+                    ui.indent("#{file} (from #{owner})")
+                  end
+                end
+
                 ui.blank
                 ui.info("No changes made (dry run)")
                 return
               end
 
               # Handle conflicts
-              if conflicts.any? && !options[:force]
-                ui.blank
-                ui.warning("The following files already exist:")
-                conflicts.each { |path| ui.display_file_operation(:conflict, path) }
+              if (local_conflicts.any? || project_conflicts.any?) && !options[:force]
                 ui.blank
 
-                choice = ui.select("Overwrite existing files?", [
-                  {name: "Yes", value: :yes},
-                  {name: "No (abort)", value: :no},
+                if project_conflicts.any?
+                  ui.warning("The following files conflict with already installed projects:")
+                  project_conflicts.each do |file, owner|
+                    ui.indent("#{file} #{ui.dim("(from #{owner})")}")
+                  end
+                  ui.blank
+                end
+
+                other_local_conflicts = local_conflicts - project_conflicts.keys
+                if other_local_conflicts.any?
+                  ui.warning("The following local files will be overwritten:")
+                  other_local_conflicts.each { |path| ui.display_file_operation(:conflict, path) }
+                  ui.blank
+                end
+
+                choice = ui.select("How would you like to proceed?", [
+                  {name: "Overwrite files (conflicting projects will be updated)", value: :yes},
+                  {name: "Cancel installation", value: :no},
                   {name: "Show diff", value: :diff}
                 ])
 
                 if choice == :diff
-                  show_install_diff(tree, base_path, conflicts)
-                  return unless ui.yes?("Overwrite existing files?")
+                  show_install_diff(tree, base_path, local_conflicts)
+                  return unless ui.yes?("Proceed with installation?")
                 elsif choice == :no
                   ui.info("Installation cancelled")
                   return
@@ -169,8 +187,17 @@ module Shai
               ui.header("Installing #{display_name}...")
               ui.blank
 
+              # Remove conflicting files from their original projects
+              if project_conflicts.any?
+                affected_projects = project_conflicts.values.uniq
+                affected_projects.each do |project_slug|
+                  files_to_remove = project_conflicts.select { |_, owner| owner == project_slug }.keys
+                  installed.remove_files_from_project(project_slug, files_to_remove)
+                end
+              end
+
               # Create folders and files
-              created_count = 0
+              created_files = []
               tree.sort_by { |n| (n["kind"] == "folder") ? 0 : 1 }.each do |node|
                 local_path = File.join(base_path, node["path"])
 
@@ -181,20 +208,26 @@ module Shai
                   FileUtils.mkdir_p(File.dirname(local_path))
                   File.write(local_path, node["content"])
                   ui.display_file_operation(:created, node["path"])
+                  created_files << node["path"]
                 end
-                created_count += 1
               end
 
-              # Write installation tracking file
-              installed_content = <<~YAML
-                # Installed by shai - do not edit manually
-                slug: "#{display_name}"
-                installed_at: "#{Time.now.iso8601}"
-              YAML
-              File.write(installed_path, installed_content)
+              # Track the installed project
+              installed.add_project(display_name, created_files)
+
+              # Record the install for analytics (fire and forget)
+              begin
+                api.record_install(display_name)
+              rescue
+                # Silently ignore install tracking errors
+              end
 
               ui.blank
-              ui.success("Installed #{created_count} items from #{display_name}")
+              ui.success("Installed #{display_name}")
+
+              if installed.project_count > 1
+                ui.indent("#{installed.project_count} configurations now installed in this directory")
+              end
             rescue NotFoundError
               ui.error("Configuration '#{display_name}' not found.")
               exit EXIT_NOT_FOUND
@@ -207,116 +240,198 @@ module Shai
             end
           end
 
+          desc "open CONFIGURATION", "Open a configuration in the browser"
+          def open(configuration)
+            owner, slug = parse_configuration_name(configuration)
+            display_name = owner ? "#{owner}/#{slug}" : slug
+            base_url = Shai.configuration.api_url
+
+            # Fetch configuration details to determine ownership and visibility
+            begin
+              config = ui.spinner("Fetching #{display_name}...") do
+                api.get_configuration(display_name)
+              end
+
+              config_owner = config["owner"]
+              config_slug = config["slug"]
+              visibility = config["visibility"]
+              current_username = credentials.authenticated? ? credentials.username : nil
+
+              # Determine the appropriate URL based on ownership
+              if current_username && config_owner == current_username
+                # User owns this config - open in configuration_projects
+                url = "#{base_url}/configuration_projects/#{config_slug}"
+              elsif visibility == "public"
+                # Public config owned by someone else - open in explore
+                url = "#{base_url}/explore/#{config_owner}/#{config_slug}"
+              else
+                # Private config not owned by user - can't access
+                ui.error("Configuration '#{display_name}' is private and you don't have access.")
+                exit EXIT_PERMISSION_DENIED
+              end
+
+              ui.info("Opening #{display_name} in browser...")
+
+              begin
+                require "launchy"
+                Launchy.open(url)
+              rescue LoadError
+                ui.warning("Could not open browser automatically.")
+                ui.info("Visit: #{url}")
+              rescue Launchy::Error => e
+                ui.warning("Could not open browser: #{e.message}")
+                ui.info("Visit: #{url}")
+              end
+            rescue NotFoundError
+              if owner
+                ui.error("Configuration '#{display_name}' not found.")
+                ui.info("It may be private or doesn't exist.")
+              else
+                ui.error("Configuration '#{display_name}' not found in your projects.")
+                ui.info("Use 'owner/slug' format to open someone else's public configuration.")
+              end
+              exit EXIT_NOT_FOUND
+            rescue PermissionDeniedError
+              ui.error("You don't have permission to access '#{display_name}'.")
+              ui.info("This configuration may be private.")
+              exit EXIT_PERMISSION_DENIED
+            rescue NetworkError => e
+              ui.error(e.message)
+              exit EXIT_NETWORK_ERROR
+            end
+          end
+
           desc "uninstall [CONFIGURATION]", "Remove an installed configuration from local project"
           option :dry_run, type: :boolean, default: false, desc: "Show what would be removed"
           option :path, type: :string, default: ".", desc: "Path where configuration is installed"
           def uninstall(configuration = nil)
-            # No auth required - uninstall just fetches tree (works for public configs)
-            # and removes local files
-
             base_path = File.expand_path(options[:path])
-            installed_path = File.join(base_path, INSTALLED_FILE)
+            installed = InstalledProjects.new(base_path)
 
-            # If no configuration specified, try to read from .shai-installed
+            # If no configuration specified, determine which to uninstall
             if configuration.nil?
-              unless File.exist?(installed_path)
-                ui.error("No configuration specified and no .shai-installed file found.")
+              if installed.empty?
+                ui.error("No configurations installed in this directory.")
                 ui.info("Usage: shai uninstall <configuration>")
                 exit EXIT_INVALID_INPUT
-              end
-
-              installed_config = YAML.safe_load_file(installed_path)
-              configuration = installed_config["slug"]
+              elsif installed.project_count == 1
+                configuration = installed.project_slugs.first
+                ui.info("Uninstalling #{configuration}...")
+              else
+                ui.info("Multiple configurations installed:")
+                configuration = ui.select("Which configuration do you want to uninstall?",
+                  installed.project_slugs.map { |s| {name: s, value: s} } + [{name: "Cancel", value: nil}])
 
-              unless configuration
-                ui.error("Could not read configuration from .shai-installed")
-                exit EXIT_INVALID_INPUT
+                if configuration.nil?
+                  ui.info("Uninstall cancelled")
+                  return
+                end
               end
             end
 
             owner, slug = parse_configuration_name(configuration)
             display_name = owner ? "#{owner}/#{slug}" : slug
 
-            begin
-              response = ui.spinner("Fetching #{display_name}...") do
-                api.get_tree(display_name)
-              end
-
-              tree = response.is_a?(Array) ? response : response["tree"]
-
-              # Security: Validate all paths before any file operations
-              validate_tree_paths!(tree, base_path)
-
-              # Find files that exist locally
-              files_to_remove = []
-              folders_to_remove = []
-
-              tree.each do |node|
-                local_path = File.join(base_path, node["path"])
+            # Get files to remove - either from tracking or from remote tree
+            tracked_files = installed.files_for_project(display_name)
 
-                if node["kind"] == "folder"
-                  folders_to_remove << node["path"] if Dir.exist?(local_path)
-                elsif File.exist?(local_path)
-                  files_to_remove << node["path"]
+            if tracked_files.empty?
+              # Fall back to fetching from remote (for v1 migrations or manual installs)
+              begin
+                response = ui.spinner("Fetching #{display_name}...") do
+                  api.get_tree(display_name)
                 end
-              end
 
-              if files_to_remove.empty? && folders_to_remove.empty?
-                ui.info("No files from '#{display_name}' found in #{base_path}")
-                return
+                tree = response.is_a?(Array) ? response : response["tree"]
+                validate_tree_paths!(tree, base_path)
+
+                tracked_files = tree.reject { |n| n["kind"] == "folder" }.map { |n| n["path"] }
+              rescue NotFoundError
+                ui.error("Configuration '#{display_name}' not found and no tracked files.")
+                exit EXIT_NOT_FOUND
+              rescue PermissionDeniedError
+                ui.error("You don't have permission to access '#{display_name}'.")
+                exit EXIT_PERMISSION_DENIED
+              rescue NetworkError => e
+                ui.error(e.message)
+                exit EXIT_NETWORK_ERROR
               end
+            end
 
-              if options[:dry_run]
-                ui.header("Would remove:")
-                files_to_remove.each { |path| ui.display_file_operation(:would_create, path) }
-                folders_to_remove.sort.reverse_each { |path| ui.display_file_operation(:would_create, path + "/") }
-                ui.blank
-                ui.info("No changes made (dry run)")
-                return
+            # Find files that exist locally
+            files_to_remove = []
+            folders_to_check = Set.new
+
+            tracked_files.each do |path|
+              local_path = File.join(base_path, path)
+              if File.exist?(local_path)
+                files_to_remove << path
+                # Track parent folders for potential removal
+                dir = File.dirname(path)
+                while dir != "."
+                  folders_to_check << dir
+                  dir = File.dirname(dir)
+                end
               end
+            end
 
-              unless ui.yes?("Remove #{files_to_remove.length} files and #{folders_to_remove.length} folders from '#{display_name}'?")
-                ui.info("Uninstall cancelled")
-                return
+            if files_to_remove.empty?
+              ui.info("No files from '#{display_name}' found in #{base_path}")
+
+              # Still remove from tracking if it exists
+              if installed.has_project?(display_name)
+                installed.remove_project(display_name)
+                installed.delete! if installed.empty?
               end
+              return
+            end
 
-              ui.header("Uninstalling #{display_name}...")
+            if options[:dry_run]
+              ui.header("Would remove:")
+              files_to_remove.each { |path| ui.display_file_operation(:would_create, path) }
               ui.blank
+              ui.info("No changes made (dry run)")
+              return
+            end
 
-              # Remove files first
-              files_to_remove.each do |path|
-                local_path = File.join(base_path, path)
-                File.delete(local_path)
-                ui.display_file_operation(:deleted, path)
-              end
+            unless ui.yes?("Remove #{files_to_remove.length} files from '#{display_name}'?")
+              ui.info("Uninstall cancelled")
+              return
+            end
 
-              # Remove folders (deepest first)
-              folders_to_remove.sort.reverse_each do |path|
-                local_path = File.join(base_path, path)
-                if Dir.exist?(local_path) && Dir.empty?(local_path)
-                  Dir.rmdir(local_path)
-                  ui.display_file_operation(:deleted, path + "/")
-                end
-              end
+            ui.header("Uninstalling #{display_name}...")
+            ui.blank
+
+            # Remove files
+            files_to_remove.each do |path|
+              local_path = File.join(base_path, path)
+              File.delete(local_path)
+              ui.display_file_operation(:deleted, path)
+            end
 
-              # Remove installation tracking file
-              installed_path = File.join(base_path, Shai::Commands::Configurations::INSTALLED_FILE)
-              if File.exist?(installed_path)
-                File.delete(installed_path)
-                ui.display_file_operation(:deleted, Shai::Commands::Configurations::INSTALLED_FILE)
+            # Remove empty folders (deepest first)
+            folders_to_check.to_a.sort.reverse_each do |path|
+              local_path = File.join(base_path, path)
+              if Dir.exist?(local_path) && Dir.empty?(local_path)
+                Dir.rmdir(local_path)
+                ui.display_file_operation(:deleted, path + "/")
               end
+            end
 
-              ui.blank
-              ui.success("Uninstalled #{display_name}")
-            rescue NotFoundError
-              ui.error("Configuration '#{display_name}' not found.")
-              exit EXIT_NOT_FOUND
-            rescue PermissionDeniedError
-              ui.error("You don't have permission to access '#{display_name}'.")
-              exit EXIT_PERMISSION_DENIED
-            rescue NetworkError => e
-              ui.error(e.message)
-              exit EXIT_NETWORK_ERROR
+            # Update tracking
+            installed.remove_project(display_name)
+
+            # Remove tracking file if no more projects
+            if installed.empty?
+              installed.delete!
+              ui.display_file_operation(:deleted, InstalledProjects::FILENAME)
+            end
+
+            ui.blank
+            ui.success("Uninstalled #{display_name}")
+
+            if installed.project_count > 0
+              ui.indent("#{installed.project_count} configuration(s) still installed")
             end
           end
         end

data/lib/shai/installed_projects.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "time"
+
+module Shai
+  class InstalledProjects
+    FILENAME = ".shai-installed"
+    CURRENT_VERSION = 2
+
+    attr_reader :base_path
+
+    def initialize(base_path)
+      @base_path = File.expand_path(base_path)
+      @data = load_data
+    end
+
+    def file_path
+      File.join(base_path, FILENAME)
+    end
+
+    def exists?
+      File.exist?(file_path)
+    end
+
+    def projects
+      @data["projects"] || {}
+    end
+
+    def project_slugs
+      projects.keys
+    end
+
+    def empty?
+      projects.empty?
+    end
+
+    def project_count
+      projects.size
+    end
+
+    def has_project?(slug)
+      projects.key?(slug)
+    end
+
+    def get_project(slug)
+      projects[slug]
+    end
+
+    def files_for_project(slug)
+      projects.dig(slug, "files") || []
+    end
+
+    def all_installed_files
+      projects.values.flat_map { |p| p["files"] || [] }
+    end
+
+    # Find which project owns a specific file
+    def project_for_file(file_path)
+      projects.each do |slug, data|
+        return slug if (data["files"] || []).include?(file_path)
+      end
+      nil
+    end
+
+    # Check for conflicts between new files and already installed projects
+    # Returns hash of { file_path => owning_project_slug }
+    def find_conflicts(new_files)
+      conflicts = {}
+      new_files.each do |file|
+        owner = project_for_file(file)
+        conflicts[file] = owner if owner
+      end
+      conflicts
+    end
+
+    # Add a new project with its files
+    def add_project(slug, files)
+      @data["projects"][slug] = {
+        "installed_at" => Time.now.iso8601,
+        "files" => files.sort
+      }
+      save!
+    end
+
+    # Remove a project and return its files
+    def remove_project(slug)
+      project = @data["projects"].delete(slug)
+      save! if project
+      project&.dig("files") || []
+    end
+
+    # Remove specific files from a project (when being overwritten)
+    def remove_files_from_project(slug, files_to_remove)
+      return unless @data["projects"][slug]
+
+      current_files = @data["projects"][slug]["files"] || []
+      @data["projects"][slug]["files"] = current_files - files_to_remove
+
+      # If no files left, remove the project entirely
+      if @data["projects"][slug]["files"].empty?
+        @data["projects"].delete(slug)
+      end
+
+      save!
+    end
+
+    def save!
+      content = YAML.dump(@data)
+      header = "# Installed by shai - do not edit manually\n"
+      File.write(file_path, header + content)
+    end
+
+    def delete!
+      File.delete(file_path) if exists?
+    end
+
+    private
+
+    def load_data
+      return default_data unless exists?
+
+      raw = YAML.safe_load_file(file_path) || {}
+
+      # Handle old format (version 1 / no version)
+      if raw["version"].nil? || raw["version"] < CURRENT_VERSION
+        migrate_from_v1(raw)
+      else
+        raw
+      end
+    rescue
+      # If file is corrupted, start fresh
+      default_data
+    end
+
+    def default_data
+      {
+        "version" => CURRENT_VERSION,
+        "projects" => {}
+      }
+    end
+
+    def migrate_from_v1(old_data)
+      # Old format had: { "slug" => "name", "installed_at" => "..." }
+      slug = old_data["slug"]
+      installed_at = old_data["installed_at"]
+
+      if slug
+        {
+          "version" => CURRENT_VERSION,
+          "projects" => {
+            slug => {
+              "installed_at" => installed_at || Time.now.iso8601,
+              "files" => [] # We don't know the files from v1, will be populated on next operation
+            }
+          }
+        }
+      else
+        default_data
+      end
+    end
+  end
+end

data/lib/shai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Shai
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/shai.rb

@@ -4,6 +4,7 @@ require_relative "shai/version"
 require_relative "shai/configuration"
 require_relative "shai/credentials"
 require_relative "shai/api_client"
+require_relative "shai/installed_projects"
 require_relative "shai/cli"
 
 module Shai
@@ -19,6 +20,41 @@ module Shai
 
   class InvalidConfigurationError < Error; end
 
+  class RateLimitError < Error
+    attr_reader :retry_after
+
+    def initialize(message = "Too many requests", retry_after: nil)
+      @retry_after = retry_after
+      super(message)
+    end
+  end
+
+  class DeviceFlowError < Error
+    attr_reader :error_code, :interval
+
+    def initialize(error_code, interval: nil)
+      @error_code = error_code
+      @interval = interval
+      super(error_code)
+    end
+
+    def authorization_pending?
+      error_code == "authorization_pending"
+    end
+
+    def slow_down?
+      error_code == "slow_down"
+    end
+
+    def access_denied?
+      error_code == "access_denied"
+    end
+
+    def expired?
+      error_code == "expired_token"
+    end
+  end
+
   # Exit codes as specified in tech spec
   EXIT_SUCCESS = 0
   EXIT_GENERAL_ERROR = 1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shai-cli
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Sebastian Jimenez
@@ -107,6 +107,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: launchy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
 description: A command-line interface for shaicli.dev - download, share, and sync
   AI agent configurations (Claude, Cursor, etc.) across projects and teams.
 email:
@@ -128,6 +142,7 @@ files:
 - lib/shai/commands/sync.rb
 - lib/shai/configuration.rb
 - lib/shai/credentials.rb
+- lib/shai/installed_projects.rb
 - lib/shai/ui.rb
 - lib/shai/version.rb
 homepage: https://shaicli.dev