flycal-cli 1.1 → 1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcbd8c2cfb6f90272cf8cc8cfa489bc99a7487efca11f68560b2d7f96ac92f34
-  data.tar.gz: 21e92239db0dc5b3f587abdd1e859b5e67e67293706f6ec1f50ca34ca4fe0e1d
+  metadata.gz: 55605292daf7d56f71dc210b4c607ebceeb0aa1be1bc464ba73d82ce26583c4a
+  data.tar.gz: 256c9dd132265a9d7b36ac7a144c516b06d5c298f9a8e8fb8ac29e1fe2a7bc53
 SHA512:
-  metadata.gz: 2524fb58d1faecdf6ac6643761315f2586f6fe10b4535f2f50b87418f871665f13c84110c3d627ad2131bb9b2ef95aa171c0e6e1e41b52f87d7b76fd7261493c
-  data.tar.gz: 906c85b9dd3711aa16874a6f41be9851be1accbd07d131b09fb9f6173ed26d0e081f6607b457d606f538ea8861ab98dcff89b6cdab4f482b79ffe0c8af41eb7b
+  metadata.gz: b7a93a60e2cfd438b9b9ef9b52bf1c1a06e07c329bf3e86d3e8ef2253a5bf96c8bbbb390c5258b5250d71e0f87d6669b1088c1b7d10a3bebac0ad9809dc4f638
+  data.tar.gz: 5fc7e9f8a1d202e84caf771498a5758023a8aa16a240e6490108eb31d73507889857ca40a2db00309a78f7c15de34f16db1a334037bc44cd684531bac8d73053

data/config/defaults.yml

@@ -1,4 +1,5 @@
 calendar_default: ~
 locale: en
+timezone: Europe/Rome
 # `slots` is injected from Flycal::DefaultSlots at load/setup time.
 # After first write, the CLI reads templates from this file on disk.

data/config/oauth_client.json

@@ -0,0 +1,14 @@
+{
+  "installed": {
+    "client_id": "854938129342-tnf0miouj03b4vgi17aol1j8aann25mn.apps.googleusercontent.com",
+    "project_id": "flycal-387320",
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://oauth2.googleapis.com/token",
+    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+    "client_secret": "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",
+    "redirect_uris": [
+      "http://localhost",
+      "http://127.0.0.1:9292/oauth2callback"
+    ]
+  }
+}

data/lib/flycal/cli/app.rb

@@ -22,29 +22,23 @@ module Cli
     end
 
     desc "login", "Connect to your Google account"
+    option :client, type: :string,
+           desc: "OAuth client: flycal (Flycal Desktop app) or json (~/.flycal/credentials.json)"
     def login
       apply_locale_override
       if Auth.logged_in?
-        puts "✓ You are already connected to your Google account."
-        puts "\nRun 'flycal config' to set the default calendar."
+        puts Locale.t("login.already_connected")
+        puts "\n#{Locale.t('login.next_config')}"
         return
       end
 
-      unless Config.credentials_exist?
-        puts "Error: Credentials file not found."
-        puts "\nTo configure flycal:"
-        puts "1. Go to https://console.cloud.google.com/apis/credentials"
-        puts "2. Create 'Desktop app' credentials"
-        puts "3. Download the JSON and save it as: #{Config.credentials_path}"
-        puts "\nAlso add this URI as an authorized redirect:"
-        puts "  http://127.0.0.1:9292/oauth2callback"
-        return
-      end
+      mode = resolve_login_mode
+      return unless mode
 
       begin
-        Auth.login
-        puts "\n✓ Authentication completed successfully!"
-        puts "\nRun 'flycal config' to set the default calendar."
+        Auth.login(mode)
+        puts "\n#{Locale.t('login.success')}"
+        puts "\n#{Locale.t('login.next_config')}"
       rescue Flycal::Error => e
         puts "Error: #{e.message}"
         exit 1
@@ -332,17 +326,28 @@ module Cli
       from_value = options[:from].to_s.strip
       from_value = defaults["from"].to_s.strip if from_value.empty?
       from_value = "now" if from_value.empty?
+      timezone = Config.timezone
+      template_name = nil
+      hours = nil
+      days = nil
+      slot_duration = nil
+      free_before = nil
+      free_after = nil
+      time_min = nil
+      time_max = nil
 
       begin
-        resolved = SlotTemplates.resolve(name: options[:template], catalog: slot_cfg["templates"])
-        template_name = resolved[:name]
-        hours = resolved[:hours]
-        days = resolved[:days]
-        slot_duration = DurationParser.to_seconds(duration_value)
-        free_before = DurationParser.to_seconds(slot_cfg["free_before"] || "0m")
-        free_after = DurationParser.to_seconds(slot_cfg["free_after"] || "0m")
-        time_min = parse_slots_from(from_value)
-        time_max = DurationParser.add_to_time(in_value, time_min)
+        TimeFormat.with_zone(timezone) do
+          resolved = SlotTemplates.resolve(name: options[:template], catalog: slot_cfg["templates"])
+          template_name = resolved[:name]
+          hours = resolved[:hours]
+          days = resolved[:days]
+          slot_duration = DurationParser.to_seconds(duration_value)
+          free_before = DurationParser.to_seconds(slot_cfg["free_before"] || "0m")
+          free_after = DurationParser.to_seconds(slot_cfg["free_after"] || "0m")
+          time_min = parse_slots_from(from_value)
+          time_max = DurationParser.add_to_time(in_value, time_min)
+        end
       rescue Flycal::Error => e
         puts "Error: #{e.message}"
         exit 1
@@ -380,6 +385,7 @@ module Cli
         free_after: slot_cfg["free_after"] || "0m",
         template: template_name,
         locale: Locale.current_locale,
+        timezone: timezone,
         calendar: options[:calendar],
         hours: hours,
         days: days,
@@ -404,55 +410,57 @@ module Cli
       if output.nil?
         FileCache.delete(cache_key) if nocache
 
-        calendars = client.list_calendars
-        calendar_meta = exclude_calendar_ids.filter_map do |id|
-          cal = calendars.find { |c| c.id == id }
-          name = cal&.summary || id
-          { id: id, name: name }
-        end
-
-        fetch_from = time_min - free_before
-        events = exclude_calendar_ids.flat_map do |calendar_id|
-          client.list_events(
-            calendar_id,
-            time_min: fetch_from,
-            time_max: time_max
-          )
-        rescue Google::Apis::Error => e
-          warn Locale.t("errors.calendar_fetch", calendar: calendar_id, message: e.message)
-          []
-        end
+        TimeFormat.with_zone(timezone) do
+          calendars = client.list_calendars
+          calendar_meta = exclude_calendar_ids.filter_map do |id|
+            cal = calendars.find { |c| c.id == id }
+            name = cal&.summary || id
+            { id: id, name: name }
+          end
 
-        finder = SlotFinder.new(
-          events: events,
-          time_min: time_min,
-          time_max: time_max,
-          slot_duration_seconds: slot_duration,
-          hours: hours,
-          days: days,
-          free_before_seconds: free_before,
-          free_after_seconds: free_after
-        )
+          fetch_from = time_min - free_before
+          events = exclude_calendar_ids.flat_map do |calendar_id|
+            client.list_events(
+              calendar_id,
+              time_min: fetch_from,
+              time_max: time_max
+            )
+          rescue Google::Apis::Error => e
+            warn Locale.t("errors.calendar_fetch", calendar: calendar_id, message: e.message)
+            []
+          end
 
-        slots_by_day = finder.slots_by_day
+          finder = SlotFinder.new(
+            events: events,
+            time_min: time_min,
+            time_max: time_max,
+            slot_duration_seconds: slot_duration,
+            hours: hours,
+            days: days,
+            free_before_seconds: free_before,
+            free_after_seconds: free_after
+          )
 
-        output =
-          if format == "json"
-            SlotFormatter.format_json(
-              slots_by_day: slots_by_day,
-              time_min: time_min,
-              time_max: time_max,
-              duration: duration_value,
-              template: template_name,
-              calendars: calendar_meta,
-              locale: Locale.current_locale,
-              calendar_option: options[:calendar],
-              from_option: options[:from],
-              in_option: options[:in],
-              free_before: slot_cfg["free_before"],
-              free_after: slot_cfg["free_after"],
-              empty_message: Locale.t("slots.no_available")
-            )
+          slots_by_day = finder.slots_by_day
+
+          output =
+            if format == "json"
+              SlotFormatter.format_json(
+                slots_by_day: slots_by_day,
+                time_min: time_min,
+                time_max: time_max,
+                duration: duration_value,
+                template: template_name,
+                calendars: calendar_meta,
+                locale: Locale.current_locale,
+                timezone: timezone,
+                calendar_option: options[:calendar],
+                from_option: options[:from],
+                in_option: options[:in],
+                free_before: slot_cfg["free_before"],
+                free_after: slot_cfg["free_after"],
+                empty_message: Locale.t("slots.no_available")
+              )
           else
             SlotFormatter.format_text(
               slots_by_day: slots_by_day,
@@ -465,8 +473,9 @@ module Cli
             )
           end
 
-        FileCache.write(cache_key, strip_cache_marker_from_output(output, format))
-        status = "MISS"
+          FileCache.write(cache_key, strip_cache_marker_from_output(output, format))
+          status = "MISS"
+        end
       end
 
       print annotate_cli_output(output, status, cache_key, format)
@@ -542,6 +551,37 @@ module Cli
       lines[(blank_idx + 1)..].join("\n").strip
     end
 
+    def resolve_login_mode
+      requested = options[:client].to_s.strip.downcase
+      unless requested.empty?
+        unless [ Auth::CLIENT_FLYCAL, Auth::CLIENT_JSON ].include?(requested)
+          puts Locale.t("login.unknown_client", client: options[:client])
+          exit 1
+        end
+        return requested
+      end
+
+      return Auth::CLIENT_FLYCAL unless $stdin.tty?
+
+      begin
+        prompt = TTY::Prompt.new
+        choices = {
+          Locale.t("login.options.flycal") => Auth::CLIENT_FLYCAL,
+          Locale.t("login.options.json") => Auth::CLIENT_JSON
+        }
+        default_label =
+          if Config.auth_client == Auth::CLIENT_JSON
+            Locale.t("login.options.json")
+          else
+            Locale.t("login.options.flycal")
+          end
+        prompt.select(Locale.t("login.prompt"), choices, default: default_label, per_page: 5)
+      rescue Interrupt
+        puts "\n#{Locale.t('login.cancelled')}"
+        exit 0
+      end
+    end
+
     def with_config_interrupt_handling
       yield
     rescue Interrupt
@@ -682,8 +722,6 @@ module Cli
     end
 
     def parse_slots_from(value)
-      return Time.now if value.to_s.strip.downcase == "now"
-
       DateTimeParser.parse(value)
     end
 

data/lib/flycal/cli/auth.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require "webrick"
 require "googleauth"
 require "googleauth/stores/file_token_store"
 require "fileutils"
+require "rbconfig"
 
 module Flycal
 module Cli
@@ -11,23 +11,19 @@ module Cli
     SCOPE = "https://www.googleapis.com/auth/calendar.readonly"
     REDIRECT_PORT = 9292
     REDIRECT_URI = "http://127.0.0.1:#{REDIRECT_PORT}/oauth2callback"
+    CLIENT_FLYCAL = "flycal"
+    CLIENT_JSON = "json"
+    USER_ID = "flycal_user"
+    OAUTH_CLIENT_FILE = File.expand_path("../../../config/oauth_client.json", __dir__)
 
     class << self
       def credentials
-        return nil unless Config.credentials_exist?
-
-        token_store = Google::Auth::Stores::FileTokenStore.new(file: Config.tokens_path)
-        client_id = Google::Auth::ClientId.from_file(Config.credentials_path)
-        authorizer = Google::Auth::UserAuthorizer.new(
-          client_id,
-          SCOPE,
-          token_store,
-          "/oauth2callback"
-        )
-
-        creds = authorizer.get_credentials("flycal_user")
-        return creds if creds
+        mode = resolved_mode
+        return nil unless mode
+        return nil unless File.exist?(Config.tokens_path)
 
+        authorizer_for(mode).get_credentials(USER_ID)
+      rescue Signet::AuthorizationError, Flycal::Error
         nil
       end
 
@@ -41,52 +37,109 @@ module Cli
         false
       end
 
-      def login
-        unless Config.credentials_exist?
-          raise Flycal::Error,
-                "Credentials file not found. Create #{Config.credentials_path} with OAuth credentials from Google Cloud Console.\n" \
-                "Go to: https://console.cloud.google.com/apis/credentials\n" \
-                "Create 'Desktop app' credentials and download the JSON as credentials.json"
+      def login(mode)
+        mode = normalize_mode(mode)
+        if Config.auth_client && Config.auth_client != mode && File.exist?(Config.tokens_path)
+          logout
         end
 
-        token_store = Google::Auth::Stores::FileTokenStore.new(file: Config.tokens_path)
-        client_id = Google::Auth::ClientId.from_file(Config.credentials_path)
-        authorizer = Google::Auth::UserAuthorizer.new(
-          client_id,
-          SCOPE,
-          token_store,
-          "/oauth2callback"
-        )
+        Config.auth_client = mode
+        authorizer = authorizer_for(mode)
 
-        creds = authorizer.get_credentials("flycal_user")
+        creds = authorizer.get_credentials(USER_ID)
         if creds
-          creds.fetch_access_token!
-          return creds
+          begin
+            creds.fetch_access_token!
+            return creds
+          rescue Signet::AuthorizationError
+            token_store = Google::Auth::Stores::FileTokenStore.new(file: Config.tokens_path)
+            token_store.delete(USER_ID)
+            File.delete(Config.tokens_path) if File.exist?(Config.tokens_path)
+            authorizer = authorizer_for(mode)
+          end
         end
 
-        # Start local server to receive the auth code
         code = start_redirect_server(authorizer)
-        raise Flycal::Error, "Authentication cancelled or failed" if code.nil? || code.empty?
+        raise Flycal::Error, Locale.t("login.cancelled") if code.nil? || code.empty?
 
         authorizer.get_and_store_credentials_from_code(
-          user_id: "flycal_user",
+          user_id: USER_ID,
           code: code,
           base_url: "http://127.0.0.1:#{REDIRECT_PORT}"
         )
       end
 
       def logout
-        return true unless File.exist?(Config.tokens_path)
-
-        token_store = Google::Auth::Stores::FileTokenStore.new(file: Config.tokens_path)
-        token_store.delete("flycal_user")
-        File.delete(Config.tokens_path) if File.exist?(Config.tokens_path)
+        if File.exist?(Config.tokens_path)
+          token_store = Google::Auth::Stores::FileTokenStore.new(file: Config.tokens_path)
+          token_store.delete(USER_ID)
+          File.delete(Config.tokens_path) if File.exist?(Config.tokens_path)
+        end
+        Config.auth_client = nil
         true
       end
 
+      def client_id_for(mode)
+        mode = normalize_mode(mode)
+        path = client_id_path(mode)
+        unless File.exist?(path)
+          raise Flycal::Error, missing_client_message(mode, path)
+        end
+
+        Google::Auth::ClientId.from_file(path)
+      end
+
+      def bundled_client_path
+        OAUTH_CLIENT_FILE
+      end
+
       private
 
+      def resolved_mode
+        stored = Config.auth_client
+        return stored if stored
+        return CLIENT_JSON if Config.credentials_exist?
+        return CLIENT_FLYCAL if File.exist?(Config.tokens_path)
+
+        nil
+      end
+
+      def normalize_mode(mode)
+        value = mode.to_s.strip.downcase
+        return value if [ CLIENT_FLYCAL, CLIENT_JSON ].include?(value)
+
+        raise Flycal::Error, Locale.t("login.unknown_client", client: mode)
+      end
+
+      def client_id_path(mode)
+        mode == CLIENT_JSON ? Config.credentials_path : bundled_client_path
+      end
+
+      def authorizer_for(mode)
+        token_store = Google::Auth::Stores::FileTokenStore.new(file: Config.tokens_path)
+        Google::Auth::UserAuthorizer.new(
+          client_id_for(mode),
+          SCOPE,
+          token_store,
+          "/oauth2callback"
+        )
+      end
+
+      def missing_client_message(mode, path)
+        if mode == CLIENT_JSON
+          Locale.t(
+            "login.json_missing",
+            path: path,
+            redirect: REDIRECT_URI
+          )
+        else
+          Locale.t("login.flycal_missing", path: path)
+        end
+      end
+
       def start_redirect_server(authorizer)
+        require "webrick"
+
         auth_code = nil
         state = SecureRandom.hex(16)
         code_verifier = Google::Auth::UserAuthorizer.generate_code_verifier
@@ -110,7 +163,7 @@ module Cli
           elsif params["code"]
             auth_code = params["code"]
             res.status = 200
-            res.body = "<h1>Authentication complete!</h1><p>You can close this window and return to the terminal.</p>"
+            res.body = "<h1>#{Locale.t('login.browser_done_title')}</h1><p>#{Locale.t('login.browser_done_body')}</p>"
           end
 
           Thread.new { server.shutdown }
@@ -121,13 +174,31 @@ module Cli
           state: state
         )
 
-        puts "\nOpen this link in your browser to authenticate:\n\n"
+        puts "\n#{Locale.t('login.open_link')}\n\n"
         puts "  #{url}\n\n"
-        puts "After authentication, you will be redirected back here automatically.\n\n"
+        puts "#{Locale.t('login.waiting')}\n\n"
+        open_browser(url)
 
         server.start
         auth_code
       end
+
+      def open_browser(url)
+        host_os = RbConfig::CONFIG["host_os"].to_s
+        cmd =
+          if host_os.match?(/darwin/)
+            [ "open", url ]
+          elsif host_os.match?(/linux/)
+            [ "xdg-open", url ]
+          elsif host_os.match?(/mswin|mingw|cygwin/)
+            [ "cmd", "/c", "start", "", url ]
+          end
+        return unless cmd
+
+        system(*cmd, out: File::NULL, err: File::NULL)
+      rescue StandardError
+        nil
+      end
     end
   end
 end

data/lib/flycal/cli/config.rb

@@ -53,6 +53,23 @@ module Cli
         File.exist?(CREDENTIALS_FILE)
       end
 
+      def auth_client
+        value = load["auth_client"].to_s.strip.downcase
+        return value if %w[flycal json].include?(value)
+
+        nil
+      end
+
+      def auth_client=(value)
+        data = load
+        if value.to_s.strip.empty?
+          data.delete("auth_client")
+        else
+          data["auth_client"] = value.to_s.strip.downcase
+        end
+        save(data)
+      end
+
       def tokens_path
         TOKENS_FILE
       end
@@ -149,6 +166,11 @@ module Cli
         load["locale"].to_s
       end
 
+      def timezone
+        value = load["timezone"].to_s.strip
+        value.empty? ? Flycal::TimeFormat::DEFAULT_ZONE : value
+      end
+
       def locale=(value)
         data = load
         data["locale"] = value.to_s

data/lib/flycal/client.rb

@@ -73,55 +73,75 @@ module Flycal
     #   calendar_ids (required), duration, from, to, in,
     #   free_before, free_after, hours, days,
     #   template (work|dinner), template_custom ({ days:, hours: } YAML shape),
-    #   locale, calendar (label for meta)
+    #   locale, timezone (IANA, default Europe/Rome or the Google calendar TZ),
+    #   calendar (label for meta)
     # Pass +events:+ to skip Google (tests / mock).
     def slots(params = {}, events: nil)
       previous_locale = Thread.current[:flycal_locale_override]
       p = params.respond_to?(:with_indifferent_access) ? params.with_indifferent_access : params
-      q = resolve_slots_query(p)
-      Locale.override!(q[:locale])
-
-      calendar_meta, loaded_events = load_slot_events(q, events)
-      finder = SlotFinder.new(
-        events: loaded_events,
-        time_min: q[:time_min],
-        time_max: q[:time_max],
-        slot_duration_seconds: q[:slot_duration_seconds],
-        hours: q[:hours],
-        days: q[:days],
-        free_before_seconds: q[:free_before_seconds],
-        free_after_seconds: q[:free_after_seconds]
-      )
 
-      SlotFormatter.payload_hash(
-        slots_by_day: finder.slots_by_day,
-        time_min: q[:time_min],
-        time_max: q[:time_max],
-        duration: q[:duration],
-        template: q[:template],
-        calendars: calendar_meta,
-        locale: q[:locale],
-        calendar_option: q[:calendar],
-        from_option: p[:from],
-        to_option: p[:to],
-        in_option: p[:in],
-        free_before: q[:free_before],
-        free_after: q[:free_after],
-        empty_message: Locale.t("slots.no_available")
+      calendar_list = nil
+      unless events
+        calendar_list = begin
+          list_calendars
+        rescue StandardError
+          nil
+        end
+      end
+
+      timezone = TimeFormat.resolve(
+        explicit: p[:timezone],
+        calendars: calendar_list,
+        calendar_ids: p[:calendar_ids]
       )
+
+      TimeFormat.with_zone(timezone) do
+        q = resolve_slots_query(p.merge(timezone: timezone))
+        Locale.override!(q[:locale])
+
+        calendar_meta, loaded_events = load_slot_events(q, events, calendars: calendar_list)
+        finder = SlotFinder.new(
+          events: loaded_events,
+          time_min: q[:time_min],
+          time_max: q[:time_max],
+          slot_duration_seconds: q[:slot_duration_seconds],
+          hours: q[:hours],
+          days: q[:days],
+          free_before_seconds: q[:free_before_seconds],
+          free_after_seconds: q[:free_after_seconds]
+        )
+
+        SlotFormatter.payload_hash(
+          slots_by_day: finder.slots_by_day,
+          time_min: q[:time_min],
+          time_max: q[:time_max],
+          duration: q[:duration],
+          template: q[:template],
+          calendars: calendar_meta,
+          locale: q[:locale],
+          timezone: timezone,
+          calendar_option: q[:calendar],
+          from_option: p[:from],
+          to_option: p[:to],
+          in_option: p[:in],
+          free_before: q[:free_before],
+          free_after: q[:free_after],
+          empty_message: Locale.t("slots.no_available")
+        )
+      end
     ensure
       Thread.current[:flycal_locale_override] = previous_locale
     end
 
     private
 
-    def load_slot_events(query, events)
+    def load_slot_events(query, events, calendars: nil)
       if events
         meta = query[:calendar_ids].map { |id| { id: id, name: id } }
         return [ meta, Array(events) ]
       end
 
-      calendars = list_calendars
+      calendars ||= list_calendars
       meta = query[:calendar_ids].filter_map do |id|
         cal = calendars.find { |c| c.id == id }
         { id: id, name: cal&.summary || id }

data/lib/flycal/date_time_parser.rb

@@ -69,7 +69,7 @@ module Flycal
         end
       end
 
-      def parse_or_default(str, default: Time.now, end_of_day: false, locale: nil)
+      def parse_or_default(str, default: TimeFormat.now, end_of_day: false, locale: nil)
         return default if str.nil? || str.to_s.strip.empty?
 
         parse(str, end_of_day: end_of_day, locale: locale)
@@ -83,13 +83,13 @@ module Flycal
 
         case normalized
         when "now", "adesso", "ora"
-          return Time.now
+          return TimeFormat.now
         when "today", "oggi"
-          return time_for_date(Date.today, end_of_day: end_of_day)
+          return time_for_date(TimeFormat.today, end_of_day: end_of_day)
         when "tomorrow", "domani"
-          return time_for_date(Date.today + 1, end_of_day: end_of_day)
+          return time_for_date(TimeFormat.today + 1, end_of_day: end_of_day)
         when "yesterday", "ieri"
-          return time_for_date(Date.today - 1, end_of_day: end_of_day)
+          return time_for_date(TimeFormat.today - 1, end_of_day: end_of_day)
         end
 
         weekday = parse_weekday_phrase(normalized)
@@ -117,7 +117,7 @@ module Flycal
         wday = WEEKDAYS[day_token]
         return nil unless wday
 
-        today = Date.today
+        today = TimeFormat.today
 
         if qualifier.nil? || THIS_WORDS.include?(qualifier)
           next_weekday(today, wday, inclusive: true)
@@ -142,9 +142,10 @@ module Flycal
 
       def time_for_date(date, end_of_day:)
         return end_of_day_for(date) if end_of_day
-        return [date.to_time, Time.now].max if date == Date.today
+        midnight = TimeFormat.local(date.year, date.month, date.day)
+        return [ midnight, TimeFormat.now ].max if date == TimeFormat.today
 
-        date.to_time
+        midnight
       end
 
       def formats_for(locale)
@@ -192,13 +193,13 @@ module Flycal
           return time_for_date(date, end_of_day: end_of_day)
         end
 
-        Time.local(year, month, day, hour, min || 0, sec || 0)
+        TimeFormat.local(year, month, day, hour, min || 0, sec || 0)
       rescue ArgumentError
         raise Flycal::Error, "Invalid date: #{year}-#{month}-#{day}"
       end
 
       def end_of_day_for(date)
-        Time.local(date.year, date.month, date.day, 23, 59, 59)
+        TimeFormat.local(date.year, date.month, date.day, 23, 59, 59)
       end
 
       def time_component?(value)

data/lib/flycal/mock/event_generator.rb

@@ -58,8 +58,8 @@ module Flycal
       def random_start_on(day, duration_seconds)
         from_h, from_m = @config.hours_from
         to_h, to_m = @config.hours_to
-        window_start = day.to_time + (from_h * 3600) + (from_m * 60)
-        window_end = day.to_time + (to_h * 3600) + (to_m * 60)
+        window_start = TimeFormat.local(day.year, day.month, day.day, from_h, from_m)
+        window_end = TimeFormat.local(day.year, day.month, day.day, to_h, to_m)
         latest_start = window_end - duration_seconds
         if latest_start < window_start
           raise Flycal::Error, "Mock event duration does not fit in the daily hours window."

data/lib/flycal/mock/slot_scenario.rb

@@ -28,22 +28,25 @@ module Flycal
         mock_opts[:mockSeed] = @seed
 
         @config = Config.from_options(mock_opts)
-        @events = EventGenerator.new(@config).generate
-        @query = SlotQuery.resolve(
-          { calendar_ids: [ @config.calendar_name ] }.merge(symbolize(slots))
-        )
-        finder = SlotFinder.new(
-          events: @events,
-          time_min: @query[:time_min],
-          time_max: @query[:time_max],
-          slot_duration_seconds: @query[:slot_duration_seconds],
-          hours: @query[:hours],
-          days: @query[:days],
-          free_before_seconds: @query[:free_before_seconds],
-          free_after_seconds: @query[:free_after_seconds]
-        )
-        @slots_by_day = finder.slots_by_day
-        @expected_count = @slots_by_day.values.sum(&:size)
+        timezone = TimeFormat.resolve(explicit: slots[:timezone] || slots["timezone"])
+        TimeFormat.with_zone(timezone) do
+          @events = EventGenerator.new(@config).generate
+          @query = SlotQuery.resolve(
+            { calendar_ids: [ @config.calendar_name ], timezone: timezone }.merge(symbolize(slots))
+          )
+          finder = SlotFinder.new(
+            events: @events,
+            time_min: @query[:time_min],
+            time_max: @query[:time_max],
+            slot_duration_seconds: @query[:slot_duration_seconds],
+            hours: @query[:hours],
+            days: @query[:days],
+            free_before_seconds: @query[:free_before_seconds],
+            free_after_seconds: @query[:free_after_seconds]
+          )
+          @slots_by_day = finder.slots_by_day
+          @expected_count = @slots_by_day.values.sum(&:size)
+        end
       end
 
       def to_h

data/lib/flycal/slot_finder.rb

@@ -69,11 +69,11 @@ module Flycal
 
     def day_intervals(date)
       @hours.map do |start_h, start_m, end_h, end_m|
-        start_at = Time.local(date.year, date.month, date.day, start_h, start_m, 0)
-        end_at = Time.local(date.year, date.month, date.day, end_h, end_m, 0)
-        start_at = [@time_min, start_at].max
-        end_at = [@time_max, end_at].min
-        [start_at, end_at]
+        start_at = TimeFormat.local(date.year, date.month, date.day, start_h, start_m, 0)
+        end_at = TimeFormat.local(date.year, date.month, date.day, end_h, end_m, 0)
+        start_at = [ @time_min, start_at ].max
+        end_at = [ @time_max, end_at ].min
+        [ start_at, end_at ]
       end
     end
 

data/lib/flycal/slot_formatter.rb

@@ -77,6 +77,7 @@ module Flycal
         template:,
         calendars:,
         locale: nil,
+        timezone: nil,
         calendar_option: nil,
         from_option: nil,
         to_option: nil,
@@ -121,6 +122,7 @@ module Flycal
             "calendar_ids" => Array(calendars).map { |c| c[:id] },
             "format" => "json",
             "locale" => locale || Locale.current_locale,
+            "timezone" => timezone || TimeFormat.zone_name,
             "from_option" => blank_to_nil(from_option),
             "to_option" => blank_to_nil(to_option),
             "in_option" => blank_to_nil(in_option),
@@ -133,6 +135,7 @@ module Flycal
             "to" => format_iso(time_max),
             "duration" => duration,
             "template" => template,
+            "timezone" => timezone || TimeFormat.zone_name,
             "calendars" => Array(calendars).map { |c| { "id" => c[:id], "name" => c[:name] } },
             "link" => google_calendar_day_url(time_min)
           },

data/lib/flycal/slot_query.rb

@@ -12,6 +12,13 @@ module Flycal
         calendar_ids = Array(p[:calendar_ids]).map(&:to_s).reject(&:empty?)
         raise Error, "calendar_ids are required" if calendar_ids.empty?
 
+        timezone = TimeFormat.resolve(explicit: p[:timezone])
+        TimeFormat.with_zone(timezone) { build(p, calendar_ids, timezone) }
+      end
+
+      private
+
+      def build(p, calendar_ids, timezone)
         duration_value = p[:duration].presence || "45min"
         from_value = p[:from].presence || "now"
         free_before_value = p[:free_before].presence || "0m"
@@ -46,6 +53,7 @@ module Flycal
           free_after: free_after_value,
           template: template[:name],
           locale: locale,
+          timezone: timezone,
           calendar: p[:calendar],
           hours: hours,
           days: days,
@@ -58,8 +66,6 @@ module Flycal
         }
       end
 
-      private
-
       def resolve_time_max(params, time_min, locale)
         if params[:in].present?
           DurationParser.add_to_time(params[:in], time_min)

data/lib/flycal/time_format.rb

@@ -2,25 +2,103 @@
 
 require "time"
 require "date"
+require "active_support/time"
 
 module Flycal
-  # Single clock for every datetime Flycal emits (JSON + text).
+  # Named-zone clock for template hours and every datetime Flycal emits.
   #
-  # Instants are converted to process-local Time so start/end/from/to never mix
-  # offsets (e.g. +02:00 vs +00:00) in the same payload.
+  # Wall-clock windows (work 9:30–13, dinner 19–23, template_custom) are local
+  # to this zone — never the server process TZ (often UTC in production).
+  # JSON start/end/from/to always share that same offset.
   module TimeFormat
+    DEFAULT_ZONE = "Europe/Rome"
+
     module_function
 
-    def iso8601(value)
-      time = unified(value)
-      time&.iso8601
+    def with_zone(name)
+      previous = Thread.current[:flycal_timezone]
+      Thread.current[:flycal_timezone] = coerce_zone(name)
+      yield current_zone
+    ensure
+      Thread.current[:flycal_timezone] = previous
+    end
+
+    def current_zone
+      Thread.current[:flycal_timezone] || coerce_zone(DEFAULT_ZONE)
+    end
+
+    def coerce_zone(name)
+      return name if name.is_a?(ActiveSupport::TimeZone)
+
+      key = name.to_s.strip
+      key = DEFAULT_ZONE if key.empty?
+      ActiveSupport::TimeZone[key] || ActiveSupport::TimeZone[DEFAULT_ZONE]
+    end
+
+    def zone_name(name = nil)
+      zone = if name.nil? || name.to_s.strip.empty?
+               current_zone
+             else
+               coerce_zone(name)
+             end
+      zone.tzinfo&.identifier || zone.name
+    end
+
+    # explicit param → Google calendar timeZone → FLYCAL_TIMEZONE → Europe/Rome.
+    # Never uses ENV["TZ"] (Docker/Kamal set that to UTC).
+    def resolve(explicit: nil, calendars: nil, calendar_ids: nil)
+      key = explicit.to_s.strip
+      return zone_name(key) unless key.empty?
+
+      from_cal = from_calendars(calendars, calendar_ids)
+      return from_cal if from_cal
+
+      env = ENV["FLYCAL_TIMEZONE"].to_s.strip
+      return zone_name(env) unless env.empty?
+
+      DEFAULT_ZONE
+    end
+
+    def from_calendars(calendars, calendar_ids = nil)
+      return nil if calendars.nil? || (calendars.respond_to?(:empty?) && calendars.empty?)
+
+      ids = Array(calendar_ids).map(&:to_s)
+      list = Array(calendars)
+      selected =
+        if ids.empty?
+          list
+        else
+          matched = list.select { |cal| cal.respond_to?(:id) && ids.include?(cal.id.to_s) }
+          matched.empty? ? list : matched
+        end
+      cal = selected.find { |c| c.respond_to?(:primary) && c.primary } || selected.first
+      tz = cal.respond_to?(:time_zone) ? cal.time_zone : nil
+      return nil if tz.to_s.strip.empty?
+
+      zone_name(tz)
+    end
+
+    def now
+      current_zone.now
+    end
+
+    def today
+      current_zone.today
+    end
+
+    def local(year, month, day, hour = 0, min = 0, sec = 0, zone: current_zone)
+      coerce_zone(zone).local(year, month, day, hour, min, sec)
+    end
+
+    def iso8601(value, zone: current_zone)
+      unified(value, zone: zone)&.iso8601
     end
 
-    def unified(value)
+    def unified(value, zone: current_zone)
       time = coerce(value)
       return nil unless time
 
-      Time.at(time.to_f)
+      coerce_zone(zone).at(time.to_f)
     end
 
     def coerce(value)

data/lib/flycal.rb

@@ -4,7 +4,7 @@
 # Under Rails, Zeitwerk autoloads lib/flycal/*.
 # The CLI gem entrypoint (flycal_cli/lib/flycal_cli.rb) eager-requires what it needs.
 module Flycal
-  VERSION = "1.1"
+  VERSION = "1.2"
 
   def self.connect(credentials:)
     Client.new(credentials: credentials)

data/locales/en.json

@@ -28,6 +28,24 @@
       "failed": "Error: could not open config with %{editor}."
     }
   },
+  "login": {
+    "prompt": "How do you want to sign in?",
+    "options": {
+      "flycal": "Google account (Flycal)",
+      "json": "Your own Google Cloud client JSON (~/.flycal/credentials.json)"
+    },
+    "already_connected": "✓ You are already connected to your Google account.",
+    "next_config": "Run 'flycal config' to set the default calendar.",
+    "success": "✓ Authentication completed successfully!",
+    "cancelled": "Login cancelled.",
+    "unknown_client": "Unknown OAuth client %{client}. Use flycal or json.",
+    "open_link": "Open this link in your browser to authenticate:",
+    "waiting": "After authentication, you will be redirected back here automatically.",
+    "browser_done_title": "Authentication complete!",
+    "browser_done_body": "You can close this window and return to the terminal.",
+    "flycal_missing": "Flycal OAuth client is missing from this install (%{path}).",
+    "json_missing": "Credentials file not found at %{path}.\nCreate a Desktop app at https://console.cloud.google.com/apis/credentials\nand save the JSON there.\nAuthorized redirect URI: %{redirect}"
+  },
   "slots": {
     "no_available": "No available slots found.",
     "no_calendar": "No calendar found. Run 'flycal config' to set a default.",

data/locales/it.json

@@ -28,6 +28,24 @@
       "failed": "Errore: impossibile aprire il config con %{editor}."
     }
   },
+  "login": {
+    "prompt": "Come vuoi accedere?",
+    "options": {
+      "flycal": "Account Google (Flycal)",
+      "json": "Il tuo client JSON di Google Cloud (~/.flycal/credentials.json)"
+    },
+    "already_connected": "✓ Sei già connesso al tuo account Google.",
+    "next_config": "Esegui 'flycal config' per impostare il calendario predefinito.",
+    "success": "✓ Autenticazione completata!",
+    "cancelled": "Login annullato.",
+    "unknown_client": "Client OAuth sconosciuto: %{client}. Usa flycal o json.",
+    "open_link": "Apri questo link nel browser per autenticarti:",
+    "waiting": "Dopo l'autenticazione verrai reindirizzato qui automaticamente.",
+    "browser_done_title": "Autenticazione completata!",
+    "browser_done_body": "Puoi chiudere questa finestra e tornare al terminale.",
+    "flycal_missing": "Il client OAuth Flycal manca da questa installazione (%{path}).",
+    "json_missing": "File credenziali non trovato: %{path}.\nCrea un'app Desktop su https://console.cloud.google.com/apis/credentials\ne salva il JSON lì.\nURI di reindirizzamento autorizzato: %{redirect}"
+  },
   "slots": {
     "no_available": "Nessuno slot disponibile.",
     "no_calendar": "Nessun calendario trovato. Esegui 'flycal config' per impostare il predefinito.",

data/mcp/tools.json

@@ -82,7 +82,7 @@
     "path": "~/.flycal/config.yml",
     "credentials_path": "~/.flycal/credentials.json",
     "tokens_path": "~/.flycal/tokens.yml",
-    "credentials_note": "Default/test phase: project-provided API credentials — just run flycal login. Creating your own Google Cloud Console OAuth client is optional and only needed if you want to use your own API project; save that JSON as ~/.flycal/credentials.json then run flycal login.",
+    "credentials_note": "flycal login offers two clients: (1) Flycal Desktop OAuth, no Google Cloud project needed; (2) optional ~/.flycal/credentials.json from your own Desktop app. Non-interactive default is flycal (`flycal login --client flycal`). For your own JSON: `flycal login --client json`.",
     "keys": {
       "calendar_default": {
         "type": ["string", "null"],
@@ -206,7 +206,7 @@
     {
       "name": "flycal_login",
       "title": "Connect Google account",
-      "description": "Start OAuth browser login. Requires ~/.flycal/credentials.json and a browser/TTY. Interactive.",
+      "description": "Start OAuth browser login. Interactive menu: Flycal Desktop client (default) or ~/.flycal/credentials.json. Use --client flycal|json to skip the menu.",
       "interactive": true,
       "requires_auth": false,
       "side_effects": ["writes_tokens"],
@@ -214,6 +214,13 @@
         "argv": ["flycal", "login"]
       },
       "parameters": {
+        "client": {
+          "cli": ["--client"],
+          "type": "string",
+          "enum": ["flycal", "json"],
+          "required": false,
+          "description": "Skip the login menu. flycal = Flycal Desktop OAuth; json = ~/.flycal/credentials.json."
+        },
         "locale": {
           "cli": ["--locale"],
           "type": "string",
@@ -226,6 +233,11 @@
         "type": "object",
         "additionalProperties": false,
         "properties": {
+          "client": {
+            "type": "string",
+            "enum": ["flycal", "json"],
+            "description": "OAuth client (--client flycal|json)."
+          },
           "locale": {
             "type": "string",
             "enum": ["en", "it"],
@@ -595,7 +607,7 @@
     "execution": "Spawn the flycal binary with argv from command.argv, or build argv from argv_template + option_map for each provided parameter. Capture stdout/stderr and exit code. Return stdout as MCP text content.",
     "parameter_building": "For each non-null input property present in option_map, append the mapped flag and value. Quote values with spaces. Always append --locale when locale is set.",
     "interactive_tools": "Do not auto-run tools with interactive=true unless the host provides a TTY. Tell the user to run them in a terminal.",
-    "auth_errors": "If output indicates the user is not connected, suggest flycal login (after credentials.json is in place).",
+    "auth_errors": "If output indicates the user is not connected, suggest flycal login (Flycal Desktop client by default; credentials.json only if they use their own Google Cloud project).",
     "tool_filter": "Prefer exposing flycal_search, flycal_slots, flycal_calendars, and flycal_version to agents."
   }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flycal-cli
 version: !ruby/object:Gem::Version
-  version: '1.1'
+  version: '1.2'
 platform: ruby
 authors:
 - flycal-cli
@@ -134,6 +134,7 @@ files:
 - README.md
 - bin/flycal
 - config/defaults.yml
+- config/oauth_client.json
 - lib/flycal.rb
 - lib/flycal/cache_annotator.rb
 - lib/flycal/cache_key.rb