.gitignore

@@ -1,5 +1,2 @@
 /itctl
 /itd
-/itgui
-/version.txt
-dist/

.goreleaser.yaml

@@ -1,109 +0,0 @@
-before:
-  hooks:
-    - go generate
-    - go mod tidy
-builds:
-  - id: itd
-    env:
-      - CGO_ENABLED=0
-    binary: itd
-    goos:
-      - linux
-    goarch:
-      - 386
-      - amd64
-      - arm
-      - arm64
-  - id: itctl
-    env:
-      - CGO_ENABLED=0
-    main: ./cmd/itctl
-    binary: itctl
-    goos:
-      - linux
-    goarch:
-      - 386
-      - amd64
-      - arm
-      - arm64
-archives:
-  - replacements:
-      386: i386
-      amd64: x86_64
-      arm64: aarch64
-    files:
-      - LICENSE
-      - README.md
-      - itd.toml
-      - itd.service
-nfpms:
-  - id: itd
-    file_name_template: '{{.PackageName}}-{{.Version}}-{{.Os}}-{{.Arch}}'
-    description: "Companion daemon for the InfiniTime firmware on the PineTime smartwatch"
-    replacements:
-      386: i386
-      amd64: x86_64
-      arm64: aarch64
-    homepage: 'https://gitea.arsenm.dev/Arsen6331/itd'
-    maintainer: 'Arsen Musyaelyan <arsen@arsenm.dev>'
-    license: GPLv3
-    formats:
-      - apk
-      - deb
-      - rpm
-    dependencies:
-      - dbus
-      - bluez
-      - pulseaudio-utils
-    contents:
-      - src: itd.toml
-        dst: /etc/itd.toml
-        type: "config|noreplace"
-      - src: itd.service
-        dst: /usr/lib/systemd/user/itd.service
-aurs:
-  - name: itd-bin
-    homepage: 'https://gitea.arsenm.dev/Arsen6331/itd'
-    description: "Companion daemon for the InfiniTime firmware on the PineTime smartwatch"
-    maintainers:
-      - 'Arsen Musyaelyan <arsen@arsenm.dev>'
-    license: GPLv3
-    private_key: '{{ .Env.AUR_KEY }}'
-    git_url: 'ssh://aur@aur.archlinux.org/itd-bin.git'
-    provides:
-      - itd
-      - itctl
-    conflicts:
-      - itd
-      - itctl
-    depends:
-      - dbus
-      - bluez
-      - libpulse
-    package: |-
-      # binaries
-      install -Dm755 "./itd" "${pkgdir}/usr/bin/itd"
-      install -Dm755 "./itctl" "${pkgdir}/usr/bin/itctl"
-
-      # service
-      install -Dm644 "./itd.service" ${pkgdir}/usr/lib/systemd/user/itd.service
-
-      # config
-      install -Dm644 "./itd.toml" ${pkgdir}/etc/itd.toml
-      
-      # license
-      install -Dm644 "./LICENSE" "${pkgdir}/usr/share/licenses/itd/LICENSE"
-release:
-  gitea:
-    owner: Arsen6331
-    name: itd
-gitea_urls:
-  api: 'https://gitea.arsenm.dev/api/v1/'
-  download: 'https://gitea.arsenm.dev'
-  skip_tls_verify: false
-checksum:
-  name_template: 'checksums.txt'
-snapshot:
-  name_template: "{{ incpatch .Version }}-next"
-changelog:
-  sort: asc

.woodpecker.yml

@@ -1,8 +0,0 @@
-pipeline:
-  release:
-    image: goreleaser/goreleaser
-    commands:
-      - goreleaser release
-    secrets: [ gitea_token, aur_key ]
-    when:
-      event: tag

Makefile

@@ -3,14 +3,9 @@ BIN_PREFIX = $(DESTDIR)$(PREFIX)/bin
 SERVICE_PREFIX = $(DESTDIR)$(PREFIX)/lib/systemd/user
 CFG_PREFIX = $(DESTDIR)/etc
 
-all: version.txt
-	go build
-	go build ./cmd/itctl
-
-clean:
-	rm -f itctl
-	rm -f itd
-	rm -f version.txt
+all:
+	go build $(GOFLAGS)
+	go build ./cmd/itctl $(GOFLAGS)
 
 install:
 	install -Dm755 ./itd $(BIN_PREFIX)/itd
@@ -18,13 +13,8 @@ install:
 	install -Dm644 ./itd.service $(SERVICE_PREFIX)/itd.service
 	install -Dm644 ./itd.toml $(CFG_PREFIX)/itd.toml
 
-uninstall:
-	rm $(BIN_PREFIX)/itd
-	rm $(BIN_PREFIX)/itctl
-	rm $(SERVICE_PREFIX)/itd.service
-	rm $(CFG_PREFIX)/itd.toml
+clean:
+	rm -f itctl
+	rm -f itd
 
-version.txt:
-	printf "r%s.%s" "$(shell git rev-list --count HEAD)" "$(shell git rev-parse --short HEAD)" > version.txt
-
-.PHONY: all clean install uninstall
+.PHONY: all install clean

README.md

@@ -3,55 +3,16 @@
 
 `itd` is a daemon that uses my infinitime [library](https://go.arsenm.dev/infinitime) to interact with the [PineTime](https://www.pine64.org/pinetime/) running [InfiniTime](https://infinitime.io).
 
-[![status-badge](https://ci.arsenm.dev/api/badges/Arsen6331/itd/status.svg)](https://ci.arsenm.dev/Arsen6331/itd)
-[![itd-git AUR package](https://img.shields.io/aur/version/itd-git?label=itd-git&logo=archlinux)](https://aur.archlinux.org/packages/itd-git/)
-[![itd-bin AUR package](https://img.shields.io/aur/version/itd-bin?label=itd-bin&logo=archlinux)](https://aur.archlinux.org/packages/itd-bin/)
-
 ---
 
 ### Features
 
 - Notification relay
-- Notification transliteration
-- Call Notifications (ModemManager)
 - Music control
-- Get info from watch (HRM, Battery level, Firmware version, Motion)
+- Get info from watch (HRM, Battery level, Firmware version)
 - Set current time
 - Control socket
 - Firmware upgrades
-- Weather
-- BLE Filesystem
-- Navigation (PureMaps)
-
----
-
-### Installation
-
-Since ITD 0.0.7, packages are built and uploaded whenever a new release is created.
-
-#### Arch Linux
-
-Use the `itd-bin` or `itd-git` AUR packages.
-
-#### Debian/Ubuntu
-
-- Go to the [latest release](https://gitea.arsenm.dev/Arsen6331/itd/releases/latest) and download the `.deb` package for your CPU architecture. You can find your architecture by running `uname -m` in the terminal.
-- Run `sudo apt install <package>`, replacing `<package>` with the path to the downloaded file. Note: relative paths must begin with `./`.
-- Example: `sudo apt install ~/Downloads/itd-0.0.7-linux-aarch64.deb`
-
-#### Fedora
-
-- Go to the [latest release](https://gitea.arsenm.dev/Arsen6331/itd/releases/latest) and download the `.rpm` package for your CPU architecture. You can find your architecture by running `uname -m` in the terminal.
-- Run `sudo dnf install <package>`, replacing `<package>` with the path to the downloaded file.
-- Example: `sudo dnf install ~/Downloads/itd-0.0.7-linux-aarch64.rpm`
-
-#### Alpine (and postmarketOS)
-
-- Go to the [latest release](https://gitea.arsenm.dev/Arsen6331/itd/releases/latest) and download the `.apk` package for your CPU architecture. You can find your architecture by running `uname -m` in the terminal.
-- Run `sudo apk add --allow-untrusted <package>`, replacing `<package>` with the path to the downloaded file.
-- Example: `sudo apk add --allow-untrusted ~/Downloads/itd-0.0.7-linux-aarch64.apk`
-
-Note: `--allow-untrusted` is required because ITD isn't part of a repository, and therefore is not signed.
 
 ---
 
@@ -59,50 +20,15 @@ Note: `--allow-untrusted` is required because ITD isn't part of a repository, an
 
 This daemon creates a UNIX socket at `/tmp/itd/socket`. It allows you to directly control the daemon and, by extension, the connected watch.
 
-The socket uses my [lrpc](https://gitea.arsenm.dev/Arsen6331/lrpc) library for requests. This library accepts requests in msgpack, with the following format:
+The socket accepts JSON requests. For example, sending a notification looks like this:
 
 ```json
-{"Receiver": "ITD", "Method": "Notify", "Arg": {"title": "title1", "body": "body1"}, "ID": "some-id-here"}
+{"type": "notify", "data": {"title": "title1", "body": "body1"}}
 ```
 
-It will return a msgpack response, the format of which can be found [here](https://gitea.arsenm.dev/Arsen6331/lrpc/src/branch/master/internal/types/types.go#L30). The response will have the same ID as was sent in the request in order to allow the client to keep track of which request the response belongs to.
+It will return a JSON response. A response can have 3 fields: `error`, `msg`, and `value`. Error is a boolean that signals whether an error was returned. If error is true, the msg field will contain the error. Value can contain any data and depends on what the request was.
 
----
-
-### Transliteration
-
-Since the PineTime does not have enough space to store all unicode glyphs, it only stores the ASCII space and Cyrillic. Therefore, this daemon can transliterate unsupported characters into supported ones. Since some languages have different transliterations, the transliterators to be used must be specified in the config. Here are the available transliterators:
-
-- eASCII
-- Scandinavian
-- German
-- Hebrew
-- Greek
-- Russian
-- Ukranian
-- Arabic
-- Farsi
-- Polish
-- Lithuanian
-- Estonian
-- Icelandic
-- Czech
-- French
-- Armenian
-- Korean
-- Chinese
-- Romanian
-- Emoji
-
-Place the desired map names in an array as `notifs.translit.use`. They will be evaluated in order. You can also put custom transliterations in `notifs.translit.custom`. These take priority over any other maps. The `notifs.translit` config section should look like this:
-
-```toml
-[notifs.translit]
-    use = ["eASCII", "Russian", "Emoji"]
-    custom = [
-        "test", "replaced"
-    ]
-```
+The various request types and their data requirements can be seen in `internal/types`. I can make separate docs for it if I get enough requests.
 
 ---
 
@@ -112,74 +38,29 @@ This daemon comes with a binary called `itctl` which uses the socket to control
 
 This is the `itctl` usage screen:
 ```
-NAME:
-   itctl - A new cli application
+Control the itd daemon for InfiniTime smartwatches
 
-USAGE:
-   itctl [global options] command [command options] [arguments...]
+Usage:
+  itctl [command]
 
-COMMANDS:
-   help            Display help screen for a command
-   resources, res  Handle InfiniTime resource loading
-   filesystem, fs  Perform filesystem operations on the PineTime
-   firmware, fw    Manage InfiniTime firmware
+Available Commands:
+  completion  generate the autocompletion script for the specified shell
+  firmware    Manage InfiniTime firmware
   get         Get information from InfiniTime
+  help        Help about any command
   notify      Send notification to InfiniTime
   set         Set information on InfiniTime
-   update, upd     Update information on InfiniTime
-   watch           Watch a value for changes
 
-GLOBAL OPTIONS:
-   --socket-path value, -s value  Path to itd socket (default: "/tmp/itd/socket")
+Flags:
+  -h, --help   help for itctl
+
+Use "itctl [command] --help" for more information about a command.
 ```
-
----
-
-### `itgui`
-
-In `cmd/itgui`, there is a gui frontend to the socket of `itd`. It uses the [Fyne library](https://fyne.io/) for Go.
-
-#### Compilation
-
-Before compiling, certain prerequisites must be installed. These are listed on the following page: https://developer.fyne.io/started/#prerequisites
-
-It can be compiled by running:
-
-```shell
-go build ./cmd/itgui
-```
-
-#### Cross-compilation
-
-Due to the use of OpenGL, cross-compilation of `itgui` isn't as simple as that of `itd` and `itctl`. The following guide from the Fyne website should work for `itgui`: https://developer.fyne.io/started/cross-compiling.
-
-#### Screenshots
-
-![Info tab](cmd/itgui/screenshots/info.png)
-
-![Motion tab](cmd/itgui/screenshots/motion.png)
-
-![Notify tab](cmd/itgui/screenshots/notify.png)
-
-![FS tab](cmd/itgui/screenshots/fs.png)
-
-![FS mkdir](cmd/itgui/screenshots/mkdir.png)
-
-![FS resource upload](cmd/itgui/screenshots/resources.png)
-
-![Time tab](cmd/itgui/screenshots/time.png)
-
-![Firmware tab](cmd/itgui/screenshots/firmware.png)
-
-![Upgrade in progress](cmd/itgui/screenshots/progress.png)
-
-![Metrics tab](cmd/itgui/screenshots/metrics.png)
-
 ---
 
 ### Installation
 
-To install, install the go compiler and make. Usually, go is provided by a package either named `go` or `golang`, and make is usually provided by `make`. The go compiler must be version 1.17 or newer for various new `reflect` features.
+To install, install the go compiler and make. Usually, go is provided by a package either named `go` or `golang`, and make is usually provided by `make`. The go compiler must be version 1.16 or newer for the `io/fs` module.
 
 To install, run
 ```shell
@@ -211,7 +92,7 @@ To cross compile, simply set the go environment variables. For example, for Pine
 make GOOS=linux GOARCH=arm64
 ```
 
-This will compile `itd` and `itctl` for Linux aarch64 which is what runs on the PinePhone. This daemon only runs on Linux due to the library's dependencies (`dbus`, and `bluez` specifically).
+This will compile `itd` and `itctl` for Linux aarch64 which is what runs on the PinePhone. This daemon only runs on Linux due to the library's dependencies (`dbus`, `bluez`, and `playerctl` specifically).
 
 ---
 
@@ -220,11 +101,3 @@ This will compile `itd` and `itctl` for Linux aarch64 which is what runs on the
 This daemon places a config file at `/etc/itd.toml`. This is the global config. `itd` will also look for a config at `~/.config/itd.toml`.
 
 Most of the time, the daemon does not need to be restarted for config changes to take effect.
-
----
-
-### Attribution
-
-Location data from OpenStreetMap Nominatim, &copy; [OpenStreetMap](https://www.openstreetmap.org/copyright) contributors
-
-Weather data from the [Norwegian Meteorological Institute](https://www.met.no/en)

api/api.go

@@ -1,37 +0,0 @@
-package api
-
-import (
-	"io"
-	"net"
-
-	"go.arsenm.dev/lrpc/client"
-	"go.arsenm.dev/lrpc/codec"
-)
-
-const DefaultAddr = "/tmp/itd/socket"
-
-type Client struct {
-	client *client.Client
-}
-
-func New(sockPath string) (*Client, error) {
-	conn, err := net.Dial("unix", sockPath)
-	if err != nil {
-		return nil, err
-	}
-
-	out := &Client{
-		client: client.New(conn, codec.Default),
-	}
-	return out, nil
-}
-
-func NewFromConn(conn io.ReadWriteCloser) *Client {
-	return &Client{
-		client: client.New(conn, codec.Default),
-	}
-}
-
-func (c *Client) Close() error {
-	return c.client.Close()
-}

api/firmware.go

@@ -1,26 +0,0 @@
-package api
-
-import (
-	"context"
-
-	"go.arsenm.dev/infinitime"
-)
-
-func (c *Client) FirmwareUpgrade(ctx context.Context, upgType UpgradeType, files ...string) (chan infinitime.DFUProgress, error) {
-	progressCh := make(chan infinitime.DFUProgress, 5)
-	err := c.client.Call(
-		ctx,
-		"ITD",
-		"FirmwareUpgrade",
-		FwUpgradeData{
-			Type:  upgType,
-			Files: files,
-		},
-		progressCh,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return progressCh, nil
-}

api/fs.go

@@ -1,96 +0,0 @@
-package api
-
-import "context"
-
-func (c *Client) RemoveAll(ctx context.Context, paths ...string) error {
-	return c.client.Call(
-		ctx,
-		"FS",
-		"RemoveAll",
-		paths,
-		nil,
-	)
-}
-
-func (c *Client) Remove(ctx context.Context, paths ...string) error {
-	return c.client.Call(
-		ctx,
-		"FS",
-		"Remove",
-		paths,
-		nil,
-	)
-}
-
-func (c *Client) Rename(ctx context.Context, old, new string) error {
-	return c.client.Call(
-		ctx,
-		"FS",
-		"Rename",
-		[2]string{old, new},
-		nil,
-	)
-}
-
-func (c *Client) MkdirAll(ctx context.Context, paths ...string) error {
-	return c.client.Call(
-		ctx,
-		"FS",
-		"MkdirAll",
-		paths,
-		nil,
-	)
-}
-
-func (c *Client) Mkdir(ctx context.Context, paths ...string) error {
-	return c.client.Call(
-		ctx,
-		"FS",
-		"Mkdir",
-		paths,
-		nil,
-	)
-}
-
-func (c *Client) ReadDir(ctx context.Context, dir string) (out []FileInfo, err error) {
-	err = c.client.Call(
-		ctx,
-		"FS",
-		"ReadDir",
-		dir,
-		&out,
-	)
-	return
-}
-
-func (c *Client) Upload(ctx context.Context, dst, src string) (chan FSTransferProgress, error) {
-	progressCh := make(chan FSTransferProgress, 5)
-	err := c.client.Call(
-		ctx,
-		"FS",
-		"Upload",
-		[2]string{dst, src},
-		progressCh,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return progressCh, nil
-}
-
-func (c *Client) Download(ctx context.Context, dst, src string) (chan FSTransferProgress, error) {
-	progressCh := make(chan FSTransferProgress, 5)
-	err := c.client.Call(
-		ctx,
-		"FS",
-		"Download",
-		[2]string{dst, src},
-		progressCh,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return progressCh, nil
-}

api/get.go

@@ -1,73 +0,0 @@
-package api
-
-import (
-	"context"
-
-	"go.arsenm.dev/infinitime"
-)
-
-func (c *Client) HeartRate(ctx context.Context) (out uint8, err error) {
-	err = c.client.Call(
-		ctx,
-		"ITD",
-		"HeartRate",
-		nil,
-		&out,
-	)
-	return
-}
-
-func (c *Client) BatteryLevel(ctx context.Context) (out uint8, err error) {
-	err = c.client.Call(
-		ctx,
-		"ITD",
-		"BatteryLevel",
-		nil,
-		&out,
-	)
-	return
-}
-
-func (c *Client) Motion(ctx context.Context) (out infinitime.MotionValues, err error) {
-	err = c.client.Call(
-		ctx,
-		"ITD",
-		"Motion",
-		nil,
-		&out,
-	)
-	return
-}
-
-func (c *Client) StepCount(ctx context.Context) (out uint32, err error) {
-	err = c.client.Call(
-		ctx,
-		"ITD",
-		"StepCount",
-		nil,
-		&out,
-	)
-	return
-}
-
-func (c *Client) Version(ctx context.Context) (out string, err error) {
-	err = c.client.Call(
-		ctx,
-		"ITD",
-		"Version",
-		nil,
-		&out,
-	)
-	return
-}
-
-func (c *Client) Address(ctx context.Context) (out string, err error) {
-	err = c.client.Call(
-		ctx,
-		"ITD",
-		"Address",
-		nil,
-		&out,
-	)
-	return
-}

api/notify.go

@@ -1,16 +0,0 @@
-package api
-
-import "context"
-
-func (c *Client) Notify(ctx context.Context, title, body string) error {
-	return c.client.Call(
-		ctx,
-		"ITD",
-		"Notify",
-		NotifyData{
-			Title: title,
-			Body:  body,
-		},
-		nil,
-	)
-}

api/resources.go

@@ -1,26 +0,0 @@
-package api
-
-import (
-	"context"
-
-	"go.arsenm.dev/infinitime"
-)
-
-// LoadResources loads resources onto the watch from the given
-// file path to the resources zip
-func (c *Client) LoadResources(ctx context.Context, path string) (<-chan infinitime.ResourceLoadProgress, error) {
-	progCh := make(chan infinitime.ResourceLoadProgress)
-
-	err := c.client.Call(
-		ctx,
-		"FS",
-		"LoadResources",
-		path,
-		progCh,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return progCh, nil
-}

api/set.go

@@ -1,16 +0,0 @@
-package api
-
-import (
-	"context"
-	"time"
-)
-
-func (c *Client) SetTime(ctx context.Context, t time.Time) error {
-	return c.client.Call(
-		ctx,
-		"ITD",
-		"SetTime",
-		t,
-		nil,
-	)
-}

api/types.go

@@ -1,96 +0,0 @@
-package api
-
-import (
-	"fmt"
-	"strconv"
-)
-
-type UpgradeType uint8
-
-const (
-	UpgradeTypeArchive UpgradeType = iota
-	UpgradeTypeFiles
-)
-
-type FSData struct {
-	Files []string
-	Data  string
-}
-
-type FwUpgradeData struct {
-	Type  UpgradeType
-	Files []string
-}
-
-type NotifyData struct {
-	Title string
-	Body  string
-}
-
-type FSTransferProgress struct {
-	Total uint32
-	Sent  uint32
-}
-
-type FileInfo struct {
-	Name  string
-	Size  int64
-	IsDir bool
-}
-
-func (fi FileInfo) String() string {
-	var isDirChar rune
-	if fi.IsDir {
-		isDirChar = 'd'
-	} else {
-		isDirChar = '-'
-	}
-
-	// Get human-readable value for file size
-	val, unit := bytesHuman(fi.Size)
-	prec := 0
-	// If value is less than 10, set precision to 1
-	if val < 10 {
-		prec = 1
-	}
-	// Convert float to string
-	valStr := strconv.FormatFloat(val, 'f', prec, 64)
-
-	// Return string formatted like so:
-	// -  10 kB file
-	// or:
-	// d   0 B  .
-	return fmt.Sprintf(
-		"%c %3s %-2s %s",
-		isDirChar,
-		valStr,
-		unit,
-		fi.Name,
-	)
-}
-
-// bytesHuman returns a human-readable string for
-// the amount of bytes inputted.
-func bytesHuman(b int64) (float64, string) {
-	const unit = 1000
-	// Set possible units prefixes (PineTime flash is 4MB)
-	units := [2]rune{'k', 'M'}
-	// If amount of bytes is less than smallest unit
-	if b < unit {
-		// Return unchanged with unit "B"
-		return float64(b), "B"
-	}
-
-	div, exp := int64(unit), 0
-	// Get decimal values and unit prefix index
-	for n := b / unit; n >= unit; n /= unit {
-		div *= unit
-		exp++
-	}
-
-	// Create string for full unit
-	unitStr := string([]rune{units[exp], 'B'})
-
-	// Return decimal with unit string
-	return float64(b) / float64(div), unitStr
-}

api/update.go

@@ -1,13 +0,0 @@
-package api
-
-import "context"
-
-func (c *Client) WeatherUpdate(ctx context.Context) error {
-	return c.client.Call(
-		ctx,
-		"ITD",
-		"WeatherUpdate",
-		nil,
-		nil,
-	)
-}

api/watch.go

@@ -1,71 +0,0 @@
-package api
-
-import (
-	"context"
-
-	"go.arsenm.dev/infinitime"
-)
-
-func (c *Client) WatchHeartRate(ctx context.Context) (<-chan uint8, error) {
-	outCh := make(chan uint8, 2)
-	err := c.client.Call(
-		ctx,
-		"ITD",
-		"WatchHeartRate",
-		nil,
-		outCh,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return outCh, nil
-}
-
-func (c *Client) WatchBatteryLevel(ctx context.Context) (<-chan uint8, error) {
-	outCh := make(chan uint8, 2)
-	err := c.client.Call(
-		ctx,
-		"ITD",
-		"WatchBatteryLevel",
-		nil,
-		outCh,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return outCh, nil
-}
-
-func (c *Client) WatchStepCount(ctx context.Context) (<-chan uint32, error) {
-	outCh := make(chan uint32, 2)
-	err := c.client.Call(
-		ctx,
-		"ITD",
-		"WatchStepCount",
-		nil,
-		outCh,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return outCh, nil
-}
-
-func (c *Client) WatchMotion(ctx context.Context) (<-chan infinitime.MotionValues, error) {
-	outCh := make(chan infinitime.MotionValues, 2)
-	err := c.client.Call(
-		ctx,
-		"ITD",
-		"WatchMotion",
-		nil,
-		outCh,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	return outCh, nil
-}

calls.go

@@ -1,149 +0,0 @@
-package main
-
-import (
-	"context"
-	"sync"
-
-	"github.com/godbus/dbus/v5"
-	"github.com/rs/zerolog/log"
-	"go.arsenm.dev/infinitime"
-)
-
-func initCallNotifs(ctx context.Context, dev *infinitime.Device) error {
-	// Connect to system bus. This connection is for method calls.
-	conn, err := newSystemBusConn(ctx)
-	if err != nil {
-		return err
-	}
-
-	// Check if modem manager interface exists
-	exists, err := modemManagerExists(ctx, conn)
-	if err != nil {
-		return err
-	}
-
-	// If it does not exist, stop function
-	if !exists {
-		conn.Close()
-		return nil
-	}
-
-	// Connect to system bus. This connection is for monitoring.
-	monitorConn, err := newSystemBusConn(ctx)
-	if err != nil {
-		return err
-	}
-
-	// Add match for new calls to monitor connection
-	err = monitorConn.AddMatchSignal(
-		dbus.WithMatchSender("org.freedesktop.ModemManager1"),
-		dbus.WithMatchInterface("org.freedesktop.ModemManager1.Modem.Voice"),
-		dbus.WithMatchMember("CallAdded"),
-	)
-	if err != nil {
-		return err
-	}
-
-	// Create channel to receive calls
-	callCh := make(chan *dbus.Message, 5)
-	// Notify channel upon received message
-	monitorConn.Eavesdrop(callCh)
-
-	var respHandlerOnce sync.Once
-	var callObj dbus.BusObject
-
-	go func() {
-		// For every message received
-		for event := range callCh {
-			// Get path to call object
-			callPath := event.Body[0].(dbus.ObjectPath)
-			// Get call object
-			callObj = conn.Object("org.freedesktop.ModemManager1", callPath)
-
-			// Get phone number from call object using method call connection
-			phoneNum, err := getPhoneNum(conn, callObj)
-			if err != nil {
-				log.Error().Err(err).Msg("Error getting phone number")
-				continue
-			}
-
-			// Send call notification to InfiniTime
-			resCh, err := dev.NotifyCall(phoneNum)
-			if err != nil {
-				continue
-			}
-
-			go respHandlerOnce.Do(func() {
-				// Wait for PineTime response
-				for res := range resCh {
-					switch res {
-					case infinitime.CallStatusAccepted:
-						// Attempt to accept call
-						err = acceptCall(ctx, conn, callObj)
-						if err != nil {
-							log.Warn().Err(err).Msg("Error accepting call")
-						}
-					case infinitime.CallStatusDeclined:
-						// Attempt to decline call
-						err = declineCall(ctx, conn, callObj)
-						if err != nil {
-							log.Warn().Err(err).Msg("Error declining call")
-						}
-					case infinitime.CallStatusMuted:
-						// Warn about unimplemented muting
-						log.Warn().Msg("Muting calls is not implemented")
-					}
-				}
-			})
-		}
-	}()
-
-	log.Info().Msg("Relaying calls to InfiniTime")
-	return nil
-}
-
-func modemManagerExists(ctx context.Context, conn *dbus.Conn) (bool, error) {
-	var names []string
-	err := conn.BusObject().CallWithContext(
-		ctx, "org.freedesktop.DBus.ListNames", 0,
-	).Store(&names)
-	if err != nil {
-		return false, err
-	}
-	return strSlcContains(names, "org.freedesktop.ModemManager1"), nil
-}
-
-// getPhoneNum gets a phone number from a call object using a DBus connection
-func getPhoneNum(conn *dbus.Conn, callObj dbus.BusObject) (string, error) {
-	var out string
-	// Get number property on DBus object and store return value in out
-	err := callObj.StoreProperty("org.freedesktop.ModemManager1.Call.Number", &out)
-	if err != nil {
-		return "", err
-	}
-	return out, nil
-}
-
-// getPhoneNum accepts a call using a DBus connection
-func acceptCall(ctx context.Context, conn *dbus.Conn, callObj dbus.BusObject) error {
-	// Call Accept() method on DBus object
-	call := callObj.CallWithContext(
-		ctx, "org.freedesktop.ModemManager1.Call.Accept", 0,
-	)
-	if call.Err != nil {
-		return call.Err
-	}
-	return nil
-}
-
-// getPhoneNum declines a call using a DBus connection
-func declineCall(ctx context.Context, conn *dbus.Conn, callObj dbus.BusObject) error {
-	// Call Hangup() method on DBus object
-	call := callObj.CallWithContext(
-		ctx, "org.freedesktop.ModemManager1.Call.Hangup", 0,
-	)
-	if call.Err != nil {
-		return call.Err
-	}
-	return nil
-}

cmd/itctl/cmd/address.go

@@ -0,0 +1,87 @@
+/*
+ *	itd uses bluetooth low energy to communicate with InfiniTime devices
+ *	Copyright (C) 2021 Arsen Musayelyan
+ *
+ *	This program is free software: you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation, either version 3 of the License, or
+ *	(at your option) any later version.
+ *
+ *	This program is distributed in the hope that it will be useful,
+ *	but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *	GNU General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License
+ *	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package cmd
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"net"
+
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+	"go.arsenm.dev/itd/internal/types"
+)
+
+// addressCmd represents the address command
+var addressCmd = &cobra.Command{
+	Use:     "address",
+	Aliases: []string{"addr"},
+	Short:   "Get InfiniTime's bluetooth address",
+	Run: func(cmd *cobra.Command, args []string) {
+		// Connect to itd UNIX socket
+		conn, err := net.Dial("unix", SockPath)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error dialing socket. Is itd running?")
+		}
+		defer conn.Close()
+
+		// Encode request into connection
+		err = json.NewEncoder(conn).Encode(types.Request{
+			Type: ReqTypeBtAddress,
+		})
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error making request")
+		}
+
+		// Read one line from connection
+		line, _, err := bufio.NewReader(conn).ReadLine()
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error reading line from connection")
+		}
+
+		var res types.Response
+		// Decode line into response
+		err = json.Unmarshal(line, &res)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error decoding JSON data")
+		}
+
+		if res.Error {
+			log.Fatal().Msg(res.Message)
+		}
+
+		// Print returned value
+		fmt.Println(res.Value)
+	},
+}
+
+func init() {
+	getCmd.AddCommand(addressCmd)
+
+	// Here you will define your flags and configuration settings.
+
+	// Cobra supports Persistent Flags which will work for this command
+	// and all subcommands, e.g.:
+	// addressCmd.PersistentFlags().String("foo", "", "A help for foo")
+
+	// Cobra supports local flags which will only run when this command
+	// is called directly, e.g.:
+	// addressCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
+}

cmd/itctl/cmd/battery.go

@@ -0,0 +1,77 @@
+/*
+ *	itd uses bluetooth low energy to communicate with InfiniTime devices
+ *	Copyright (C) 2021 Arsen Musayelyan
+ *
+ *	This program is free software: you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation, either version 3 of the License, or
+ *	(at your option) any later version.
+ *
+ *	This program is distributed in the hope that it will be useful,
+ *	but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *	GNU General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License
+ *	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package cmd
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"net"
+
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+	"go.arsenm.dev/itd/internal/types"
+)
+
+// batteryCmd represents the batt command
+var batteryCmd = &cobra.Command{
+	Use:     "battery",
+	Aliases: []string{"batt"},
+	Short:   "Get battery level from InfiniTime",
+	Run: func(cmd *cobra.Command, args []string) {
+		// Connect to itd UNIX socket
+		conn, err := net.Dial("unix", SockPath)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error dialing socket. Is itd running?")
+		}
+		defer conn.Close()
+
+		// Encode request into connection
+		err = json.NewEncoder(conn).Encode(types.Request{
+			Type: ReqTypeBattLevel,
+		})
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error making request")
+		}
+
+		// Read one line from connection
+		line, _, err := bufio.NewReader(conn).ReadLine()
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error reading line from connection")
+		}
+
+		var res types.Response
+		// Deocde line into response
+		err = json.Unmarshal(line, &res)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error decoding JSON data")
+		}
+
+		if res.Error {
+			log.Fatal().Msg(res.Message)
+		}
+
+		// Print returned percentage
+		fmt.Printf("%d%%\n", int(res.Value.(float64)))
+	},
+}
+
+func init() {
+	getCmd.AddCommand(batteryCmd)
+}

cmd/itctl/cmd/common.go

@@ -0,0 +1,41 @@
+/*
+ *	itd uses bluetooth low energy to communicate with InfiniTime devices
+ *	Copyright (C) 2021 Arsen Musayelyan
+ *
+ *	This program is free software: you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation, either version 3 of the License, or
+ *	(at your option) any later version.
+ *
+ *	This program is distributed in the hope that it will be useful,
+ *	but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *	GNU General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License
+ *	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package cmd
+
+const SockPath = "/tmp/itd/socket"
+
+const (
+	ReqTypeHeartRate = "hrt"
+	ReqTypeBattLevel = "battlvl"
+	ReqTypeFwVersion = "fwver"
+	ReqTypeFwUpgrade = "fwupg"
+	ReqTypeBtAddress = "btaddr"
+	ReqTypeNotify    = "notify"
+	ReqTypeSetTime   = "settime"
+)
+
+const (
+	UpgradeTypeArchive = iota
+	UpgradeTypeFiles
+)
+
+type DFUProgress struct {
+	Received int64 `mapstructure:"recvd"`
+	Total    int64 `mapstructure:"total"`
+}

cmd/itctl/cmd/firmware.go

@@ -0,0 +1,34 @@
+/*
+ *	itd uses bluetooth low energy to communicate with InfiniTime devices
+ *	Copyright (C) 2021 Arsen Musayelyan
+ *
+ *	This program is free software: you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation, either version 3 of the License, or
+ *	(at your option) any later version.
+ *
+ *	This program is distributed in the hope that it will be useful,
+ *	but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *	GNU General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License
+ *	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+)
+
+// firmwareCmd represents the firmware command
+var firmwareCmd = &cobra.Command{
+	Use:     "firmware",
+	Short:   "Manage InfiniTime firmware",
+	Aliases: []string{"fw"},
+}
+
+func init() {
+	rootCmd.AddCommand(firmwareCmd)
+}

cmd/itctl/cmd/get.go

@@ -0,0 +1,33 @@
+/*
+ *	itd uses bluetooth low energy to communicate with InfiniTime devices
+ *	Copyright (C) 2021 Arsen Musayelyan
+ *
+ *	This program is free software: you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation, either version 3 of the License, or
+ *	(at your option) any later version.
+ *
+ *	This program is distributed in the hope that it will be useful,
+ *	but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *	GNU General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License
+ *	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+)
+
+// getCmd represents the get command
+var getCmd = &cobra.Command{
+	Use:   "get",
+	Short: "Get information from InfiniTime",
+}
+
+func init() {
+	rootCmd.AddCommand(getCmd)
+}

cmd/itctl/cmd/heart.go

@@ -0,0 +1,76 @@
+/*
+ *	itd uses bluetooth low energy to communicate with InfiniTime devices
+ *	Copyright (C) 2021 Arsen Musayelyan
+ *
+ *	This program is free software: you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation, either version 3 of the License, or
+ *	(at your option) any later version.
+ *
+ *	This program is distributed in the hope that it will be useful,
+ *	but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *	GNU General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License
+ *	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package cmd
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"net"
+
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+	"go.arsenm.dev/itd/internal/types"
+)
+
+// heartCmd represents the heart command
+var heartCmd = &cobra.Command{
+	Use:   "heart",
+	Short: "Get heart rate from InfiniTime",
+	Run: func(cmd *cobra.Command, args []string) {
+		// Connect to itd UNIX socket
+		conn, err := net.Dial("unix", SockPath)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error dialing socket. Is itd running?")
+		}
+		defer conn.Close()
+
+		// Encode request into connection
+		err = json.NewEncoder(conn).Encode(types.Request{
+			Type: ReqTypeHeartRate,
+		})
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error making request")
+		}
+
+		// Read one line from connection
+		line, _, err := bufio.NewReader(conn).ReadLine()
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error reading line from connection")
+		}
+
+		var res types.Response
+		// Decode line into response
+		err = json.Unmarshal(line, &res)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error decoding JSON data")
+		}
+
+		if res.Error {
+			log.Fatal().Msg(res.Message)
+		}
+
+		// Print returned BPM
+		fmt.Printf("%d BPM\n", int(res.Value.(float64)))
+	},
+}
+
+func init() {
+	getCmd.AddCommand(heartCmd)
+}

cmd/itctl/cmd/notify.go

@@ -0,0 +1,82 @@
+/*
+ *	itd uses bluetooth low energy to communicate with InfiniTime devices
+ *	Copyright (C) 2021 Arsen Musayelyan
+ *
+ *	This program is free software: you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation, either version 3 of the License, or
+ *	(at your option) any later version.
+ *
+ *	This program is distributed in the hope that it will be useful,
+ *	but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *	GNU General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License
+ *	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package cmd
+
+import (
+	"bufio"
+	"encoding/json"
+	"net"
+
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+	"go.arsenm.dev/itd/internal/types"
+)
+
+// notifyCmd represents the notify command
+var notifyCmd = &cobra.Command{
+	Use:   "notify <title> <body>",
+	Short: "Send notification to InfiniTime",
+	Run: func(cmd *cobra.Command, args []string) {
+		// Ensure required arguments
+		if len(args) != 2 {
+			cmd.Usage()
+			log.Fatal().Msg("Command notify requires two arguments")
+		}
+
+		// Connect to itd UNIX socket
+		conn, err := net.Dial("unix", SockPath)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error dialing socket. Is itd running?")
+		}
+		defer conn.Close()
+
+		// Encode request into connection
+		err = json.NewEncoder(conn).Encode(types.Request{
+			Type: ReqTypeNotify,
+			Data: types.ReqDataNotify{
+				Title: args[0],
+				Body:  args[1],
+			},
+		})
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error making request")
+		}
+
+		// Read one line from connection
+		line, _, err := bufio.NewReader(conn).ReadLine()
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error reading line from connection")
+		}
+
+		var res types.Response
+		// Decode line into response
+		err = json.Unmarshal(line, &res)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error decoding JSON data")
+		}
+
+		if res.Error {
+			log.Fatal().Msg(res.Message)
+		}
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(notifyCmd)
+}

cmd/itctl/cmd/root.go

@@ -0,0 +1,64 @@
+/*
+ *	itd uses bluetooth low energy to communicate with InfiniTime devices
+ *	Copyright (C) 2021 Arsen Musayelyan
+ *
+ *	This program is free software: you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation, either version 3 of the License, or
+ *	(at your option) any later version.
+ *
+ *	This program is distributed in the hope that it will be useful,
+ *	but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *	GNU General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License
+ *	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package cmd
+
+import (
+	"github.com/abiosoft/ishell"
+	"github.com/spf13/cobra"
+)
+
+// rootCmd represents the base command when called without any subcommands
+var rootCmd = &cobra.Command{
+	Use:   "itctl",
+	Short: "Control the itd daemon for InfiniTime smartwatches",
+	Run: func(cmd *cobra.Command, args []string) {
+
+		// Create new shell
+		sh := ishell.New()
+		sh.SetPrompt("itctl> ")
+
+		// For every command in cobra
+		for _, subCmd := range cmd.Commands() {
+			// Add top level command to ishell
+			sh.AddCmd(&ishell.Cmd{
+				Name:     subCmd.Name(),
+				Help:     subCmd.Short,
+				Aliases:  subCmd.Aliases,
+				LongHelp: subCmd.Long,
+				Func: func(ctx *ishell.Context) {
+					// Append name and arguments of command
+					args := append([]string{ctx.Cmd.Name}, ctx.Args...)
+					// Set root command arguments
+					cmd.SetArgs(args)
+					// Execute root command with new arguments
+					cmd.Execute()
+				},
+			})
+		}
+
+		// Start shell
+		sh.Run()
+	},
+}
+
+// Execute adds all child commands to the root command and sets flags appropriately.
+// This is called by main.main(). It only needs to happen once to the rootCmd.
+func Execute() {
+	cobra.CheckErr(rootCmd.Execute())
+}

cmd/itctl/cmd/set.go

@@ -0,0 +1,33 @@
+/*
+ *	itd uses bluetooth low energy to communicate with InfiniTime devices
+ *	Copyright (C) 2021 Arsen Musayelyan
+ *
+ *	This program is free software: you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation, either version 3 of the License, or
+ *	(at your option) any later version.
+ *
+ *	This program is distributed in the hope that it will be useful,
+ *	but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *	GNU General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License
+ *	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+)
+
+// setCmd represents the set command
+var setCmd = &cobra.Command{
+	Use:   "set",
+	Short: "Set information on InfiniTime",
+}
+
+func init() {
+	rootCmd.AddCommand(setCmd)
+}

cmd/itctl/cmd/time.go

@@ -0,0 +1,80 @@
+/*
+ *	itd uses bluetooth low energy to communicate with InfiniTime devices
+ *	Copyright (C) 2021 Arsen Musayelyan
+ *
+ *	This program is free software: you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation, either version 3 of the License, or
+ *	(at your option) any later version.
+ *
+ *	This program is distributed in the hope that it will be useful,
+ *	but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *	GNU General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License
+ *	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package cmd
+
+import (
+	"bufio"
+	"encoding/json"
+	"net"
+
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+	"go.arsenm.dev/itd/internal/types"
+)
+
+// timeCmd represents the time command
+var timeCmd = &cobra.Command{
+	Use:   `time <ISO8601|"now">`,
+	Short: "Set InfiniTime's clock to specified time",
+	Run: func(cmd *cobra.Command, args []string) {
+		// Ensure required arguments
+		if len(args) != 1 {
+			cmd.Usage()
+			log.Warn().Msg("Command time requires one argument")
+			return
+		}
+		
+		// Connect to itd UNIX socket
+		conn, err := net.Dial("unix", SockPath)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error dialing socket. Is itd running?")
+		}
+		defer conn.Close()
+
+		// Encode request into connection
+		err = json.NewEncoder(conn).Encode(types.Request{
+			Type: ReqTypeSetTime,
+			Data: args[0],
+		})
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error making request")
+		}
+
+		// Read one line from connetion
+		line, _, err := bufio.NewReader(conn).ReadLine()
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error reading line from connection")
+		}
+
+		var res types.Response
+		// Decode line into response
+		err = json.Unmarshal(line, &res)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error decoding JSON data")
+		}
+
+		if res.Error {
+			log.Fatal().Msg(res.Message)
+		}
+	},
+}
+
+func init() {
+	setCmd.AddCommand(timeCmd)
+}

cmd/itctl/cmd/upgrade.go

@@ -0,0 +1,127 @@
+/*
+ *	itd uses bluetooth low energy to communicate with InfiniTime devices
+ *	Copyright (C) 2021 Arsen Musayelyan
+ *
+ *	This program is free software: you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation, either version 3 of the License, or
+ *	(at your option) any later version.
+ *
+ *	This program is distributed in the hope that it will be useful,
+ *	but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *	GNU General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License
+ *	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package cmd
+
+import (
+	"bufio"
+	"encoding/json"
+	"net"
+
+	"github.com/cheggaaa/pb/v3"
+	"github.com/mitchellh/mapstructure"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"go.arsenm.dev/itd/internal/types"
+)
+
+// upgradeCmd represents the upgrade command
+var upgradeCmd = &cobra.Command{
+	Use:     "upgrade",
+	Short:   "Upgrade InfiniTime firmware using files or archive",
+	Aliases: []string{"upg"},
+	Run: func(cmd *cobra.Command, args []string) {
+		// Connect to itd UNIX socket
+		conn, err := net.Dial("unix", SockPath)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error dialing socket. Is itd running?")
+		}
+		defer conn.Close()
+
+		var data types.ReqDataFwUpgrade
+		// Get relevant data struct
+		if viper.GetString("archive") != "" {
+			// Get archive data struct
+			data = types.ReqDataFwUpgrade{
+				Type:  UpgradeTypeArchive,
+				Files: []string{viper.GetString("archive")},
+			}
+		} else if viper.GetString("initPkt") != "" && viper.GetString("firmware") != "" {
+			// Get files data struct
+			data = types.ReqDataFwUpgrade{
+				Type:  UpgradeTypeFiles,
+				Files: []string{viper.GetString("initPkt"), viper.GetString("firmware")},
+			}
+		} else {
+			cmd.Usage()
+			log.Warn().Msg("Upgrade command requires either archive or init packet and firmware.")
+			return
+		}
+
+		// Encode response into connection
+		err = json.NewEncoder(conn).Encode(types.Request{
+			Type: ReqTypeFwUpgrade,
+			Data: data,
+		})
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error making request")
+		}
+
+		// Create progress bar template
+		barTmpl := `{{counters . }} B {{bar . "|" "-" (cycle .) " " "|"}} {{percent . }} {{rtime . "%s"}}`
+		// Start full bar at 0 total
+		bar := pb.ProgressBarTemplate(barTmpl).Start(0)
+		// Create new scanner of connection
+		scanner := bufio.NewScanner(conn)
+		for scanner.Scan() {
+			var res types.Response
+			// Decode scanned line into response struct
+			err = json.Unmarshal(scanner.Bytes(), &res)
+			if err != nil {
+				log.Fatal().Err(err).Msg("Error decoding JSON response")
+			}
+			if res.Error {
+				log.Fatal().Msg(res.Message)
+			}
+			var event DFUProgress
+			// Decode response data into progress struct
+			err = mapstructure.Decode(res.Value, &event)
+			if err != nil {
+				log.Fatal().Err(err).Msg("Error decoding response data")
+			}
+			// If transfer finished, break
+			if event.Received == event.Total {
+				break
+			}
+			// Set total bytes in progress bar
+			bar.SetTotal(event.Total)
+			// Set amount of bytes received in progress bar
+			bar.SetCurrent(event.Received)
+		}
+		// Finish progress bar
+		bar.Finish()
+		if scanner.Err() != nil {
+			log.Fatal().Err(scanner.Err()).Msg("Error while scanning output")
+		}
+	},
+}
+
+func init() {
+	firmwareCmd.AddCommand(upgradeCmd)
+
+	// Register flags
+	upgradeCmd.Flags().StringP("archive", "a", "", "Path to firmware archive")
+	upgradeCmd.Flags().StringP("init-pkt", "i", "", "Path to init packet (.dat file)")
+	upgradeCmd.Flags().StringP("firmware", "f", "", "Path to firmware image (.bin file)")
+
+	// Bind flags to viper keys
+	viper.BindPFlag("archive", upgradeCmd.Flags().Lookup("archive"))
+	viper.BindPFlag("initPkt", upgradeCmd.Flags().Lookup("init-pkt"))
+	viper.BindPFlag("firmware", upgradeCmd.Flags().Lookup("firmware"))
+}

cmd/itctl/cmd/version.go

@@ -0,0 +1,77 @@
+/*
+ *	itd uses bluetooth low energy to communicate with InfiniTime devices
+ *	Copyright (C) 2021 Arsen Musayelyan
+ *
+ *	This program is free software: you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation, either version 3 of the License, or
+ *	(at your option) any later version.
+ *
+ *	This program is distributed in the hope that it will be useful,
+ *	but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *	GNU General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License
+ *	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package cmd
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"net"
+
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+	"go.arsenm.dev/itd/internal/types"
+)
+
+// versionCmd represents the version command
+var versionCmd = &cobra.Command{
+	Use:     "version",
+	Aliases: []string{"ver"},
+	Short:   "Get firmware version of InfiniTime",
+	Run: func(cmd *cobra.Command, args []string) {
+		// Connect to itd UNIX socket
+		conn, err := net.Dial("unix", SockPath)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error dialing socket. Is itd running?")
+		}
+		defer conn.Close()
+
+		// Encode request into connection
+		err = json.NewEncoder(conn).Encode(types.Request{
+			Type: ReqTypeFwVersion,
+		})
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error making request")
+		}
+
+		// Read one line from connection
+		line, _, err := bufio.NewReader(conn).ReadLine()
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error reading line from connection")
+		}
+
+		var res types.Response
+		// Decode line into response
+		err = json.Unmarshal(line, &res)
+		if err != nil {
+			log.Fatal().Err(err).Msg("Error decoding JSON data")
+		}
+
+		if res.Error {
+			log.Fatal().Msg(res.Message)
+		}
+
+		// Print returned value
+		fmt.Println(res.Value)
+	},
+}
+
+func init() {
+	firmwareCmd.AddCommand(versionCmd)
+}

cmd/itctl/firmware.go

@@ -1,94 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"path/filepath"
-	"time"
-
-	"github.com/cheggaaa/pb/v3"
-	"github.com/rs/zerolog/log"
-	"github.com/urfave/cli/v2"
-	"go.arsenm.dev/itd/api"
-)
-
-func fwUpgrade(c *cli.Context) error {
-	resources := c.String("resources")
-	if resources != "" {
-		absRes, err := filepath.Abs(resources)
-		if err != nil {
-			return err
-		}
-
-		err = resLoad(c.Context, []string{absRes})
-		if err != nil {
-			log.Error().Msg("Resource loading has returned an error. This can happen if your current version of InfiniTime doesn't support BLE FS. Try updating without resource loading, and then load them after using the `itctl res load` command.")
-			return err
-		}
-	}
-
-	start := time.Now()
-
-	var upgType api.UpgradeType
-	var files []string
-	// Get relevant data struct
-	if c.String("archive") != "" {
-		// Get archive data struct
-		upgType = api.UpgradeTypeArchive
-		files = []string{c.String("archive")}
-	} else if c.String("init-packet") != "" && c.String("firmware") != "" {
-		// Get files data struct
-		upgType = api.UpgradeTypeFiles
-		files = []string{c.String("init-packet"), c.String("firmware")}
-	} else {
-		return cli.Exit("Upgrade command requires either archive or init packet and firmware.", 1)
-	}
-
-	progress, err := client.FirmwareUpgrade(c.Context, upgType, abs(files)...)
-	if err != nil {
-		return err
-	}
-
-	// Create progress bar template
-	barTmpl := `{{counters . }} B {{bar . "|" "-" (cycle .) " " "|"}} {{percent . }} {{rtime . "%s"}}`
-	// Start full bar at 0 total
-	bar := pb.ProgressBarTemplate(barTmpl).Start(0)
-	// Create new scanner of connection
-	for event := range progress {
-		// Set total bytes in progress bar
-		bar.SetTotal(event.Total)
-		// Set amount of bytes received in progress bar
-		bar.SetCurrent(int64(event.Received))
-		// If transfer finished, break
-		if int64(event.Sent) == event.Total {
-			break
-		}
-	}
-	// Finish progress bar
-	bar.Finish()
-
-	fmt.Printf("Transferred %d B in %s.\n", bar.Total(), time.Since(start))
-	fmt.Println("Remember to validate the new firmware in the InfiniTime settings.")
-
-	return nil
-}
-
-func fwVersion(c *cli.Context) error {
-	version, err := client.Version(c.Context)
-	if err != nil {
-		return err
-	}
-
-	fmt.Println(version)
-	return nil
-}
-
-func abs(paths []string) []string {
-	for index, path := range paths {
-		newPath, err := filepath.Abs(path)
-		if err != nil {
-			continue
-		}
-		paths[index] = newPath
-	}
-	return paths
-}

cmd/itctl/fs.go

@@ -1,175 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-
-	"github.com/cheggaaa/pb/v3"
-	"github.com/urfave/cli/v2"
-)
-
-func fsList(c *cli.Context) error {
-	dirPath := "/"
-	if c.Args().Len() > 0 {
-		dirPath = c.Args().Get(0)
-	}
-
-	listing, err := client.ReadDir(c.Context, dirPath)
-	if err != nil {
-		return err
-	}
-
-	for _, entry := range listing {
-		fmt.Println(entry)
-	}
-
-	return nil
-}
-
-func fsMkdir(c *cli.Context) error {
-	if c.Args().Len() < 1 {
-		return cli.Exit("Command mkdir requires one or more arguments", 1)
-	}
-
-	var err error
-	if c.Bool("parents") {
-		err = client.MkdirAll(c.Context, c.Args().Slice()...)
-	} else {
-		err = client.Mkdir(c.Context, c.Args().Slice()...)
-	}
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func fsMove(c *cli.Context) error {
-	if c.Args().Len() != 2 {
-		return cli.Exit("Command move requires two arguments", 1)
-	}
-
-	err := client.Rename(c.Context, c.Args().Get(0), c.Args().Get(1))
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func fsRead(c *cli.Context) error {
-	if c.Args().Len() != 2 {
-		return cli.Exit("Command read requires two arguments", 1)
-	}
-
-	var tmpFile *os.File
-	var path string
-	var err error
-	if c.Args().Get(1) == "-" {
-		tmpFile, err = ioutil.TempFile("/tmp", "itctl.*")
-		if err != nil {
-			return err
-		}
-		path = tmpFile.Name()
-	} else {
-		path, err = filepath.Abs(c.Args().Get(1))
-		if err != nil {
-			return err
-		}
-	}
-
-	progress, err := client.Download(c.Context, path, c.Args().Get(0))
-	if err != nil {
-		return err
-	}
-
-	// Create progress bar template
-	barTmpl := `{{counters . }} B {{bar . "|" "-" (cycle .) " " "|"}} {{percent . }} {{rtime . "%s"}}`
-	// Start full bar at 0 total
-	bar := pb.ProgressBarTemplate(barTmpl).Start(0)
-	// Get progress events
-	for event := range progress {
-		// Set total bytes in progress bar
-		bar.SetTotal(int64(event.Total))
-		// Set amount of bytes sent in progress bar
-		bar.SetCurrent(int64(event.Sent))
-	}
-	bar.Finish()
-
-	if c.Args().Get(1) == "-" {
-		io.Copy(os.Stdout, tmpFile)
-		os.Stdout.WriteString("\n")
-		os.Stdout.Sync()
-		tmpFile.Close()
-	}
-
-	return nil
-}
-
-func fsRemove(c *cli.Context) error {
-	if c.Args().Len() < 1 {
-		return cli.Exit("Command remove requires one or more arguments", 1)
-	}
-
-	var err error
-	if c.Bool("recursive") {
-		err = client.RemoveAll(c.Context, c.Args().Slice()...)
-	} else {
-		err = client.Remove(c.Context, c.Args().Slice()...)
-	}
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func fsWrite(c *cli.Context) error {
-	if c.Args().Len() != 2 {
-		return cli.Exit("Command write requires two arguments", 1)
-	}
-
-	var tmpFile *os.File
-	var path string
-	var err error
-	if c.Args().Get(0) == "-" {
-		tmpFile, err = ioutil.TempFile("/tmp", "itctl.*")
-		if err != nil {
-			return err
-		}
-		path = tmpFile.Name()
-	} else {
-		path, err = filepath.Abs(c.Args().Get(0))
-		if err != nil {
-			return err
-		}
-	}
-
-	if c.Args().Get(0) == "-" {
-		io.Copy(tmpFile, os.Stdin)
-		defer tmpFile.Close()
-		defer os.Remove(path)
-	}
-
-	progress, err := client.Upload(c.Context, c.Args().Get(1), path)
-	if err != nil {
-		return err
-	}
-
-	// Create progress bar template
-	barTmpl := `{{counters . }} B {{bar . "|" "-" (cycle .) " " "|"}} {{percent . }} {{rtime . "%s"}}`
-	// Start full bar at 0 total
-	bar := pb.ProgressBarTemplate(barTmpl).Start(0)
-	// Get progress events
-	for event := range progress {
-		// Set total bytes in progress bar
-		bar.SetTotal(int64(event.Total))
-		// Set amount of bytes sent in progress bar
-		bar.SetCurrent(int64(event.Sent))
-	}
-
-	return nil
-}

cmd/itctl/get.go

@@ -1,71 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-
-	"github.com/urfave/cli/v2"
-)
-
-func getAddress(c *cli.Context) error {
-	address, err := client.Address(c.Context)
-	if err != nil {
-		return err
-	}
-
-	fmt.Println(address)
-	return nil
-}
-
-func getBattery(c *cli.Context) error {
-	battLevel, err := client.BatteryLevel(c.Context)
-	if err != nil {
-		return err
-	}
-
-	// Print returned percentage
-	fmt.Printf("%d%%\n", battLevel)
-	return nil
-}
-
-func getHeart(c *cli.Context) error {
-	heartRate, err := client.HeartRate(c.Context)
-	if err != nil {
-		return err
-	}
-
-	// Print returned BPM
-	fmt.Printf("%d BPM\n", heartRate)
-	return nil
-}
-
-func getMotion(c *cli.Context) error {
-	motionVals, err := client.Motion(c.Context)
-	if err != nil {
-		return err
-	}
-
-	if c.Bool("shell") {
-		fmt.Printf(
-			"X=%d\nY=%d\nZ=%d\n",
-			motionVals.X,
-			motionVals.Y,
-			motionVals.Z,
-		)
-	} else {
-		return json.NewEncoder(os.Stdout).Encode(motionVals)
-	}
-	return nil
-}
-
-func getSteps(c *cli.Context) error {
-	stepCount, err := client.StepCount(c.Context)
-	if err != nil {
-		return err
-	}
-
-	// Print returned BPM
-	fmt.Printf("%d Steps\n", stepCount)
-	return nil
-}

cmd/itctl/main.go

@@ -1,319 +1,36 @@
+/*
+ *	itd uses bluetooth low energy to communicate with InfiniTime devices
+ *	Copyright (C) 2021 Arsen Musayelyan
+ *
+ *	This program is free software: you can redistribute it and/or modify
+ *	it under the terms of the GNU General Public License as published by
+ *	the Free Software Foundation, either version 3 of the License, or
+ *	(at your option) any later version.
+ *
+ *	This program is distributed in the hope that it will be useful,
+ *	but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *	GNU General Public License for more details.
+ *
+ *	You should have received a copy of the GNU General Public License
+ *	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 package main
 
 import (
-	"context"
 	"os"
-	"os/signal"
-	"syscall"
-	"time"
+
+	"go.arsenm.dev/itd/cmd/itctl/cmd"
 
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
-	"github.com/urfave/cli/v2"
-	"go.arsenm.dev/itd/api"
 )
 
-var client *api.Client
+func init() {
+	log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr})
+}
 
 func main() {
-	log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr})
-
-	ctx := context.Background()
-	ctx, _ = signal.NotifyContext(
-		ctx,
-		syscall.SIGINT,
-		syscall.SIGTERM,
-	)
-
-	// This goroutine ensures that itctl will exit
-	// at most 200ms after the user sends SIGINT/SIGTERM.
-	go func() {
-		<-ctx.Done()
-		time.Sleep(200 * time.Millisecond)
-		os.Exit(0)
-	}()
-
-	app := cli.App{
-		Name:            "itctl",
-		HideHelpCommand: true,
-		Flags: []cli.Flag{
-			&cli.StringFlag{
-				Name:    "socket-path",
-				Aliases: []string{"s"},
-				Value:   api.DefaultAddr,
-				Usage:   "Path to itd socket",
-			},
-		},
-		Commands: []*cli.Command{
-			{
-				Name:      "help",
-				ArgsUsage: "<command>",
-				Usage:     "Display help screen for a command",
-				Action:    helpCmd,
-			},
-			{
-				Name:    "resources",
-				Aliases: []string{"res"},
-				Usage:   "Handle InfiniTime resource loading",
-				Subcommands: []*cli.Command{
-					{
-						Name:      "load",
-						ArgsUsage: "<path>",
-						Usage:     "Load an InifiniTime resources package",
-						Action:    resourcesLoad,
-					},
-				},
-			},
-			{
-				Name:    "filesystem",
-				Aliases: []string{"fs"},
-				Usage:   "Perform filesystem operations on the PineTime",
-				Subcommands: []*cli.Command{
-					{
-						Name:      "list",
-						ArgsUsage: "[dir]",
-						Aliases:   []string{"ls"},
-						Usage:     "List a directory",
-						Action:    fsList,
-					},
-					{
-						Flags: []cli.Flag{
-							&cli.BoolFlag{
-								Name:    "parents",
-								Aliases: []string{"p"},
-								Usage:   "Make parent directories if needed, no error if already existing",
-							},
-						},
-						Name:      "mkdir",
-						ArgsUsage: "<paths...>",
-						Usage:     "Create new directories",
-						Action:    fsMkdir,
-					},
-					{
-						Name:      "move",
-						ArgsUsage: "<old> <new>",
-						Aliases:   []string{"mv"},
-						Usage:     "Move a file or directory",
-						Action:    fsMove,
-					},
-					{
-						Name:        "read",
-						ArgsUsage:   `<remote path> <local path>`,
-						Usage:       "Read a file from InfiniTime.",
-						Description: `Read is used to read files from InfiniTime's filesystem. A "-" can be used to signify stdout`,
-						Action:      fsRead,
-					},
-					{
-						Flags: []cli.Flag{
-							&cli.BoolFlag{
-								Name:    "recursive",
-								Aliases: []string{"r", "R"},
-								Usage:   "Remove directories and their contents recursively",
-							},
-						},
-						Name:      "remove",
-						ArgsUsage: "<paths...>",
-						Aliases:   []string{"rm"},
-						Usage:     "Remove a file from InfiniTime",
-						Action:    fsRemove,
-					},
-					{
-						Name:        "write",
-						ArgsUsage:   `<local path> <remote path>`,
-						Usage:       "Write a file to InfiniTime",
-						Description: `Write is used to write files to InfiniTime's filesystem. A "-" can be used to signify stdin`,
-						Action:      fsWrite,
-					},
-				},
-			},
-			{
-				Name:    "firmware",
-				Aliases: []string{"fw"},
-				Usage:   "Manage InfiniTime firmware",
-				Subcommands: []*cli.Command{
-					{
-						Flags: []cli.Flag{
-							&cli.PathFlag{
-								Name:    "init-packet",
-								Aliases: []string{"i"},
-								Usage:   "Path to init packet (.dat file)",
-							},
-							&cli.PathFlag{
-								Name:    "firmware",
-								Aliases: []string{"f"},
-								Usage:   "Path to firmware image (.bin file)",
-							},
-							&cli.PathFlag{
-								Name:    "resources",
-								Aliases: []string{"r"},
-								Usage:   "Path to resources file (.zip file)",
-							},
-							&cli.PathFlag{
-								Name:    "archive",
-								Aliases: []string{"a"},
-								Usage:   "Path to firmware archive (.zip file)",
-							},
-						},
-						Name:    "upgrade",
-						Aliases: []string{"upg"},
-						Usage:   "Upgrade InfiniTime firmware using files or archive",
-						Action:  fwUpgrade,
-					},
-					{
-						Name:    "version",
-						Aliases: []string{"ver"},
-						Usage:   "Get firmware version of InfiniTime",
-						Action:  fwVersion,
-					},
-				},
-			},
-			{
-				Name:  "get",
-				Usage: "Get information from InfiniTime",
-				Subcommands: []*cli.Command{
-					{
-						Name:    "address",
-						Aliases: []string{"addr"},
-						Usage:   "Get InfiniTime's bluetooth address",
-						Action:  getAddress,
-					},
-					{
-						Name:    "battery",
-						Aliases: []string{"batt"},
-						Usage:   "Get InfiniTime's battery percentage",
-						Action:  getBattery,
-					},
-					{
-						Name:   "heart",
-						Usage:  "Get heart rate from InfiniTime",
-						Action: getHeart,
-					},
-					{
-						Flags: []cli.Flag{
-							&cli.BoolFlag{Name: "shell"},
-						},
-						Name:   "motion",
-						Usage:  "Get motion values from InfiniTime",
-						Action: getMotion,
-					},
-					{
-						Name:   "steps",
-						Usage:  "Get step count from InfiniTime",
-						Action: getSteps,
-					},
-				},
-			},
-			{
-				Name:   "notify",
-				Usage:  "Send notification to InfiniTime",
-				Action: notify,
-			},
-			{
-				Name:  "set",
-				Usage: "Set information on InfiniTime",
-				Subcommands: []*cli.Command{
-					{
-						Name:      "time",
-						ArgsUsage: `<ISO8601|"now">`,
-						Usage:     "Set InfiniTime's clock to specified time",
-						Action:    setTime,
-					},
-				},
-			},
-			{
-				Name:    "update",
-				Usage:   "Update information on InfiniTime",
-				Aliases: []string{"upd"},
-				Subcommands: []*cli.Command{
-					{
-						Name:   "weather",
-						Usage:  "Force an immediate update of weather data",
-						Action: updateWeather,
-					},
-				},
-			},
-			{
-				Name:  "watch",
-				Usage: "Watch a value for changes",
-				Subcommands: []*cli.Command{
-					{
-						Flags: []cli.Flag{
-							&cli.BoolFlag{Name: "json"},
-							&cli.BoolFlag{Name: "shell"},
-						},
-						Name:   "heart",
-						Usage:  "Watch heart rate value for changes",
-						Action: watchHeart,
-					},
-					{
-						Flags: []cli.Flag{
-							&cli.BoolFlag{Name: "json"},
-							&cli.BoolFlag{Name: "shell"},
-						},
-						Name:   "steps",
-						Usage:  "Watch step count value for changes",
-						Action: watchStepCount,
-					},
-					{
-						Flags: []cli.Flag{
-							&cli.BoolFlag{Name: "json"},
-							&cli.BoolFlag{Name: "shell"},
-						},
-						Name:   "motion",
-						Usage:  "Watch motion coordinates for changes",
-						Action: watchMotion,
-					},
-					{
-						Flags: []cli.Flag{
-							&cli.BoolFlag{Name: "json"},
-							&cli.BoolFlag{Name: "shell"},
-						},
-						Name:    "battery",
-						Aliases: []string{"batt"},
-						Usage:   "Watch battery level value for changes",
-						Action:  watchBattLevel,
-					},
-				},
-			},
-		},
-		Before: func(c *cli.Context) error {
-			if !isHelpCmd() {
-				newClient, err := api.New(c.String("socket-path"))
-				if err != nil {
-					return err
-				}
-				client = newClient
-			}
-			return nil
-		},
-		After: func(*cli.Context) error {
-			if client != nil {
-				client.Close()
-			}
-			return nil
-		},
-	}
-
-	err := app.RunContext(ctx, os.Args)
-	if err != nil {
-		log.Fatal().Err(err).Msg("Error while running app")
-	}
-}
-
-func helpCmd(c *cli.Context) error {
-	cmdArgs := append([]string{os.Args[0]}, c.Args().Slice()...)
-	cmdArgs = append(cmdArgs, "-h")
-	return c.App.RunContext(c.Context, cmdArgs)
-}
-
-func isHelpCmd() bool {
-	if len(os.Args) == 1 {
-		return true
-	}
-	for _, arg := range os.Args {
-		if arg == "-h" || arg == "help" {
-			return true
-		}
-	}
-	return false
+	cmd.Execute()
 }

cmd/itctl/notify.go

@@ -1,17 +0,0 @@
-package main
-
-import "github.com/urfave/cli/v2"
-
-func notify(c *cli.Context) error {
-	// Ensure required arguments
-	if c.Args().Len() != 2 {
-		return cli.Exit("Command notify requires two arguments", 1)
-	}
-
-	err := client.Notify(c.Context, c.Args().Get(0), c.Args().Get(1))
-	if err != nil {
-		return err
-	}
-
-	return nil
-}

cmd/itctl/resources.go

@@ -1,57 +0,0 @@
-package main
-
-import (
-	"context"
-	"path/filepath"
-
-	"github.com/cheggaaa/pb/v3"
-	"github.com/urfave/cli/v2"
-	"go.arsenm.dev/infinitime"
-)
-
-func resourcesLoad(c *cli.Context) error {
-	return resLoad(c.Context, c.Args().Slice())
-}
-
-func resLoad(ctx context.Context, args []string) error {
-	if len(args) == 0 {
-		return cli.Exit("Command load requires one argument.", 1)
-	}
-
-	// Create progress bar templates
-	rmTmpl := `Removing {{string . "filename"}}`
-	upTmpl := `Uploading {{string . "filename"}} {{counters . }} B {{bar . "|" "-" (cycle .) " " "|"}} {{percent . }} {{rtime . "%s"}}`
-	// Start full bar at 0 total
-	bar := pb.ProgressBarTemplate(rmTmpl).Start(0)
-
-	path, err := filepath.Abs(args[0])
-	if err != nil {
-		return err
-	}
-
-	progCh, err := client.LoadResources(ctx, path)
-	if err != nil {
-		return err
-	}
-
-	for evt := range progCh {
-		if evt.Err != nil {
-			return evt.Err
-		}
-
-		if evt.Operation == infinitime.ResourceOperationRemoveObsolete {
-			bar.SetTemplateString(rmTmpl)
-			bar.Set("filename", evt.Name)
-		} else {
-			bar.SetTemplateString(upTmpl)
-			bar.Set("filename", evt.Name)
-
-			bar.SetTotal(evt.Total)
-			bar.SetCurrent(evt.Sent)
-		}
-	}
-
-	bar.Finish()
-
-	return nil
-}

cmd/itctl/set.go

@@ -1,24 +0,0 @@
-package main
-
-import (
-	"time"
-
-	"github.com/urfave/cli/v2"
-)
-
-func setTime(c *cli.Context) error {
-	// Ensure required arguments
-	if c.Args().Len() < 1 {
-		return cli.Exit("Command time requires one argument", 1)
-	}
-
-	if c.Args().Get(0) == "now" {
-		return client.SetTime(c.Context, time.Now())
-	} else {
-		parsed, err := time.Parse(time.RFC3339, c.Args().Get(0))
-		if err != nil {
-			return err
-		}
-		return client.SetTime(c.Context, parsed)
-	}
-}

cmd/itctl/update.go

@@ -1,7 +0,0 @@
-package main
-
-import "github.com/urfave/cli/v2"
-
-func updateWeather(c *cli.Context) error {
-	return client.WeatherUpdate(c.Context)
-}

cmd/itctl/watch.go

@@ -1,108 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-
-	"github.com/urfave/cli/v2"
-)
-
-func watchHeart(c *cli.Context) error {
-	heartCh, err := client.WatchHeartRate(c.Context)
-	if err != nil {
-		return err
-	}
-
-	for {
-		select {
-		case heartRate := <-heartCh:
-			if c.Bool("json") {
-				json.NewEncoder(os.Stdout).Encode(
-					map[string]uint8{"heartRate": heartRate},
-				)
-			} else if c.Bool("shell") {
-				fmt.Printf("HEART_RATE=%d\n", heartRate)
-			} else {
-				fmt.Println(heartRate, "BPM")
-			}
-		case <-c.Done():
-			return nil
-		}
-	}
-}
-
-func watchBattLevel(c *cli.Context) error {
-	battLevelCh, err := client.WatchBatteryLevel(c.Context)
-	if err != nil {
-		return err
-	}
-
-	for {
-		select {
-		case battLevel := <-battLevelCh:
-			if c.Bool("json") {
-				json.NewEncoder(os.Stdout).Encode(
-					map[string]uint8{"battLevel": battLevel},
-				)
-			} else if c.Bool("shell") {
-				fmt.Printf("BATTERY_LEVEL=%d\n", battLevel)
-			} else {
-				fmt.Printf("%d%%\n", battLevel)
-			}
-		case <-c.Done():
-			return nil
-		}
-	}
-}
-
-func watchStepCount(c *cli.Context) error {
-	stepCountCh, err := client.WatchStepCount(c.Context)
-	if err != nil {
-		return err
-	}
-
-	for {
-		select {
-		case stepCount := <-stepCountCh:
-			if c.Bool("json") {
-				json.NewEncoder(os.Stdout).Encode(
-					map[string]uint32{"stepCount": stepCount},
-				)
-			} else if c.Bool("shell") {
-				fmt.Printf("STEP_COUNT=%d\n", stepCount)
-			} else {
-				fmt.Println(stepCount, "Steps")
-			}
-		case <-c.Done():
-			return nil
-		}
-	}
-}
-
-func watchMotion(c *cli.Context) error {
-	motionCh, err := client.WatchMotion(c.Context)
-	if err != nil {
-		return err
-	}
-
-	for {
-		select {
-		case motionVals := <-motionCh:
-			if c.Bool("json") {
-				json.NewEncoder(os.Stdout).Encode(motionVals)
-			} else if c.Bool("shell") {
-				fmt.Printf(
-					"X=%d\nY=%d\nZ=%d\n",
-					motionVals.X,
-					motionVals.Y,
-					motionVals.Z,
-				)
-			} else {
-				fmt.Println(motionVals)
-			}
-		case <-c.Done():
-			return nil
-		}
-	}
-}

cmd/itgui/error.go

@@ -1,57 +0,0 @@
-package main
-
-import (
-	"image/color"
-	"os"
-
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/canvas"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/dialog"
-	"fyne.io/fyne/v2/widget"
-)
-
-func guiErr(err error, msg string, fatal bool, parent fyne.Window) {
-	// Create new label containing message
-	msgLbl := widget.NewLabel(msg)
-	// Text formatting settings
-	msgLbl.Wrapping = fyne.TextWrapWord
-	msgLbl.Alignment = fyne.TextAlignCenter
-	// Create new rectangle to set the size of the dialog
-	rect := canvas.NewRectangle(color.Transparent)
-	// Set minimum size of rectangle to 350x0
-	rect.SetMinSize(fyne.NewSize(350, 0))
-	// Create new container containing message and rectangle
-	content := container.NewVBox(
-		msgLbl,
-		rect,
-	)
-	if err != nil {
-		// Create new label containing error text
-		errEntry := widget.NewEntry()
-		errEntry.SetText(err.Error())
-		// If text changed, change it back
-		errEntry.OnChanged = func(string) {
-			errEntry.SetText(err.Error())
-		}
-		// Create new dropdown containing error label
-		content.Add(widget.NewAccordion(
-			widget.NewAccordionItem("More Details", errEntry),
-		))
-	}
-	if fatal {
-		// Create new error dialog
-		errDlg := dialog.NewCustom("Error", "Close", content, parent)
-		// On close, exit with code 1
-		errDlg.SetOnClosed(func() {
-			os.Exit(1)
-		})
-		// Show dialog
-		errDlg.Show()
-		// Run app prematurely to stop further execution
-		parent.ShowAndRun()
-	} else {
-		// Show error dialog
-		dialog.NewCustom("Error", "Ok", content, parent).Show()
-	}
-}

cmd/itgui/firmware.go

@@ -1,163 +0,0 @@
-package main
-
-import (
-	"context"
-
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/dialog"
-	"fyne.io/fyne/v2/layout"
-	"fyne.io/fyne/v2/storage"
-	"fyne.io/fyne/v2/widget"
-	"go.arsenm.dev/itd/api"
-)
-
-func firmwareTab(ctx context.Context, client *api.Client, w fyne.Window) fyne.CanvasObject {
-	// Create select to chose between archive and files upgrade
-	typeSelect := widget.NewSelect([]string{"Archive", "Files"}, nil)
-	typeSelect.PlaceHolder = "Upgrade Type"
-
-	// Create map to store files
-	files := map[string]string{}
-
-	// Create and disable start button
-	startBtn := widget.NewButton("Start", nil)
-	startBtn.Disable()
-
-	// Create new file open dialog for archive
-	archiveDlg := dialog.NewFileOpen(func(uc fyne.URIReadCloser, err error) {
-		if err != nil || uc == nil {
-			return
-		}
-		defer uc.Close()
-		// Set archive path in map
-		files[".zip"] = uc.URI().Path()
-		// Enable start button
-		startBtn.Enable()
-	}, w)
-	// Only allow .zip files
-	archiveDlg.SetFilter(storage.NewExtensionFileFilter([]string{".zip"}))
-	// Create button to show dialog
-	archiveBtn := widget.NewButton("Select Archive (.zip)", archiveDlg.Show)
-
-	// Create new file open dialog for firmware image
-	imageDlg := dialog.NewFileOpen(func(uc fyne.URIReadCloser, err error) {
-		if err != nil || uc == nil {
-			return
-		}
-		defer uc.Close()
-
-		// Set firmware image path in map
-		files[".bin"] = uc.URI().Path()
-
-		// If the init packet was already selected
-		_, datOk := files[".dat"]
-		if datOk {
-			// Enable start button
-			startBtn.Enable()
-		}
-	}, w)
-	// Only allow .bin files
-	imageDlg.SetFilter(storage.NewExtensionFileFilter([]string{".bin"}))
-	// Create button to show dialog
-	imageBtn := widget.NewButton("Select Firmware (.bin)", imageDlg.Show)
-
-	// Create new file open dialog for init packet
-	initDlg := dialog.NewFileOpen(func(uc fyne.URIReadCloser, err error) {
-		if err != nil || uc == nil {
-			return
-		}
-		defer uc.Close()
-
-		// Set init packet path in map
-		files[".dat"] = uc.URI().Path()
-
-		// If the firmware image was already selected
-		_, binOk := files[".bin"]
-		if binOk {
-			// Enable start button
-			startBtn.Enable()
-		}
-	}, w)
-	// Only allow .dat files
-	initDlg.SetFilter(storage.NewExtensionFileFilter([]string{".dat"}))
-	// Create button to show dialog
-	initBtn := widget.NewButton("Select Init Packet (.dat)", initDlg.Show)
-
-	var upgType api.UpgradeType = 255
-	// When upgrade type changes
-	typeSelect.OnChanged = func(s string) {
-		// Delete all files from map
-		delete(files, ".bin")
-		delete(files, ".dat")
-		delete(files, ".zip")
-		// Hide all dialog buttons
-		imageBtn.Hide()
-		initBtn.Hide()
-		archiveBtn.Hide()
-		// Disable start button
-		startBtn.Disable()
-
-		switch s {
-		case "Files":
-			// Set file upgrade type
-			upgType = api.UpgradeTypeFiles
-			// Show firmware image and init packet buttons
-			imageBtn.Show()
-			initBtn.Show()
-		case "Archive":
-			// Set archive upgrade type
-			upgType = api.UpgradeTypeArchive
-			// Show archive button
-			archiveBtn.Show()
-		}
-	}
-	// Select archive by default
-	typeSelect.SetSelectedIndex(0)
-
-	// When start button pressed
-	startBtn.OnTapped = func() {
-		var args []string
-		// Append the appropriate files for upgrade type
-		switch upgType {
-		case api.UpgradeTypeArchive:
-			args = append(args, files[".zip"])
-		case api.UpgradeTypeFiles:
-			args = append(args, files[".dat"], files[".bin"])
-		}
-
-		// If args are nil (invalid upgrade type)
-		if args == nil {
-			return
-		}
-
-		// Create new progress dialog
-		progress := newProgress(w)
-		// Start firmware upgrade
-		progressCh, err := client.FirmwareUpgrade(ctx, upgType, args...)
-		if err != nil {
-			guiErr(err, "Error performing firmware upgrade", false, w)
-			return
-		}
-		// Show progress dialog
-		progress.Show()
-		// For every progress event
-		for progressEvt := range progressCh {
-			// Set progress bar values
-			progress.SetTotal(float64(progressEvt.Total))
-			progress.SetValue(float64(progressEvt.Sent))
-		}
-		// Hide progress dialog
-		progress.Hide()
-	}
-
-	return container.NewVBox(
-		layout.NewSpacer(),
-		typeSelect,
-		archiveBtn,
-		imageBtn,
-		initBtn,
-		startBtn,
-		layout.NewSpacer(),
-	)
-}

cmd/itgui/fs.go

@@ -1,407 +0,0 @@
-package main
-
-import (
-	"context"
-	"path/filepath"
-
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/data/binding"
-	"fyne.io/fyne/v2/dialog"
-	"fyne.io/fyne/v2/storage"
-	"fyne.io/fyne/v2/theme"
-	"fyne.io/fyne/v2/widget"
-	"go.arsenm.dev/infinitime"
-	"go.arsenm.dev/itd/api"
-)
-
-func fsTab(ctx context.Context, client *api.Client, w fyne.Window, opened chan struct{}) fyne.CanvasObject {
-	c := container.NewVBox()
-
-	// Create new binding to store current directory
-	cwdData := binding.NewString()
-	cwdData.Set("/")
-
-	// Create new list binding to store fs listing entries
-	lsData := binding.NewUntypedList()
-
-	// This goroutine waits until the fs tab is opened to
-	// request the listing from the watch
-	go func() {
-		// Wait for opened signal
-		<-opened
-
-		// Show loading pop up
-		loading := newLoadingPopUp(w)
-		loading.Show()
-
-		// Read root directory
-		ls, err := client.ReadDir(ctx, "/")
-		if err != nil {
-			guiErr(err, "Error reading directory", false, w)
-			return
-		}
-		// Set ls binding
-		lsData.Set(lsToAny(ls))
-
-		// Hide loading pop up
-		loading.Hide()
-	}()
-
-	toolbar := widget.NewToolbar(
-		widget.NewToolbarAction(
-			theme.ViewRefreshIcon(),
-			func() {
-				refresh(ctx, cwdData, lsData, client, w, c)
-			},
-		),
-		widget.NewToolbarAction(
-			theme.FileApplicationIcon(),
-			func() {
-				dlg := dialog.NewFileOpen(func(uc fyne.URIReadCloser, err error) {
-					if err != nil || uc == nil {
-						return
-					}
-
-					resPath := uc.URI().Path()
-					uc.Close()
-
-					progressDlg := newProgress(w)
-					progressDlg.Show()
-
-					progCh, err := client.LoadResources(ctx, resPath)
-					if err != nil {
-						guiErr(err, "Error loading resources", false, w)
-						return
-					}
-
-					for evt := range progCh {
-						if evt.Err != nil {
-							guiErr(evt.Err, "Error loading resources", false, w)
-							return
-						}
-
-						switch evt.Operation {
-						case infinitime.ResourceOperationRemoveObsolete:
-							progressDlg.SetText("Removing " + evt.Name)
-						case infinitime.ResourceOperationUpload:
-							progressDlg.SetText("Uploading " + evt.Name)
-							progressDlg.SetTotal(float64(evt.Total))
-							progressDlg.SetValue(float64(evt.Sent))
-						}
-					}
-
-					progressDlg.Hide()
-					refresh(ctx, cwdData, lsData, client, w, c)
-				}, w)
-				dlg.SetConfirmText("Upload Resources")
-				dlg.SetFilter(storage.NewExtensionFileFilter([]string{
-					".zip",
-				}))
-				dlg.Show()
-			},
-		),
-		widget.NewToolbarAction(
-			theme.UploadIcon(),
-			func() {
-				// Create open dialog for file that will be uploaded
-				dlg := dialog.NewFileOpen(func(uc fyne.URIReadCloser, err error) {
-					if err != nil || uc == nil {
-						return
-					}
-					// Get filepath and close
-					localPath := uc.URI().Path()
-					uc.Close()
-
-					// Create new entry to store filepath
-					filenameEntry := widget.NewEntry()
-					// Set entry text to the file name of the selected file
-					filenameEntry.SetText(filepath.Base(localPath))
-					// Create new dialog asking for the filename of the file to be stored on the watch
-					uploadDlg := dialog.NewForm("Upload", "Upload", "Cancel", []*widget.FormItem{
-						widget.NewFormItem("Filename", filenameEntry),
-					}, func(ok bool) {
-						if !ok {
-							return
-						}
-
-						// Get current directory
-						cwd, _ := cwdData.Get()
-						// Get remote path by joining current directory with filename
-						remotePath := filepath.Join(cwd, filenameEntry.Text)
-
-						// Create new progress dialog
-						progressDlg := newProgress(w)
-						progressDlg.Show()
-
-						// Upload file
-						progressCh, err := client.Upload(ctx, remotePath, localPath)
-						if err != nil {
-							guiErr(err, "Error uploading file", false, w)
-							return
-						}
-
-						for progressEvt := range progressCh {
-							progressDlg.SetTotal(float64(progressEvt.Total))
-							progressDlg.SetValue(float64(progressEvt.Sent))
-							if progressEvt.Sent == progressEvt.Total {
-								break
-							}
-						}
-
-						// Close progress dialog
-						progressDlg.Hide()
-
-						// Add file to listing (avoids full refresh)
-						lsData.Append(api.FileInfo{
-							IsDir: false,
-							Name:  filepath.Base(remotePath),
-						})
-					}, w)
-					uploadDlg.Show()
-				}, w)
-				dlg.Show()
-			},
-		),
-		widget.NewToolbarAction(
-			theme.FolderNewIcon(),
-			func() {
-				// Create new entry for filename
-				filenameEntry := widget.NewEntry()
-				// Create new dialog to ask for the filename
-				mkdirDialog := dialog.NewForm("Make Directory", "Create", "Cancel", []*widget.FormItem{
-					widget.NewFormItem("Filename", filenameEntry),
-				}, func(ok bool) {
-					if !ok {
-						return
-					}
-
-					// Get current directory
-					cwd, _ := cwdData.Get()
-					// Get remote path by joining current directory and filename
-					remotePath := filepath.Join(cwd, filenameEntry.Text)
-
-					// Make directory
-					err := client.Mkdir(ctx, remotePath)
-					if err != nil {
-						guiErr(err, "Error creating directory", false, w)
-						return
-					}
-
-					// Add directory to listing (avoids full refresh)
-					lsData.Append(api.FileInfo{
-						IsDir: true,
-						Name:  filepath.Base(remotePath),
-					})
-				}, w)
-				mkdirDialog.Show()
-			},
-		),
-	)
-
-	// Add listener to listing data to create the new items on the GUI
-	// whenever the listing changes
-	lsData.AddListener(binding.NewDataListener(func() {
-		c.Objects = makeItems(ctx, client, lsData, cwdData, w, c)
-		c.Refresh()
-	}))
-
-	return container.NewBorder(
-		nil,
-		toolbar,
-		nil,
-		nil,
-		container.NewVScroll(c),
-	)
-}
-
-// makeItems creates GUI objects from listing data
-func makeItems(
-	ctx context.Context,
-	client *api.Client,
-	lsData binding.UntypedList,
-	cwdData binding.String,
-	w fyne.Window,
-	c *fyne.Container,
-) []fyne.CanvasObject {
-	// Get listing data
-	ls, _ := lsData.Get()
-
-	// Create output slice with dame length as listing
-	out := make([]fyne.CanvasObject, len(ls))
-	for index, val := range ls {
-		// Assert value as file info
-		item := val.(api.FileInfo)
-
-		var icon fyne.Resource
-		// Decide which icon to use
-		if item.IsDir {
-			if item.Name == ".." {
-				icon = theme.NavigateBackIcon()
-			} else {
-				icon = theme.FolderIcon()
-			}
-		} else {
-			icon = theme.FileIcon()
-		}
-
-		// Create new button with the decided icon and the item name
-		btn := widget.NewButtonWithIcon(item.Name, icon, nil)
-		// Align left
-		btn.Alignment = widget.ButtonAlignLeading
-		// Decide which callback function to use
-		if item.IsDir {
-			btn.OnTapped = func() {
-				// Get current directory
-				cwd, _ := cwdData.Get()
-				// Join current directory with item name
-				cwd = filepath.Join(cwd, item.Name)
-				// Set new current directory
-				cwdData.Set(cwd)
-				// Refresh GUI to display new directory
-				refresh(ctx, cwdData, lsData, client, w, c)
-			}
-		} else {
-			btn.OnTapped = func() {
-				// Get current directory
-				cwd, _ := cwdData.Get()
-				// Join current directory with item name
-				remotePath := filepath.Join(cwd, item.Name)
-				// Create new save dialog
-				dlg := dialog.NewFileSave(func(uc fyne.URIWriteCloser, err error) {
-					if err != nil || uc == nil {
-						return
-					}
-					// Get path of selected file
-					localPath := uc.URI().Path()
-					// Close WriteCloser (it's not needed)
-					uc.Close()
-
-					// Create new progress dialog
-					progressDlg := newProgress(w)
-					progressDlg.Show()
-
-					// Download file
-					progressCh, err := client.Download(ctx, localPath, remotePath)
-					if err != nil {
-						guiErr(err, "Error downloading file", false, w)
-						return
-					}
-
-					// For every progress event
-					for progressEvt := range progressCh {
-						progressDlg.SetTotal(float64(progressEvt.Total))
-						progressDlg.SetValue(float64(progressEvt.Sent))
-					}
-
-					// Close progress dialog
-					progressDlg.Hide()
-				}, w)
-				// Set filename to the item name
-				dlg.SetFileName(item.Name)
-				dlg.Show()
-			}
-		}
-
-		if item.Name == ".." {
-			out[index] = btn
-			continue
-		}
-
-		moveBtn := widget.NewButtonWithIcon("", theme.NavigateNextIcon(), func() {
-			moveEntry := widget.NewEntry()
-			dlg := dialog.NewForm("Move", "Move", "Cancel", []*widget.FormItem{
-				widget.NewFormItem("New Path", moveEntry),
-			}, func(ok bool) {
-				if !ok {
-					return
-				}
-
-				// Get current directory
-				cwd, _ := cwdData.Get()
-				// Join current directory with item name
-				oldPath := filepath.Join(cwd, item.Name)
-
-				// Rename file
-				err := client.Rename(ctx, oldPath, moveEntry.Text)
-				if err != nil {
-					guiErr(err, "Error renaming file", false, w)
-					return
-				}
-
-				// Refresh GUI
-				refresh(ctx, cwdData, lsData, client, w, c)
-			}, w)
-			dlg.Show()
-		})
-
-		removeBtn := widget.NewButtonWithIcon("", theme.DeleteIcon(), func() {
-			// Get current directory
-			cwd, _ := cwdData.Get()
-			// Join current directory with item name
-			path := filepath.Join(cwd, item.Name)
-
-			// Remove file
-			err := client.Remove(ctx, path)
-			if err != nil {
-				guiErr(err, "Error removing file", false, w)
-				return
-			}
-
-			// Refresh GUI
-			refresh(ctx, cwdData, lsData, client, w, c)
-		})
-
-		// Add button to GUI component list
-		out[index] = container.NewBorder(
-			nil,
-			nil,
-			nil,
-			container.NewHBox(moveBtn, removeBtn),
-			btn,
-		)
-	}
-	return out
-}
-
-func refresh(
-	ctx context.Context,
-	cwdData binding.String,
-	lsData binding.UntypedList,
-	client *api.Client,
-	w fyne.Window,
-	c *fyne.Container,
-) {
-	// Create and show new loading pop up
-	loading := newLoadingPopUp(w)
-	loading.Show()
-	// Close pop up at the end of the function
-	defer loading.Hide()
-
-	// Get current directory
-	cwd, _ := cwdData.Get()
-	// Read directory
-	ls, err := client.ReadDir(ctx, cwd)
-	if err != nil {
-		guiErr(err, "Error reading directory", false, w)
-		return
-	}
-	// Set new listing data
-	lsData.Set(lsToAny(ls))
-	// Create new GUI objects
-	c.Objects = makeItems(ctx, client, lsData, cwdData, w, c)
-	// Refresh GUI
-	c.Refresh()
-}
-
-func lsToAny(ls []api.FileInfo) []interface{} {
-	out := make([]interface{}, len(ls)-1)
-	for i, e := range ls {
-		// Skip first element as it is always "."
-		if i == 0 {
-			continue
-		}
-		out[i-1] = e
-	}
-	return out
-}

cmd/itgui/graph.go

@@ -1,150 +0,0 @@
-package main
-
-import (
-	"context"
-	"database/sql"
-	"image/color"
-	"os"
-	"path/filepath"
-
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/theme"
-	"fyne.io/x/fyne/widget/charts"
-	"go.arsenm.dev/itd/api"
-	_ "modernc.org/sqlite"
-)
-
-func graphTab(ctx context.Context, client *api.Client, w fyne.Window) fyne.CanvasObject {
-	// Get user configuration directory
-	userCfgDir, err := os.UserConfigDir()
-	if err != nil {
-		return nil
-	}
-	cfgDir := filepath.Join(userCfgDir, "itd")
-	dbPath := filepath.Join(cfgDir, "metrics.db")
-
-	// If stat on database returns error, return nil
-	if _, err := os.Stat(dbPath); err != nil {
-		return nil
-	}
-
-	// Open database
-	db, err := sql.Open("sqlite", dbPath)
-	if err != nil {
-		return nil
-	}
-
-	// Get heart rate data and create chart
-	heartRateData := getData(db, "bpm", "heartRate")
-	heartRate := newLineChartData(nil, heartRateData)
-
-	// Get step count data and create chart
-	stepCountData := getData(db, "steps", "stepCount")
-	stepCount := newLineChartData(nil, stepCountData)
-
-	// Get battery level data and create chart
-	battLevelData := getData(db, "percent", "battLevel")
-	battLevel := newLineChartData(nil, battLevelData)
-
-	// Get motion data
-	motionData := getMotionData(db)
-	// Create chart for each coordinate
-	xChart := newLineChartData(theme.PrimaryColorNamed(theme.ColorRed), motionData["X"])
-	yChart := newLineChartData(theme.PrimaryColorNamed(theme.ColorGreen), motionData["Y"])
-	zChart := newLineChartData(theme.PrimaryColorNamed(theme.ColorBlue), motionData["Z"])
-
-	// Create new max container with all the charts
-	motion := container.NewMax(xChart, yChart, zChart)
-
-	// Create tabs for charts
-	chartTabs := container.NewAppTabs(
-		container.NewTabItem("Heart Rate", heartRate),
-		container.NewTabItem("Step Count", stepCount),
-		container.NewTabItem("Battery Level", battLevel),
-		container.NewTabItem("Motion", motion),
-	)
-	// Place tabs on left
-	chartTabs.SetTabLocation(container.TabLocationLeading)
-	return chartTabs
-}
-
-func newLineChartData(col color.Color, data []float64) *charts.LineChart {
-	// Create new line chart
-	lc := charts.NewLineChart(nil)
-	setOpts(lc, col)
-	// If no data, make the stroke transparent
-	if len(data) == 0 {
-		lc.Options().StrokeColor = color.RGBA{0, 0, 0, 0}
-	}
-	// Set data
-	lc.SetData(data)
-	return lc
-}
-
-func setOpts(lc *charts.LineChart, col color.Color) {
-	// Get pointer to options
-	opts := lc.Options()
-	// Set fill color to transparent
-	opts.FillColor = color.RGBA{0, 0, 0, 0}
-	// Set stroke width
-	opts.StrokeWidth = 2
-	// If color provided
-	if col != nil {
-		// Set stroke color
-		opts.StrokeColor = col
-	} else {
-		// Set stroke color to orange primary color
-		opts.StrokeColor = theme.PrimaryColorNamed(theme.ColorOrange)
-	}
-}
-
-func getData(db *sql.DB, field, table string) []float64 {
-	// Get data from database
-	rows, err := db.Query("SELECT " + field + " FROM " + table + " ORDER BY time;")
-	if err != nil {
-		return nil
-	}
-	defer rows.Close()
-
-	var out []float64
-	for rows.Next() {
-		var val int64
-		// Scan data into int
-		err := rows.Scan(&val)
-		if err != nil {
-			return nil
-		}
-
-		// Convert to float64 and append to data slice
-		out = append(out, float64(val))
-	}
-
-	return out
-}
-
-func getMotionData(db *sql.DB) map[string][]float64 {
-	// Get data from database
-	rows, err := db.Query("SELECT X, Y, Z FROM motion ORDER BY time;")
-	if err != nil {
-		return nil
-	}
-	defer rows.Close()
-
-	out := map[string][]float64{}
-	for rows.Next() {
-		var x, y, z int64
-		// Scan data into ints
-		err := rows.Scan(&x, &y, &z)
-		if err != nil {
-			return nil
-		}
-
-		// Convert to float64 and append to appropriate slice
-		out["X"] = append(out["X"], float64(x))
-		out["Y"] = append(out["Y"], float64(y))
-		out["Z"] = append(out["Z"], float64(z))
-	}
-
-	return out
-}

cmd/itgui/info.go

@@ -1,86 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/container"
-	"go.arsenm.dev/itd/api"
-)
-
-func infoTab(ctx context.Context, client *api.Client, w fyne.Window) fyne.CanvasObject {
-	c := container.NewVBox()
-
-	// Create titled text for heart rate
-	heartRateText := newTitledText("Heart Rate", "0 BPM")
-	c.Add(heartRateText)
-	// Watch heart rate
-	heartRateCh, err := client.WatchHeartRate(ctx)
-	if err != nil {
-		guiErr(err, "Error watching heart rate", true, w)
-	}
-	go func() {
-		// For every heart rate sample
-		for heartRate := range heartRateCh {
-			// Set body of titled text
-			heartRateText.SetBody(fmt.Sprintf("%d BPM", heartRate))
-		}
-	}()
-
-	// Create titled text for battery level
-	battLevelText := newTitledText("Battery Level", "0%")
-	c.Add(battLevelText)
-	// Watch battery level
-	battLevelCh, err := client.WatchBatteryLevel(ctx)
-	if err != nil {
-		guiErr(err, "Error watching battery level", true, w)
-	}
-	go func() {
-		// For every battery level sample
-		for battLevel := range battLevelCh {
-			// Set body of titled text
-			battLevelText.SetBody(fmt.Sprintf("%d%%", battLevel))
-		}
-	}()
-
-	// Create titled text for step count
-	stepCountText := newTitledText("Step Count", "0 Steps")
-	c.Add(stepCountText)
-	// Watch step count
-	stepCountCh, err := client.WatchStepCount(ctx)
-	if err != nil {
-		guiErr(err, "Error watching step count", true, w)
-	}
-	go func() {
-		// For every step count sample
-		for stepCount := range stepCountCh {
-			// Set body of titled text
-			stepCountText.SetBody(fmt.Sprintf("%d Steps", stepCount))
-		}
-	}()
-
-	// Create new titled text for address
-	addressText := newTitledText("Address", "")
-	c.Add(addressText)
-	// Get address
-	address, err := client.Address(ctx)
-	if err != nil {
-		guiErr(err, "Error getting address", true, w)
-	}
-	// Set body of titled text
-	addressText.SetBody(address)
-
-	// Create new titled text for version
-	versionText := newTitledText("Version", "")
-	c.Add(versionText)
-	// Get version
-	version, err := client.Version(ctx)
-	if err != nil {
-		guiErr(err, "Error getting version", true, w)
-	}
-	// Set body of titled text
-	versionText.SetBody(version)
-
-	return container.NewVScroll(c)
-}

cmd/itgui/loading.go

@@ -1,21 +0,0 @@
-package main
-
-import (
-	"image/color"
-
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/canvas"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/widget"
-)
-
-func newLoadingPopUp(w fyne.Window) *widget.PopUp {
-	pb := widget.NewProgressBarInfinite()
-	rect := canvas.NewRectangle(color.Transparent)
-	rect.SetMinSize(fyne.NewSize(200, 0))
-
-	return widget.NewModalPopUp(
-		container.NewMax(rect, pb),
-		w.Canvas(),
-	)
-}

cmd/itgui/main.go

@@ -1,60 +0,0 @@
-package main
-
-import (
-	"context"
-	"sync"
-
-	"fyne.io/fyne/v2/app"
-	"fyne.io/fyne/v2/container"
-	"go.arsenm.dev/itd/api"
-)
-
-func main() {
-	a := app.New()
-	w := a.NewWindow("itgui")
-
-	// Create new context for use with the API client
-	ctx, cancel := context.WithCancel(context.Background())
-
-	// Connect to ITD API
-	client, err := api.New(api.DefaultAddr)
-	if err != nil {
-		guiErr(err, "Error connecting to ITD", true, w)
-	}
-
-	// Create channel to signal that the fs tab has been opened
-	fsOpened := make(chan struct{})
-	fsOnce := &sync.Once{}
-
-	// Create app tabs
-	tabs := container.NewAppTabs(
-		container.NewTabItem("Info", infoTab(ctx, client, w)),
-		container.NewTabItem("Motion", motionTab(ctx, client, w)),
-		container.NewTabItem("Notify", notifyTab(ctx, client, w)),
-		container.NewTabItem("FS", fsTab(ctx, client, w, fsOpened)),
-		container.NewTabItem("Time", timeTab(ctx, client, w)),
-		container.NewTabItem("Firmware", firmwareTab(ctx, client, w)),
-	)
-
-	metricsTab := graphTab(ctx, client, w)
-	if metricsTab != nil {
-		tabs.Append(container.NewTabItem("Metrics", metricsTab))
-	}
-
-	// When a tab is selected
-	tabs.OnSelected = func(ti *container.TabItem) {
-		// If the tab's name is FS
-		if ti.Text == "FS" {
-			// Signal fsOpened only once
-			fsOnce.Do(func() {
-				fsOpened <- struct{}{}
-			})
-		}
-	}
-
-	// Cancel context on close
-	w.SetOnClosed(cancel)
-	// Set content and show window
-	w.SetContent(tabs)
-	w.ShowAndRun()
-}

cmd/itgui/motion.go

@@ -1,62 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/widget"
-	"go.arsenm.dev/itd/api"
-)
-
-func motionTab(ctx context.Context, client *api.Client, w fyne.Window) fyne.CanvasObject {
-	// Create titledText for each coordinate
-	xText := newTitledText("X Coordinate", "0")
-	yText := newTitledText("Y Coordinate", "0")
-	zText := newTitledText("Z Coordinate", "0")
-
-	var ctxCancel func()
-
-	// Create start button
-	toggleBtn := widget.NewButton("Start", nil)
-	// Set button's on tapped callback
-	toggleBtn.OnTapped = func() {
-		switch toggleBtn.Text {
-		case "Start":
-			// Create new context for motion
-			motionCtx, cancel := context.WithCancel(ctx)
-			// Set ctxCancel to function so that stop button can run it
-			ctxCancel = cancel
-			// Watch motion
-			motionCh, err := client.WatchMotion(motionCtx)
-			if err != nil {
-				guiErr(err, "Error watching motion", false, w)
-				return
-			}
-			go func() {
-				// For every motion event
-				for motion := range motionCh {
-					// Set coordinates
-					xText.SetBody(fmt.Sprint(motion.X))
-					yText.SetBody(fmt.Sprint(motion.Y))
-					zText.SetBody(fmt.Sprint(motion.Z))
-				}
-			}()
-			// Set button text to "Stop"
-			toggleBtn.SetText("Stop")
-		case "Stop":
-			// Cancel motion context
-			ctxCancel()
-			// Set button text to "Start"
-			toggleBtn.SetText("Start")
-		}
-	}
-
-	return container.NewVScroll(container.NewVBox(
-		toggleBtn,
-		xText,
-		yText,
-		zText,
-	))
-}

cmd/itgui/notify.go

@@ -1,40 +0,0 @@
-package main
-
-import (
-	"context"
-
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/layout"
-	"fyne.io/fyne/v2/widget"
-	"go.arsenm.dev/itd/api"
-)
-
-func notifyTab(ctx context.Context, client *api.Client, w fyne.Window) fyne.CanvasObject {
-	c := container.NewVBox()
-	c.Add(layout.NewSpacer())
-
-	// Create new entry for title
-	titleEntry := widget.NewEntry()
-	titleEntry.SetPlaceHolder("Title")
-	c.Add(titleEntry)
-
-	// Create new multiline entry for body
-	bodyEntry := widget.NewMultiLineEntry()
-	bodyEntry.SetPlaceHolder("Body")
-	c.Add(bodyEntry)
-
-	// Create new send button
-	sendBtn := widget.NewButton("Send", func() {
-		// Send notification
-		err := client.Notify(ctx, titleEntry.Text, bodyEntry.Text)
-		if err != nil {
-			guiErr(err, "Error sending notification", false, w)
-			return
-		}
-	})
-	c.Add(sendBtn)
-
-	c.Add(layout.NewSpacer())
-	return container.NewVScroll(c)
-}

cmd/itgui/progress.go

@@ -1,64 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"image/color"
-
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/canvas"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/widget"
-)
-
-type progress struct {
-	lbl     *widget.Label
-	progLbl *widget.Label
-	pb      *widget.ProgressBar
-	*widget.PopUp
-}
-
-func newProgress(w fyne.Window) progress {
-	out := progress{}
-
-	out.lbl = widget.NewLabel("")
-	out.lbl.Hide()
-
-	// Create label to show how many bytes transfered and center it
-	out.progLbl = widget.NewLabel("0 / 0 B")
-	out.progLbl.Alignment = fyne.TextAlignCenter
-
-	// Create new progress bar
-	out.pb = widget.NewProgressBar()
-
-	// Create new rectangle to set the size of the popup
-	sizeRect := canvas.NewRectangle(color.Transparent)
-	sizeRect.SetMinSize(fyne.NewSize(300, 50))
-
-	// Create vbox for label and progress bar
-	l := container.NewVBox(out.lbl, out.progLbl, out.pb)
-	// Create popup
-	out.PopUp = widget.NewModalPopUp(container.NewMax(l, sizeRect), w.Canvas())
-
-	return out
-}
-
-func (p progress) SetText(s string) {
-	p.lbl.SetText(s)
-
-	if s == "" {
-		p.lbl.Hide()
-	} else {
-		p.lbl.Show()
-	}
-}
-
-func (p progress) SetTotal(v float64) {
-	p.pb.Max = v
-	p.pb.Refresh()
-	p.progLbl.SetText(fmt.Sprintf("%.0f / %.0f B", p.pb.Value, v))
-}
-
-func (p progress) SetValue(v float64) {
-	p.pb.SetValue(v)
-	p.progLbl.SetText(fmt.Sprintf("%.0f / %.0f B", v, p.pb.Max))
-}

cmd/itgui/time.go

@@ -1,57 +0,0 @@
-package main
-
-import (
-	"context"
-	"time"
-
-	"fyne.io/fyne/v2"
-	"fyne.io/fyne/v2/container"
-	"fyne.io/fyne/v2/layout"
-	"fyne.io/fyne/v2/widget"
-	"go.arsenm.dev/itd/api"
-)
-
-func timeTab(ctx context.Context, client *api.Client, w fyne.Window) fyne.CanvasObject {
-	c := container.NewVBox()
-	c.Add(layout.NewSpacer())
-
-	// Create entry for time string
-	timeEntry := widget.NewEntry()
-	timeEntry.SetText(time.Now().Format(time.RFC1123))
-	timeEntry.SetPlaceHolder("RFC1123")
-
-	// Create button to set current time
-	setCurrentBtn := widget.NewButton("Set current time", func() {
-		// Set current time
-		err := client.SetTime(ctx, time.Now())
-		if err != nil {
-			guiErr(err, "Error setting time", false, w)
-			return
-		}
-		// Set time entry to current time
-		timeEntry.SetText(time.Now().Format(time.RFC1123))
-	})
-
-	// Create button to set time from entry
-	setBtn := widget.NewButton("Set", func() {
-		// Parse RFC1123 time string in entry
-		newTime, err := time.Parse(time.RFC1123, timeEntry.Text)
-		if err != nil {
-			guiErr(err, "Error parsing time string", false, w)
-			return
-		}
-		// Set time from parsed string
-		err = client.SetTime(ctx, newTime)
-		if err != nil {
-			guiErr(err, "Error setting time", false, w)
-			return
-		}
-	})
-
-	c.Add(timeEntry)
-	c.Add(setBtn)
-	c.Add(setCurrentBtn)
-
-	c.Add(layout.NewSpacer())
-	return c
-}

cmd/itgui/titledText.go

@@ -1,35 +0,0 @@
-package main
-
-import "fyne.io/fyne/v2/widget"
-
-type titledText struct {
-	*widget.RichText
-}
-
-func newTitledText(title, text string) titledText {
-	titleStyle := widget.RichTextStyleHeading
-	titleStyle.TextStyle.Bold = false
-	return titledText{
-		widget.NewRichText(
-			&widget.TextSegment{
-				Style: widget.RichTextStyleParagraph,
-				Text:  title,
-			},
-			&widget.TextSegment{
-				Style: titleStyle,
-				Text:  text,
-			},
-			&widget.SeparatorSegment{},
-		),
-	}
-}
-
-func (t titledText) SetTitle(s string) {
-	t.RichText.Segments[0].(*widget.TextSegment).Text = s
-	t.Refresh()
-}
-
-func (t titledText) SetBody(s string) {
-	t.RichText.Segments[1].(*widget.TextSegment).Text = s
-	t.Refresh()
-}

config.go

@@ -1,106 +0,0 @@
-package main
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/knadh/koanf/parsers/toml"
-	"github.com/knadh/koanf/providers/confmap"
-	"github.com/knadh/koanf/providers/env"
-	"github.com/knadh/koanf/providers/file"
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
-)
-
-var cfgDir string
-
-func init() {
-	// Set up logger
-	log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr})
-
-	// Get user's configuration directory
-	userCfgDir, err := os.UserConfigDir()
-	if err != nil {
-		panic(err)
-	}
-	cfgDir = filepath.Join(userCfgDir, "itd")
-
-	// If config dir is not readable
-	if _, err = os.ReadDir(cfgDir); err != nil {
-		// Create config dir with 700 permissions
-		err = os.MkdirAll(cfgDir, 0700)
-		if err != nil {
-			panic(err)
-		}
-	}
-
-	// Get current and old config paths
-	cfgPath := filepath.Join(cfgDir, "itd.toml")
-	oldCfgPath := filepath.Join(userCfgDir, "itd.toml")
-
-	// If old config path exists
-	if _, err = os.Stat(oldCfgPath); err == nil {
-		// Move old config to new path
-		err = os.Rename(oldCfgPath, cfgPath)
-		if err != nil {
-			panic(err)
-		}
-	}
-
-	// Set config defaults
-	setCfgDefaults()
-
-	// Load config files
-	etcProvider := file.Provider("/etc/itd.toml")
-	cfgProvider := file.Provider(cfgPath)
-	k.Load(etcProvider, toml.Parser())
-	k.Load(cfgProvider, toml.Parser())
-
-	// Watch configs for changes
-	cfgWatch(etcProvider)
-	cfgWatch(cfgProvider)
-
-	// Load envireonment variables
-	k.Load(env.Provider("ITD_", "_", func(s string) string {
-		return strings.ToLower(strings.TrimPrefix(s, "ITD_"))
-	}), nil)
-}
-
-func cfgWatch(provider *file.File) {
-	// Watch for changes and reload when detected
-	provider.Watch(func(_ interface{}, err error) {
-		if err != nil {
-			return
-		}
-
-		k.Load(provider, toml.Parser())
-	})
-}
-
-func setCfgDefaults() {
-	k.Load(confmap.Provider(map[string]interface{}{
-		"bluetooth.adapter": "hci0",
-
-		"socket.path": "/tmp/itd/socket",
-
-		"conn.reconnect": true,
-
-		"conn.whitelist.enabled": false,
-		"conn.whitelist.devices": []string{},
-
-		"on.connect.notify": true,
-
-		"on.reconnect.notify":  true,
-		"on.reconnect.setTime": true,
-
-		"notifs.translit.use":    []string{"eASCII"},
-		"notifs.translit.custom": []string{},
-
-		"notifs.ignore.sender":  []string{},
-		"notifs.ignore.summary": []string{"InfiniTime"},
-		"notifs.ignore.body":    []string{},
-
-		"music.vol.interval": 5,
-	}, "."), nil)
-}

dbus.go

@@ -1,41 +0,0 @@
-package main
-
-import (
-	"context"
-
-	"github.com/godbus/dbus/v5"
-)
-
-func newSystemBusConn(ctx context.Context) (*dbus.Conn, error) {
-	// Connect to dbus session bus
-	conn, err := dbus.SystemBusPrivate(dbus.WithContext(ctx))
-	if err != nil {
-		return nil, err
-	}
-	err = conn.Auth(nil)
-	if err != nil {
-		return nil, err
-	}
-	err = conn.Hello()
-	if err != nil {
-		return nil, err
-	}
-	return conn, nil
-}
-
-func newSessionBusConn(ctx context.Context) (*dbus.Conn, error) {
-	// Connect to dbus session bus
-	conn, err := dbus.SessionBusPrivate(dbus.WithContext(ctx))
-	if err != nil {
-		return nil, err
-	}
-	err = conn.Auth(nil)
-	if err != nil {
-		return nil, err
-	}
-	err = conn.Hello()
-	if err != nil {
-		return nil, err
-	}
-	return conn, nil
-}

go.mod

@@ -1,83 +1,25 @@
 module go.arsenm.dev/itd
 
-go 1.17
-
-replace fyne.io/x/fyne => github.com/metal3d/fyne-x v0.0.0-20220508095732-177117e583fb
+go 1.16
 
 require (
-	fyne.io/fyne/v2 v2.2.3
-	fyne.io/x/fyne v0.0.0-20220107050838-c4a1de51d4ce
+	github.com/VividCortex/ewma v1.2.0 // indirect
+	github.com/abiosoft/ishell v2.0.0+incompatible
+	github.com/abiosoft/readline v0.0.0-20180607040430-155bce2042db // indirect
 	github.com/cheggaaa/pb/v3 v3.0.8
-	github.com/gen2brain/dlgs v0.0.0-20211108104213-bade24837f0b
-	github.com/godbus/dbus/v5 v5.1.0
-	github.com/knadh/koanf v1.4.0
-	github.com/mattn/go-isatty v0.0.14
-	github.com/mozillazg/go-pinyin v0.19.0
-	github.com/rs/zerolog v1.26.1
-	github.com/urfave/cli/v2 v2.4.0
-	go.arsenm.dev/infinitime v0.0.0-20221107042015-72b558707ee3
-	go.arsenm.dev/lrpc v0.0.0-20220513001344-3bcc01fdb6a0
-	golang.org/x/text v0.3.7
-	modernc.org/sqlite v1.17.2
-)
-
-require (
-	fyne.io/systray v1.10.1-0.20220621085403-9a2652634e93 // indirect
-	github.com/VividCortex/ewma v1.1.1 // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.1 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/fatih/color v1.10.0 // indirect
-	github.com/fatih/structs v1.1.0 // indirect
-	github.com/fredbi/uri v0.0.0-20181227131451-3dcfdacbaaf3 // indirect
-	github.com/fsnotify/fsnotify v1.5.4 // indirect
-	github.com/fxamacker/cbor/v2 v2.4.0 // indirect
-	github.com/fyne-io/gl-js v0.0.0-20220119005834-d2da28d9ccfe // indirect
-	github.com/fyne-io/glfw-js v0.0.0-20220120001248-ee7290d23504 // indirect
-	github.com/fyne-io/image v0.0.0-20220602074514-4956b0afb3d2 // indirect
-	github.com/go-gl/gl v0.0.0-20211210172815-726fda9656d6 // indirect
-	github.com/go-gl/glfw/v3.3/glfw v0.0.0-20211213063430-748e38ca8aec // indirect
-	github.com/gofrs/uuid v4.2.0+incompatible // indirect
-	github.com/goki/freetype v0.0.0-20220119013949-7a161fd3728c // indirect
-	github.com/google/uuid v1.3.0 // indirect
-	github.com/gopherjs/gopherjs v1.17.2 // indirect
-	github.com/jsummers/gobmp v0.0.0-20151104160322-e2ba15ffa76e // indirect
-	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
-	github.com/mattn/go-colorable v0.1.8 // indirect
+	github.com/fatih/color v1.12.0 // indirect
+	github.com/flynn-archive/go-shlex v0.0.0-20150515145356-3f9db97f8568 // indirect
+	github.com/fsnotify/fsnotify v1.5.0 // indirect
+	github.com/godbus/dbus/v5 v5.0.4
+	github.com/mattn/go-isatty v0.0.13 // indirect
 	github.com/mattn/go-runewidth v0.0.13 // indirect
-	github.com/mitchellh/copystructure v1.2.0 // indirect
-	github.com/mitchellh/mapstructure v1.5.0 // indirect
-	github.com/mitchellh/reflectwalk v1.0.2 // indirect
-	github.com/muka/go-bluetooth v0.0.0-20220819140550-1d8857e3b268 // indirect
-	github.com/pelletier/go-toml v1.9.3 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
-	github.com/rivo/uniseg v0.2.0 // indirect
-	github.com/russross/blackfriday/v2 v2.1.0 // indirect
+	github.com/mitchellh/mapstructure v1.4.1
+	github.com/rs/zerolog v1.23.0
 	github.com/sirupsen/logrus v1.8.1 // indirect
-	github.com/srwiley/oksvg v0.0.0-20220128195007-1f435e4c2b44 // indirect
-	github.com/srwiley/rasterx v0.0.0-20220128185129-2efea2b9ea41 // indirect
-	github.com/stretchr/testify v1.7.2 // indirect
-	github.com/tevino/abool v1.2.0 // indirect
-	github.com/vmihailenco/msgpack/v5 v5.3.5 // indirect
-	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
-	github.com/x448/float16 v0.8.4 // indirect
-	github.com/yuin/goldmark v1.4.10 // indirect
-	golang.org/x/image v0.0.0-20220601225756-64ec528b34cd // indirect
-	golang.org/x/mobile v0.0.0-20211207041440-4e6c2922fdee // indirect
-	golang.org/x/mod v0.4.2 // indirect
-	golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4 // indirect
-	golang.org/x/sys v0.0.0-20220412211240-33da011f77ad // indirect
-	golang.org/x/tools v0.1.8-0.20211022200916-316ba0b74098 // indirect
-	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-	honnef.co/go/js/dom v0.0.0-20210725211120-f030747120f2 // indirect
-	lukechampine.com/uint128 v1.1.1 // indirect
-	modernc.org/cc/v3 v3.36.0 // indirect
-	modernc.org/ccgo/v3 v3.16.6 // indirect
-	modernc.org/libc v1.16.7 // indirect
-	modernc.org/mathutil v1.4.1 // indirect
-	modernc.org/memory v1.1.1 // indirect
-	modernc.org/opt v0.1.1 // indirect
-	modernc.org/strutil v1.1.1 // indirect
-	modernc.org/token v1.0.0 // indirect
+	github.com/spf13/cast v1.4.1 // indirect
+	github.com/spf13/cobra v1.2.1
+	github.com/spf13/viper v1.8.1
+	go.arsenm.dev/infinitime v0.0.0-20210821070429-ea488067fb9b
+	golang.org/x/sys v0.0.0-20210820121016-41cdb8703e55 // indirect
+	golang.org/x/text v0.3.7 // indirect
 )

go.sum

@@ -37,42 +37,28 @@ cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohl
 cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
 cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-fyne.io/fyne/v2 v2.1.0/go.mod h1:c1vwI38Ebd0dAdxVa6H1Pj6/+cK1xtDy61+I31g+s14=
-fyne.io/fyne/v2 v2.2.3 h1:Umi3vVVW8XnWWPJmMkhIWQOMU/jxB1OqpWVUmjhODD0=
-fyne.io/fyne/v2 v2.2.3/go.mod h1:MBoGuHzLLSXdQOWFAwWhIhYTEMp33zqtGCReSWhaQTA=
-fyne.io/systray v1.10.1-0.20220621085403-9a2652634e93 h1:V2IC9t0Zj9Ur6qDbfhUuzVmIvXKFyxZXRJyigUvovs4=
-fyne.io/systray v1.10.1-0.20220621085403-9a2652634e93/go.mod h1:oM2AQqGJ1AMo4nNqZFYU8xYygSBZkW2hmdJ7n4yjedE=
-github.com/Andrew-M-C/go.jsonvalue v1.1.2-0.20211223013816-e873b56b4a84/go.mod h1:oTJGG91FhtsxvUFVwHSvr6zuaTcAuroj/ToxfT7Ox8U=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/BurntSushi/toml v0.4.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
-github.com/BurntSushi/toml v1.1.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/Kodeworks/golang-image-ico v0.0.0-20141118225523-73f0f4cfade9/go.mod h1:7uhhqiBaR4CpN0k9rMjOtjpcfGd6DG2m04zQxKnWQ0I=
-github.com/VividCortex/ewma v1.1.1 h1:MnEK4VOv6n0RSY4vtRe3h11qjxL3+t0B8yOL8iMXdcM=
 github.com/VividCortex/ewma v1.1.1/go.mod h1:2Tkkvm3sRDVXaiyucHiACn4cqf7DpdyLvmxzcbUokwA=
-github.com/akavel/rsrc v0.8.0/go.mod h1:uLoCtb9J+EyAqh+26kdrTgmzRBFPGOolLWKpdxkKq+c=
-github.com/akavel/rsrc v0.10.2/go.mod h1:uLoCtb9J+EyAqh+26kdrTgmzRBFPGOolLWKpdxkKq+c=
+github.com/VividCortex/ewma v1.2.0 h1:f58SaIzcDXrSy3kWaHNvuJgJ3Nmz59Zji6XoJR/q1ow=
+github.com/VividCortex/ewma v1.2.0/go.mod h1:nz4BbCtbLyFDeC9SUHbtcT5644juEuWfUAUnGx7j5l4=
+github.com/abiosoft/ishell v2.0.0+incompatible h1:zpwIuEHc37EzrsIYah3cpevrIc8Oma7oZPxr03tlmmw=
+github.com/abiosoft/ishell v2.0.0+incompatible/go.mod h1:HQR9AqF2R3P4XXpMpI0NAzgHf/aS6+zVXRj14cVk9qg=
+github.com/abiosoft/readline v0.0.0-20180607040430-155bce2042db h1:CjPUSXOiYptLbTdr1RceuZgSFDQ7U15ITERUGrUORx8=
+github.com/abiosoft/readline v0.0.0-20180607040430-155bce2042db/go.mod h1:rB3B4rKii8V21ydCbIzH5hZiCQE7f5E9SzUb/ZZx530=
 github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
 github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
 github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
 github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
-github.com/aws/aws-sdk-go-v2 v1.9.2/go.mod h1:cK/D0BBs0b/oWPIcX/Z/obahJK1TT7IPVjy53i/mX/4=
-github.com/aws/aws-sdk-go-v2/config v1.8.3/go.mod h1:4AEiLtAb8kLs7vgw2ZV3p2VZ1+hBavOc84hqxVNpCyw=
-github.com/aws/aws-sdk-go-v2/credentials v1.4.3/go.mod h1:FNNC6nQZQUuyhq5aE5c7ata8o9e4ECGmS4lAXC7o1mQ=
-github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.6.0/go.mod h1:gqlclDEZp4aqJOancXK6TN24aKhT0W0Ae9MHk3wzTMM=
-github.com/aws/aws-sdk-go-v2/internal/ini v1.2.4/go.mod h1:ZcBrrI3zBKlhGFNYWvju0I3TR93I7YIgAfy82Fh4lcQ=
-github.com/aws/aws-sdk-go-v2/service/appconfig v1.4.2/go.mod h1:FZ3HkCe+b10uFZZkFdvf98LHW21k49W8o8J366lqVKY=
-github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.3.2/go.mod h1:72HRZDLMtmVQiLG2tLfQcaWLCssELvGl+Zf2WVxMmR8=
-github.com/aws/aws-sdk-go-v2/service/sso v1.4.2/go.mod h1:NBvT9R1MEF+Ud6ApJKM0G+IkPchKS7p7c2YPKwHmBOk=
-github.com/aws/aws-sdk-go-v2/service/sts v1.7.2/go.mod h1:8EzeIqfWt2wWT4rJVu3f21TfrhJ8AEMzVybRNSb/b4g=
-github.com/aws/smithy-go v1.8.0/go.mod h1:SObp3lf9smib00L/v3U2eAKG8FyQ7iLrJnQiAmR5n+E=
 github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
 github.com/bketelsen/crypt v0.0.4/go.mod h1:aI6NrJ0pMGgvZKL1iVgXLnfIFJtfV+bKCoqOes/6LfM=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cheggaaa/pb/v3 v3.0.8 h1:bC8oemdChbke2FHIIGy9mn4DPJ2caZYQnfbRqwmdCoA=
 github.com/cheggaaa/pb/v3 v3.0.8/go.mod h1:UICbiLec/XO6Hw6k+BHEtHeQFzzBH4i2/qk/ow1EJTA=
+github.com/chzyer/logex v1.1.10 h1:Swpa1K6QvQznwJRcfTfQJmTE72DqScAa40E+fbHEXEE=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1 h1:q763qf9huN11kDQavWsoZXJNW3xEE4JJyHa5Q25/sd8=
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
@@ -80,16 +66,10 @@ github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnht
 github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
 github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
-github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
-github.com/cpuguy83/go-md2man/v2 v2.0.1 h1:r/myEWzV9lfsM1tFLgDyu0atFtJ1fXn261LKYj/3DxU=
-github.com/cpuguy83/go-md2man/v2 v2.0.1/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
-github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
-github.com/eclipse/paho.mqtt.golang v1.3.5/go.mod h1:eTzb4gxwwyWpqBUHGQZ4ABAV7+Jgm1PklsYT/eo8Hcc=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
@@ -98,51 +78,24 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.m
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fatih/color v1.10.0 h1:s36xzo75JdqLaaWoiEHk767eHiwo0598uUxyfiPkDsg=
 github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
+github.com/fatih/color v1.12.0 h1:mRhaKNwANqRgUBGKmnI5ZxEk7QXmjQeCcuYFMX2bfcc=
+github.com/fatih/color v1.12.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
 github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
-github.com/fredbi/uri v0.0.0-20181227131451-3dcfdacbaaf3 h1:FDqhDm7pcsLhhWl1QtD8vlzI4mm59llRvNzrFg6/LAA=
-github.com/fredbi/uri v0.0.0-20181227131451-3dcfdacbaaf3/go.mod h1:CzM2G82Q9BDUvMTGHnXf/6OExw/Dz2ivDj48nVg7Lg8=
+github.com/flynn-archive/go-shlex v0.0.0-20150515145356-3f9db97f8568 h1:BMXYYRWTLOJKlh+lOBt6nUQgXAfB7oVIQt5cNreqSLI=
+github.com/flynn-archive/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:rZfgFAXFS/z/lEd6LJmf9HVZ1LkgYiHx5pHhV5DR16M=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
-github.com/fsnotify/fsnotify v1.5.4 h1:jRbGcIw6P2Meqdwuo0H1p6JVLbL5DHKAKlYndzMwVZI=
-github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU=
-github.com/fxamacker/cbor/v2 v2.4.0 h1:ri0ArlOR+5XunOP8CRUowT0pSJOwhW098ZCUyskZD88=
-github.com/fxamacker/cbor/v2 v2.4.0/go.mod h1:TA1xS00nchWmaBnEIxPSE5oHLuJBAVvqrtAnWBwBCVo=
-github.com/fyne-io/gl-js v0.0.0-20220119005834-d2da28d9ccfe h1:A/wiwvQ0CAjPkuJytaD+SsXkPU0asQ+guQEIg1BJGX4=
-github.com/fyne-io/gl-js v0.0.0-20220119005834-d2da28d9ccfe/go.mod h1:d4clgH0/GrRwWjRzJJQXxT/h1TyuNSfF/X64zb/3Ggg=
-github.com/fyne-io/glfw-js v0.0.0-20220120001248-ee7290d23504 h1:+31CdF/okdokeFNoy9L/2PccG3JFidQT3ev64/r4pYU=
-github.com/fyne-io/glfw-js v0.0.0-20220120001248-ee7290d23504/go.mod h1:gLRWYfYnMA9TONeppRSikMdXlHQ97xVsPojddUv3b/E=
-github.com/fyne-io/image v0.0.0-20220602074514-4956b0afb3d2 h1:hnLq+55b7Zh7/2IRzWCpiTcAvjv/P8ERF+N7+xXbZhk=
-github.com/fyne-io/image v0.0.0-20220602074514-4956b0afb3d2/go.mod h1:eO7W361vmlPOrykIg+Rsh1SZ3tQBaOsfzZhsIOb/Lm0=
-github.com/gen2brain/dlgs v0.0.0-20211108104213-bade24837f0b h1:M0/hjawi9ur15zpqL/h66ga87jlYA7iAuZ4HC6ak08k=
-github.com/gen2brain/dlgs v0.0.0-20211108104213-bade24837f0b/go.mod h1:/eFcjDXaU2THSOOqLxOPETIbHETnamk8FA/hMjhg/gU=
+github.com/fsnotify/fsnotify v1.5.0 h1:NO5hkcB+srp1x6QmwvNZLeaOgbM8cmBTN32THzjvu2k=
+github.com/fsnotify/fsnotify v1.5.0/go.mod h1:BX0DCEr5pT4jm2CnQdVP1lFV521fcCNcyEeNp4DQQDk=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/go-gl/gl v0.0.0-20210813123233-e4099ee2221f/go.mod h1:wjpnOv6ONl2SuJSxqCPVaPZibGFdSci9HFocT9qtVYM=
-github.com/go-gl/gl v0.0.0-20211210172815-726fda9656d6 h1:zDw5v7qm4yH7N8C8uWd+8Ii9rROdgWxQuGoJ9WDXxfk=
-github.com/go-gl/gl v0.0.0-20211210172815-726fda9656d6/go.mod h1:9YTyiznxEY1fVinfM7RvRcjRHbw2xLBJ3AAGIT0I4Nw=
-github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1 h1:QbL/5oDUmRBzO9/Z7Seo6zf912W/a6Sr4Eu0G/3Jho0=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20210410170116-ea3d685f79fb/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20211213063430-748e38ca8aec h1:3FLiRYO6PlQFDpUU7OEFlWgjGD1jnBIVSJ5SYRWk+9c=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20211213063430-748e38ca8aec/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-ldap/ldap v3.0.2+incompatible/go.mod h1:qfd9rJvER9Q0/D/Sqn1DfHRoBp40uXYvFoEVrNEPqRc=
-github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
-github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
-github.com/go-test/deep v1.0.2-0.20181118220953-042da051cf31/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
 github.com/godbus/dbus/v5 v5.0.3/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/godbus/dbus/v5 v5.0.4 h1:9349emZab16e7zQvpmsbtjc18ykshndd8y2PG3sgJbA=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/godbus/dbus/v5 v5.0.6/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk=
-github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/gofrs/uuid v4.2.0+incompatible h1:yyYWMnhkhrKwwr8gAOcOCYxOOscHgDS9yZgBrnJfGa0=
-github.com/gofrs/uuid v4.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
-github.com/goki/freetype v0.0.0-20181231101311-fa8a33aabaff/go.mod h1:wfqRWLHRBsRgkp5dmbG56SA0DmVtwrF5N3oPdI8t+Aw=
-github.com/goki/freetype v0.0.0-20220119013949-7a161fd3728c h1:JGCm/+tJ9gC6THUxooTldS+CUDsba0qvkvU3DHklqW8=
-github.com/goki/freetype v0.0.0-20220119013949-7a161fd3728c/go.mod h1:wfqRWLHRBsRgkp5dmbG56SA0DmVtwrF5N3oPdI8t+Aw=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
@@ -172,7 +125,6 @@ github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
@@ -186,8 +138,6 @@ github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
-github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
 github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
@@ -206,38 +156,23 @@ github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLe
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
 github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
-github.com/gopherjs/gopherjs v0.0.0-20211219123610-ec9572f70e60/go.mod h1:cz9oNYuRUWGdHmLF2IodMLkAhcPtXeULvcBNagUrxTI=
-github.com/gopherjs/gopherjs v1.17.2 h1:fQnZVsXk8uxXIStYb0N4bGk7jeyTalG/wsZjQ25dO0g=
-github.com/gopherjs/gopherjs v1.17.2/go.mod h1:pRRIvn/QzFLrKfvEz3qUuEhtE/zLCWfreZ6J5gM2i+k=
-github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/goxjs/gl v0.0.0-20210104184919-e3fafc6f8f2a/go.mod h1:dy/f2gjY09hwVfIyATps4G2ai7/hLwLkc5TrPqONuXY=
-github.com/goxjs/glfw v0.0.0-20191126052801-d2efb5f20838/go.mod h1:oS8P8gVOT4ywTcjV6wZlOU4GuVFQ8F5328KY3MJ79CY=
 github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
 github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q=
 github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
-github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
 github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
-github.com/hashicorp/go-hclog v0.0.0-20180709165350-ff2cf002a8dd/go.mod h1:9bjs9uLqI8l75knNv3lV1kA55veR+WUPSiKIWcQHudI=
-github.com/hashicorp/go-hclog v0.8.0/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ=
 github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
 github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
 github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
-github.com/hashicorp/go-plugin v1.0.1/go.mod h1:++UyYGoz3o5w9ZzAdZxtQKrWWP+iqPBn3cQptSMzBuY=
-github.com/hashicorp/go-retryablehttp v0.5.4/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs=
 github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU=
-github.com/hashicorp/go-rootcerts v1.0.1/go.mod h1:pqUvnprVnM5bf7AOirdbb01K4ccR319Vf4pU3K5EGc8=
 github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
-github.com/hashicorp/go-sockaddr v1.0.2/go.mod h1:rB4wwRAUzs07qva3c5SdrY/NEtAUjGlgmH/UkBUC97A=
 github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4=
 github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
 github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
-github.com/hashicorp/go-version v1.1.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
@@ -247,98 +182,56 @@ github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO
 github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
 github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
 github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
-github.com/hashicorp/vault/api v1.0.4/go.mod h1:gDcqh3WGcR1cpF5AJz/B1UFheUEneMoIospckxBxk6Q=
-github.com/hashicorp/vault/sdk v0.1.13/go.mod h1:B+hVj7TpuQY1Y/GPbCpffmgd+tSEwvhkWnjtSYCaS2M=
-github.com/hashicorp/yamux v0.0.0-20180604194846-3520598351bb/go.mod h1:+NfK9FKeTrX5uv1uIXGdwYDTeHna2qgaIlx54MXqjAM=
-github.com/hashicorp/yamux v0.0.0-20181012175058-2f1d1f20f75d/go.mod h1:+NfK9FKeTrX5uv1uIXGdwYDTeHna2qgaIlx54MXqjAM=
 github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/jackmordaunt/icns v0.0.0-20181231085925-4f16af745526/go.mod h1:UQkeMHVoNcyXYq9otUupF7/h/2tmHlhrS2zw7ZVvUqc=
-github.com/jackmordaunt/icns/v2 v2.2.1/go.mod h1:6aYIB9eSzyfHHMKqDf17Xrs1zetQPReAkiUSHzdw4cI=
-github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
-github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
-github.com/joho/godotenv v1.3.0 h1:Zjp+RcGpHhGlrMbJzXTrZZPrWj+1vfm90La1wgB6Bhc=
-github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg=
-github.com/josephspurrier/goversioninfo v0.0.0-20200309025242-14b0ab84c6ca/go.mod h1:eJTEwMjXb7kZ633hO3Ln9mBUCOjX2+FlTljvpl9SYdE=
-github.com/josephspurrier/goversioninfo v1.4.0/go.mod h1:JWzv5rKQr+MmW+LvM412ToT/IkYDZjaclF2pKDss8IY=
 github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
 github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
-github.com/jsummers/gobmp v0.0.0-20151104160322-e2ba15ffa76e h1:LvL4XsI70QxOGHed6yhQtAU34Kx3Qq2wwBzGFKY8zKk=
-github.com/jsummers/gobmp v0.0.0-20151104160322-e2ba15ffa76e/go.mod h1:kLgvv7o6UM+0QSf0QjAse3wReFDsb9qbZJdfexWlrQw=
+github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
-github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
-github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/knadh/koanf v1.4.0 h1:/k0Bh49SqLyLNfte9r6cvuZWrApOQhglOmhIU3L/zDw=
-github.com/knadh/koanf v1.4.0/go.mod h1:1cfH5223ZeZUOs8FU2UdTmaNfHpqgtjV0+NHjRO43gs=
 github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/lucor/goinfo v0.0.0-20210802170112-c078a2b0f08b/go.mod h1:PRq09yoB+Q2OJReAmwzKivcYyremnibWGbK7WfftHzc=
+github.com/magiconair/properties v1.8.5 h1:b6kJs+EmPFMYGkow9GiUyCyOvIwYetYJ3fSaWak/Gls=
 github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
 github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
-github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
+github.com/mattn/go-isatty v0.0.13 h1:qdl+GuBjcsKKDco5BsxPJlId98mSWNKqYA+Co0SC1yA=
+github.com/mattn/go-isatty v0.0.13/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
 github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU=
 github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/mattn/go-sqlite3 v1.14.12 h1:TJ1bhYJPV44phC+IMu1u2K/i5RriLTPe+yc68XDJ1Z0=
-github.com/mattn/go-sqlite3 v1.14.12/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
-github.com/mcuadros/go-version v0.0.0-20190830083331-035f6764e8d2/go.mod h1:76rfSfYPWj01Z85hUf/ituArm797mNKcvINh1OlsZKo=
-github.com/metal3d/fyne-x v0.0.0-20220508095732-177117e583fb h1:+fP6ENsbd+BUOmD/kSjNtrOmi2vgJ/JfWDSWjTKmTVY=
-github.com/metal3d/fyne-x v0.0.0-20220508095732-177117e583fb/go.mod h1:jBspDudEQ+Rdono8vBGHDtMUPE8ZpB/xq7FUYRqT3CI=
 github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
 github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
-github.com/mitchellh/copystructure v1.0.0/go.mod h1:SNtv71yrdKgLRyLFxmLdkAbkKEFWgYaq1OVrnRcwhnw=
-github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw=
-github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s=
 github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/mitchellh/go-testing-interface v0.0.0-20171004221916-a61a99592b77/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
 github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
-github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
 github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg=
 github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
 github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/mitchellh/mapstructure v1.4.1 h1:CpVNEelQCZBooIPDn+AR3NpivK/TIKU8bDxdASFVQag=
 github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
-github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/mitchellh/reflectwalk v1.0.0/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
-github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ=
-github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
-github.com/mozillazg/go-pinyin v0.19.0 h1:p+J8/kjJ558KPvVGYLvqBhxf8jbZA2exSLCs2uUVN8c=
-github.com/mozillazg/go-pinyin v0.19.0/go.mod h1:iR4EnMMRXkfpFVV5FMi4FNB6wGq9NV6uDWbUuPhP4Yc=
-github.com/muka/go-bluetooth v0.0.0-20220819140550-1d8857e3b268 h1:kOnq7TfaAO2Vc/MHxPqFIXe00y1qBxJAvhctXdko6vo=
-github.com/muka/go-bluetooth v0.0.0-20220819140550-1d8857e3b268/go.mod h1:dMCjicU6vRBk34dqOmIZm0aod6gUwZXOXzBROqGous0=
-github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJEU3ofeGjhHklVoIGuVj85JJwZ6kWPaJwCIxgnFmo=
-github.com/neelance/sourcemap v0.0.0-20200213170602-2833bce08e4c/go.mod h1:Qr6/a/Q4r9LP1IltGz7tA7iOK1WonHEYhu1HRBA7ZiM=
-github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
+github.com/muka/go-bluetooth v0.0.0-20210812063148-b6c83362e27d h1:EG/xyWjHT19rkUpwsWSkyiCCmyqNwFovr9m10rhyOxU=
+github.com/muka/go-bluetooth v0.0.0-20210812063148-b6c83362e27d/go.mod h1:dMCjicU6vRBk34dqOmIZm0aod6gUwZXOXzBROqGous0=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
-github.com/npillmayer/nestext v0.1.3/go.mod h1:h2lrijH8jpicr25dFY+oAJLyzlya6jhnuG+zWp9L0Uk=
-github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA=
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
-github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/paypal/gatt v0.0.0-20151011220935-4ae819d591cf/go.mod h1:+AwQL2mK3Pd3S+TUwg0tYQjid0q1txyNUJuuSmz8Kdk=
-github.com/pelletier/go-toml v1.7.0/go.mod h1:vwGMzjaWMwyfHwgIBhI2YUM4fB6nL6lVAvS1LBMMhTE=
 github.com/pelletier/go-toml v1.9.3 h1:zeC5b1GviRUyKYd6OJPvBU/mcVDVoL1OhT17FCt5dSQ=
 github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
-github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI=
@@ -346,86 +239,56 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 h1:OdAsTTz6OkFY5QxjkYwrChwuRruF69c169dPK26NUlk=
-github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
-github.com/rhnvrm/simples3 v0.6.1/go.mod h1:Y+3vYm2V7Y4VijFoJHHTrja6OgPrJ2cBti8dPGkC3sA=
 github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/rs/xid v1.3.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.26.1 h1:/ihwxqH+4z8UxyI70wM1z9yCvkWcfz/a3mj48k/Zngc=
-github.com/rs/zerolog v1.26.1/go.mod h1:/wSSJWX7lVrsOwlbyTRSOJvqRlc+WjWlfes+CiJ+tmc=
+github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
+github.com/rs/zerolog v1.23.0 h1:UskrK+saS9P9Y789yNNulYKdARjPZuS35B8gJF2x60g=
+github.com/rs/zerolog v1.23.0/go.mod h1:6c7hFfxPOy7TacJc4Fcdi24/J0NKYGzjG8FWRI916Qo=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
-github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
-github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
-github.com/ryanuber/go-glob v1.0.0/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
-github.com/shurcooL/go v0.0.0-20200502201357-93f07166e636/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk=
-github.com/shurcooL/httpfs v0.0.0-20190707220628-8d4bc4ba7749/go.mod h1:ZY1cvUeJuFPAdZ/B6v7RHavJWZn2YPVFQ1OSXhCGOkg=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
-github.com/shurcooL/vfsgen v0.0.0-20200824052919-0d455de96546/go.mod h1:TrYk7fJVaAttu97ZZKrO9UbRa8izdowaMIZcxYMbVaw=
 github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
 github.com/sirupsen/logrus v1.8.1 h1:dJKuHgqk1NNQlqoA6BTlM1Wf9DOH3NBjQyu0h9+AZZE=
 github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s=
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
-github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
+github.com/spf13/afero v1.6.0 h1:xoax2sJ2DT8S8xA2paPFjDCScCNeWsg75VG0DLRreiY=
 github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I=
 github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cast v1.4.1 h1:s0hze+J0196ZfEMTs80N7UlFt0BDuQ7Q+JDnHiMWKdA=
+github.com/spf13/cast v1.4.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cobra v1.2.1 h1:+KmjbUw1hriSNMF55oPrkZcb27aECyrj8V2ytv7kWDw=
 github.com/spf13/cobra v1.2.1/go.mod h1:ExllRjgxM/piMAM+3tAZvg8fsklGAf3tPfi+i8t68Nk=
+github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk=
 github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
-github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.8.1 h1:Kq1fyeebqsBfbjZj4EL7gj2IO0mMaiyjYUWcUsl2O44=
 github.com/spf13/viper v1.8.1/go.mod h1:o0Pch8wJ9BVSWGQMbra6iw0oQ5oktSIBaujf1rJH9Ns=
-github.com/srwiley/oksvg v0.0.0-20200311192757-870daf9aa564/go.mod h1:afMbS0qvv1m5tfENCwnOdZGOF8RGR/FsZ7bvBxQGZG4=
-github.com/srwiley/oksvg v0.0.0-20220128195007-1f435e4c2b44 h1:XPYXKIuH/n5zpUoEWk2jWV/SjEMNYmqDYmTgbjmhtaI=
-github.com/srwiley/oksvg v0.0.0-20220128195007-1f435e4c2b44/go.mod h1:cNQ3dwVJtS5Hmnjxy6AgTPd0Inb3pW05ftPSX7NZO7Q=
-github.com/srwiley/rasterx v0.0.0-20200120212402-85cb7272f5e9/go.mod h1:mvWM0+15UqyrFKqdRjY6LuAVJR0HOVhJlEgZ5JWtSWU=
-github.com/srwiley/rasterx v0.0.0-20210519020934-456a8d69b780/go.mod h1:mvWM0+15UqyrFKqdRjY6LuAVJR0HOVhJlEgZ5JWtSWU=
-github.com/srwiley/rasterx v0.0.0-20220128185129-2efea2b9ea41 h1:YR16ysw3I1bqwtEcYV9dpvhHEe7j55hIClkLoAqY31I=
-github.com/srwiley/rasterx v0.0.0-20220128185129-2efea2b9ea41/go.mod h1:nXTWP6+gD5+LUJ8krVhhoeHjvHTutPxMYl5SvkcnJNE=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.2 h1:4jaiDzPyXQvSd7D0EjG45355tLlV3VOECpq10pLC+8s=
-github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
 github.com/suapapa/go_eddystone v1.3.1/go.mod h1:bXC11TfJOS+3g3q/Uzd7FKd5g62STQEfeEIhcKe4Qy8=
+github.com/subosito/gotenv v1.2.0 h1:Slr1R9HxAlEKefgq5jn9U+DnETlIUa6HfgEzj0g5d7s=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
-github.com/tevino/abool v1.2.0 h1:heAkClL8H6w+mK5md9dzsuohKeXHUpY7Vw0ZCKW+huA=
-github.com/tevino/abool v1.2.0/go.mod h1:qc66Pna1RiIsPa7O4Egxxs9OqkuxDX55zznh9K07Tzg=
-github.com/urfave/cli/v2 v2.3.0/go.mod h1:LJmUH05zAU44vOAcrfzZQKsZbVcdbOG8rtL3/XcUArI=
-github.com/urfave/cli/v2 v2.4.0 h1:m2pxjjDFgDxSPtO8WSdbndj17Wu2y8vOT86wE/tjr+I=
-github.com/urfave/cli/v2 v2.4.0/go.mod h1:NX9W0zmTvedE5oDoOMs2RTC8RvdK98NTYZE5LbaEYPg=
-github.com/vmihailenco/msgpack/v5 v5.3.5 h1:5gO0H1iULLWGhs2H5tbAHIZTV8/cYafcFOr9znI5mJU=
-github.com/vmihailenco/msgpack/v5 v5.3.5/go.mod h1:7xyJ9e+0+9SaZT0Wt1RGleJXzli6Q/V5KbhBonMG9jc=
-github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
-github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
-github.com/wagslane/go-password-validator v0.3.0/go.mod h1:TI1XJ6T5fRdRnHqHt14pvy1tNVnrwe7m3/f1f2fDphQ=
-github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
-github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-github.com/yuin/goldmark v1.3.8/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-github.com/yuin/goldmark v1.4.0/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-github.com/yuin/goldmark v1.4.10 h1:+WgKGo8CQrlMTRJpGCFCyNddOhW801TKC2QijVV9QVg=
-github.com/yuin/goldmark v1.4.10/go.mod h1:rmuwmfZ0+bvzB24eSC//bk1R1Zp3hM0OXYv/G2LIilg=
-go.arsenm.dev/infinitime v0.0.0-20221107042015-72b558707ee3 h1:BfZkb41Gq6h9gy5Cg5jDd5hEk9kI27/h+EX0KN3qZv8=
-go.arsenm.dev/infinitime v0.0.0-20221107042015-72b558707ee3/go.mod h1:K3NJ6fyPv5qqHUedB3MccKOE0whJMJZ80l/yTzzTrgc=
-go.arsenm.dev/lrpc v0.0.0-20220513001344-3bcc01fdb6a0 h1:1K96g1eww+77GeGchwMhd0NTrs7Mk/Hc3M3ItW5NbG4=
-go.arsenm.dev/lrpc v0.0.0-20220513001344-3bcc01fdb6a0/go.mod h1:goK9z735lfXmqlDxu9qN7FS8t0HJHN3PjyDtCToUY4w=
+go.arsenm.dev/infinitime v0.0.0-20210821070429-ea488067fb9b h1:Wwj7F0gqYHUx+9H8fCCIy5JZTlCusJRpPuzeSFM0EoU=
+go.arsenm.dev/infinitime v0.0.0-20210821070429-ea488067fb9b/go.mod h1:gaepaueUz4J5FfxuV19B4w5pi+V3mD0LTef50ryxr/Q=
 go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs=
 go.etcd.io/etcd/client/pkg/v3 v3.5.0/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g=
 go.etcd.io/etcd/client/v2 v2.305.0/go.mod h1:h9puh54ZTgAKtEbut2oe9P4L/oqKCVB6xsXlzd7alYQ=
@@ -446,12 +309,9 @@ golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.0.0-20211215165025-cf75a172585e/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
-golang.org/x/exp v0.0.0-20190731235908-ec7cb31e5a56/go.mod h1:JhuoJpWY28nO4Vef9tZUw9qufEGTyX1+7lmHxV5q5G4=
 golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
 golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
 golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
@@ -461,10 +321,6 @@ golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EH
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.0.0-20200430140353-33d19683fad8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.0.0-20211028202545-6944b10bf410/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM=
-golang.org/x/image v0.0.0-20220601225756-64ec528b34cd h1:9NbNcTg//wfC5JskFW4Z3sqwVnjmJKHxLAol1bW2qgw=
-golang.org/x/image v0.0.0-20220601225756-64ec528b34cd/go.mod h1:doUCurBvlfPMKfmIpRIywoHmhN3VyhnoFDbvIEWF4hY=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
 golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
@@ -479,8 +335,6 @@ golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPI
 golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
 golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
 golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
-golang.org/x/mobile v0.0.0-20211207041440-4e6c2922fdee h1:/tShaw8UTf0XzI8DOZwQHzC7d6Vi3EtrBnftiZ4vAvU=
-golang.org/x/mobile v0.0.0-20211207041440-4e6c2922fdee/go.mod h1:pe2sM7Uk+2Su1y7u/6Z8KJ24D7lepUjFZbhFOrmDfuQ=
 golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
 golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
@@ -489,7 +343,6 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.4.2 h1:Gz96sIWK3OalVv/I/qNygP42zyoKp3xptRVCWRFEBvo=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -512,7 +365,6 @@ golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLL
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200425230154-ff2c4b7c35a0/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
@@ -528,10 +380,6 @@ golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20211118161319-6a13c67c3ce4/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4 h1:HVyaeDAYux4pnY+D/SiwmLOR36ewZ4iGQIIrtnuCjFA=
-golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -558,10 +406,8 @@ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190129075346-302c3dd5f1cc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -569,7 +415,6 @@ golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -602,27 +447,18 @@ golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220412211240-33da011f77ad h1:ntjMns5wyP/fN65tdBD4g8J5w8n015+iIIs9rtjXkY0=
-golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210820121016-41cdb8703e55 h1:rw6UNGRMfarCepjI8qOepea/SXwIBVfTKjztZ5gBbq4=
+golang.org/x/sys v0.0.0-20210820121016-41cdb8703e55/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.1-0.20181227161524-e6919f6577db/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -674,21 +510,15 @@ golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc
 golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
 golang.org/x/tools v0.0.0-20200925191224-5d1fdd8fa346/go.mod h1:z6u4i615ZeAfBE4XtMziQW1fSVJXACjjbWkB/mvPzlU=
 golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.0.0-20201124115921-2c860bdd6e78/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
 golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.7/go.mod h1:LGqMHiF4EqQNHR1JncWGqT5BVaXmza+X+BDGol+dOxo=
-golang.org/x/tools v0.1.8-0.20211022200916-316ba0b74098 h1:YuekqPskqwCCPM79F1X5Dhv4ezTCj+Ki1oNwiafxkA0=
-golang.org/x/tools v0.1.8-0.20211022200916-316ba0b74098/go.mod h1:LGqMHiF4EqQNHR1JncWGqT5BVaXmza+X+BDGol+dOxo=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
 google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
@@ -721,7 +551,6 @@ google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCID
 google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190404172233-64821d5d2107/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
@@ -761,11 +590,9 @@ google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6D
 google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A=
 google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
-google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
-google.golang.org/grpc v1.22.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
 google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
 google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
 google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
@@ -795,25 +622,21 @@ google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGj
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-gopkg.in/asn1-ber.v1 v1.0.0-20181015200546-f715ec2f112d/go.mod h1:cuepJuh7vyXfUyUwEgHQXw849cJrilpS5NeIjOWESAw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
 gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/ini.v1 v1.62.0 h1:duBzk771uxoUuOlyRLkHsygud9+5lrlGjdFBb4mSKDU=
 gopkg.in/ini.v1 v1.62.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
-gopkg.in/square/go-jose.v2 v2.3.1/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-honnef.co/go/js/dom v0.0.0-20210725211120-f030747120f2 h1:oomkgU6VaQDsV6qZby2uz1Lap0eXmku8+2em3A/l700=
-honnef.co/go/js/dom v0.0.0-20210725211120-f030747120f2/go.mod h1:sUMDUKNB2ZcVjt92UnLy3cdGs+wDAcrPdV3JP6sVgA4=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
@@ -821,41 +644,6 @@ honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWh
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
 honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
 honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
-lukechampine.com/uint128 v1.1.1 h1:pnxCASz787iMf+02ssImqk6OLt+Z5QHMoZyUXR4z6JU=
-lukechampine.com/uint128 v1.1.1/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk=
-modernc.org/cc/v3 v3.36.0 h1:0kmRkTmqNidmu3c7BNDSdVHCxXCkWLmWmCIVX4LUboo=
-modernc.org/cc/v3 v3.36.0/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI=
-modernc.org/ccgo/v3 v3.0.0-20220428102840-41399a37e894/go.mod h1:eI31LL8EwEBKPpNpA4bU1/i+sKOwOrQy8D87zWUcRZc=
-modernc.org/ccgo/v3 v3.0.0-20220430103911-bc99d88307be/go.mod h1:bwdAnOoaIt8Ax9YdWGjxWsdkPcZyRPHqrOvJxaKAKGw=
-modernc.org/ccgo/v3 v3.16.4/go.mod h1:tGtX0gE9Jn7hdZFeU88slbTh1UtCYKusWOoCJuvkWsQ=
-modernc.org/ccgo/v3 v3.16.6 h1:3l18poV+iUemQ98O3X5OMr97LOqlzis+ytivU4NqGhA=
-modernc.org/ccgo/v3 v3.16.6/go.mod h1:tGtX0gE9Jn7hdZFeU88slbTh1UtCYKusWOoCJuvkWsQ=
-modernc.org/ccorpus v1.11.6 h1:J16RXiiqiCgua6+ZvQot4yUuUy8zxgqbqEEUuGPlISk=
-modernc.org/ccorpus v1.11.6/go.mod h1:2gEUTrWqdpH2pXsmTM1ZkjeSrUWDpjMu2T6m29L/ErQ=
-modernc.org/httpfs v1.0.6 h1:AAgIpFZRXuYnkjftxTAZwMIiwEqAfk8aVB2/oA6nAeM=
-modernc.org/httpfs v1.0.6/go.mod h1:7dosgurJGp0sPaRanU53W4xZYKh14wfzX420oZADeHM=
-modernc.org/libc v0.0.0-20220428101251-2d5f3daf273b/go.mod h1:p7Mg4+koNjc8jkqwcoFBJx7tXkpj00G77X7A72jXPXA=
-modernc.org/libc v1.16.0/go.mod h1:N4LD6DBE9cf+Dzf9buBlzVJndKr/iJHG97vGLHYnb5A=
-modernc.org/libc v1.16.1/go.mod h1:JjJE0eu4yeK7tab2n4S1w8tlWd9MxXLRzheaRnAKymU=
-modernc.org/libc v1.16.7 h1:qzQtHhsZNpVPpeCu+aMIQldXeV1P0vRhSqCL0nOIJOA=
-modernc.org/libc v1.16.7/go.mod h1:hYIV5VZczAmGZAnG15Vdngn5HSF5cSkbvfz2B7GRuVU=
-modernc.org/mathutil v1.2.2/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
-modernc.org/mathutil v1.4.1 h1:ij3fYGe8zBF4Vu+g0oT7mB06r8sqGWKuJu1yXeR4by8=
-modernc.org/mathutil v1.4.1/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
-modernc.org/memory v1.1.1 h1:bDOL0DIDLQv7bWhP3gMvIrnoFw+Eo6F7a2QK9HPDiFU=
-modernc.org/memory v1.1.1/go.mod h1:/0wo5ibyrQiaoUoH7f9D8dnglAmILJ5/cxZlRECf+Nw=
-modernc.org/opt v0.1.1 h1:/0RX92k9vwVeDXj+Xn23DKp2VJubL7k8qNffND6qn3A=
-modernc.org/opt v0.1.1/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0=
-modernc.org/sqlite v1.17.2 h1:TjmF36Wi5QcPYqRoAacV1cAyJ7xB/CD0ExpVUEMebnw=
-modernc.org/sqlite v1.17.2/go.mod h1:GOQmuiXd6pTTes1Fi2s9apiCcD/wbKQtBZ0Nw6/etjM=
-modernc.org/strutil v1.1.1 h1:xv+J1BXY3Opl2ALrBwyfEikFAj8pmqcpnfmuwUwcozs=
-modernc.org/strutil v1.1.1/go.mod h1:DE+MQQ/hjKBZS2zNInV5hhcipt5rLPWkmpbGeW5mmdw=
-modernc.org/tcl v1.13.1 h1:npxzTwFTZYM8ghWicVIX1cRWzj7Nd8i6AqqX2p+IYao=
-modernc.org/tcl v1.13.1/go.mod h1:XOLfOwzhkljL4itZkK6T72ckMgvj0BDsnKNdZVUOecw=
-modernc.org/token v1.0.0 h1:a0jaWiNMDhDUtqOj09wvjWWAqd3q7WpBulmL9H2egsk=
-modernc.org/token v1.0.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
-modernc.org/z v1.5.1 h1:RTNHdsrOpeoSeOF4FbzTo8gBYByaJ5xT7NgZ9ZqRiJM=
-modernc.org/z v1.5.1/go.mod h1:eWFB510QWW5Th9YGZT81s+LwvaAs3Q2yr4sP0rmLkv8=
 rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
 rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
 rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=

internal/types/types.go

@@ -0,0 +1,22 @@
+package types
+
+type ReqDataFwUpgrade struct {
+	Type  int
+	Files []string
+}
+
+type Response struct {
+	Value   interface{} `json:"value,omitempty"`
+	Message string      `json:"msg,omitempty"`
+	Error   bool        `json:"error"`
+}
+
+type Request struct {
+	Type string      `json:"type"`
+	Data interface{} `json:"data,omitempty"`
+}
+
+type ReqDataNotify struct {
+	Title string
+	Body  string
+}

itd.toml

@@ -1,53 +1,14 @@
-[bluetooth]
-    adapter = "hci0"
-
-[socket]
-    path = "/tmp/itd/socket"
-
-[metrics]
-    enabled = false
-
-    [metrics.heartRate]
-        enabled = true
-
-    [metrics.stepCount]
-        enabled = true
-
-    [metrics.battLevel]
-        enabled = true
-
-    [metrics.motion]
-        # This may lower the battery life of the PineTime
-        enabled = false
-
 [conn]
     reconnect = true
 
-[conn.whitelist]
-    enabled = false
-    devices = []
+[notify]
+    onConnect = true
+    onReconnect = true
 
-[on.connect]
-    notify = true
-
-[on.reconnect]
-    notify = true
-    setTime = true
-
-[notifs.translit]
-    use = ["eASCII", "Russian", "Emoji"]
-
-[notifs.ignore]
+[notifications.ignore]
     sender = []
     summary = ["InfiniTime"]
     body = []
 
 [music]
-    vol.interval = 5
-
-[weather]
-    enabled = true
-    location = "Los Angeles, CA"
-
-[logging]
-    level = "info"
+    volInterval = 5

main.go

@@ -19,107 +19,65 @@
 package main
 
 import (
-	"context"
-	_ "embed"
-	"flag"
-	"fmt"
 	"os"
-	"os/signal"
-	"strconv"
-	"syscall"
+	"strings"
 	"time"
 
-	"github.com/gen2brain/dlgs"
-	"github.com/knadh/koanf"
-	"github.com/mattn/go-isatty"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
+	"github.com/spf13/viper"
 	"go.arsenm.dev/infinitime"
 )
 
-var k = koanf.New(".")
+var firmwareUpdating = false
 
-var (
-	firmwareUpdating = false
-	// The FS must be updated when the watch is reconnected
-	updateFS = false
-)
+func init() {
+	// Set up logger
+	log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr})
+
+	// Set config settings
+	viper.AddConfigPath("$HOME/.config")
+	viper.AddConfigPath("/etc")
+	viper.SetConfigName("itd")
+	viper.SetConfigType("toml")
+	viper.WatchConfig()
+	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+	viper.SetEnvPrefix("itd")
+	if err := viper.ReadInConfig(); err != nil {
+		log.Warn().Err(err).Msg("Could not read in config")
+	}
+	viper.AutomaticEnv()
+}
 
 func main() {
-	showVer := flag.Bool("version", false, "Show version number and exit")
-	flag.Parse()
-	// If version requested, print and exit
-	if *showVer {
-		fmt.Println(version)
-		return
-	}
-
-	level, err := zerolog.ParseLevel(k.String("logging.level"))
-	if err != nil || level == zerolog.NoLevel {
-		level = zerolog.InfoLevel
-	}
-
-	// Initialize infinitime library
-	infinitime.Init(k.String("bluetooth.adapter"))
 	// Cleanly exit after function
 	defer infinitime.Exit()
 
-	// Create infinitime options struct
-	opts := &infinitime.Options{
-		AttemptReconnect: k.Bool("conn.reconnect"),
-		WhitelistEnabled: k.Bool("conn.whitelist.enabled"),
-		Whitelist:        k.Strings("conn.whitelist.devices"),
-		OnReqPasskey:     onReqPasskey,
-		Logger:           log.Logger,
-		LogLevel:         level,
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	sigCh := make(chan os.Signal, 1)
-	go func() {
-		<-sigCh
-		cancel()
-		time.Sleep(200 * time.Millisecond)
-		os.Exit(0)
-	}()
-	signal.Notify(
-		sigCh,
-		syscall.SIGINT,
-		syscall.SIGTERM,
-	)
-
 	// Connect to InfiniTime with default options
-	dev, err := infinitime.Connect(ctx, opts)
+	dev, err := infinitime.Connect(&infinitime.Options{
+		AttemptReconnect: viper.GetBool("conn.reconnect"),
+	})
 	if err != nil {
-		log.Fatal().Err(err).Msg("Error connecting to InfiniTime")
+		log.Error().Err(err).Msg("Error connecting to InfiniTime")
 	}
 
 	// When InfiniTime reconnects
-	opts.OnReconnect = func() {
-		if k.Bool("on.reconnect.setTime") {
+	dev.OnReconnect(func() {
 		// Set time to current time
 		err = dev.SetTime(time.Now())
 		if err != nil {
-				return
-			}
+			log.Error().Err(err).Msg("Error setting current time on connected InfiniTime")
 		}
 
 		// If config specifies to notify on reconnect
-		if k.Bool("on.reconnect.notify") {
+		if viper.GetBool("notify.onReconnect") {
 			// Send notification to InfiniTime
 			err = dev.Notify("itd", "Successfully reconnected")
 			if err != nil {
-				return
+				log.Error().Err(err).Msg("Error sending notification to InfiniTime")
 			}
 		}
-
-		// FS must be updated on reconnect
-		updateFS = true
-		// Resend weather on reconnect
-		sendWeatherCh <- struct{}{}
-	}
+	})
 
 	// Get firmware version
 	ver, err := dev.Version()
@@ -131,7 +89,7 @@ func main() {
 	log.Info().Str("version", ver).Msg("Connected to InfiniTime")
 
 	// If config specifies to notify on connect
-	if k.Bool("on.connect.notify") {
+	if viper.GetBool("notify.onConnect") {
 		// Send notification to InfiniTime
 		err = dev.Notify("itd", "Successfully connected")
 		if err != nil {
@@ -151,63 +109,18 @@ func main() {
 		log.Error().Err(err).Msg("Error initializing music control")
 	}
 
-	// Start control socket
-	err = initCallNotifs(ctx, dev)
-	if err != nil {
-		log.Error().Err(err).Msg("Error initializing call notifications")
-	}
-
 	// Initialize notification relay
-	err = initNotifRelay(ctx, dev)
+	err = initNotifRelay(dev)
 	if err != nil {
 		log.Error().Err(err).Msg("Error initializing notification relay")
 	}
 
-	// Initializa weather
-	err = initWeather(ctx, dev)
-	if err != nil {
-		log.Error().Err(err).Msg("Error initializing weather")
-	}
-
-	// Initialize metrics collection
-	err = initMetrics(ctx, dev)
-	if err != nil {
-		log.Error().Err(err).Msg("Error intializing metrics collection")
-	}
-
-	// Initialize metrics collection
-	err = initPureMaps(ctx, dev)
-	if err != nil {
-		log.Error().Err(err).Msg("Error intializing puremaps integration")
-	}
-
 	// Start control socket
-	err = startSocket(ctx, dev)
+	err = startSocket(dev)
 	if err != nil {
 		log.Error().Err(err).Msg("Error starting socket")
 	}
+
 	// Block forever
 	select {}
 }
-
-func onReqPasskey() (uint32, error) {
-	var out uint32
-	if isatty.IsTerminal(os.Stdin.Fd()) {
-		fmt.Print("Passkey: ")
-		_, err := fmt.Scanln(&out)
-		if err != nil {
-			return 0, err
-		}
-	} else {
-		passkey, ok, err := dlgs.Entry("Pairing", "Enter the passkey displayed on your watch.", "")
-		if err != nil {
-			return 0, err
-		}
-		if !ok {
-			return 0, nil
-		}
-		passkeyInt, err := strconv.Atoi(passkey)
-		return uint32(passkeyInt), err
-	}
-	return out, nil
-}

maps.go

@@ -1,210 +0,0 @@
-package main
-
-import (
-	"context"
-	"strings"
-
-	"github.com/godbus/dbus/v5"
-	"github.com/rs/zerolog/log"
-	"go.arsenm.dev/infinitime"
-)
-
-const (
-	interfaceName     = "io.github.rinigus.PureMaps.navigator"
-	iconProperty      = interfaceName + ".icon"
-	narrativeProperty = interfaceName + ".narrative"
-	manDistProperty   = interfaceName + ".manDist"
-	progressProperty  = interfaceName + ".progress"
-)
-
-func initPureMaps(ctx context.Context, dev *infinitime.Device) error {
-	// Connect to session bus. This connection is for method calls.
-	conn, err := newSessionBusConn(ctx)
-	if err != nil {
-		return err
-	}
-
-	exists, err := pureMapsExists(ctx, conn)
-	if err != nil {
-		return err
-	}
-
-	// Connect to session bus. This connection is for method calls.
-	monitorConn, err := newSessionBusConn(ctx)
-	if err != nil {
-		return err
-	}
-
-	// Define rules to listen for
-	var rules = []string{
-		"type='signal',interface='io.github.rinigus.PureMaps.navigator'",
-	}
-	var flag uint = 0
-	// Becode monitor for notifications
-	call := monitorConn.BusObject().CallWithContext(
-		ctx, "org.freedesktop.DBus.Monitoring.BecomeMonitor", 0, rules, flag,
-	)
-	if call.Err != nil {
-		return call.Err
-	}
-
-	var navigator dbus.BusObject
-
-	if exists {
-		navigator = conn.Object("io.github.rinigus.PureMaps", "/io/github/rinigus/PureMaps/navigator")
-		err = setAll(navigator, dev)
-		if err != nil {
-			log.Error().Err(err).Msg("Error setting all navigation fields")
-		}
-	}
-
-	go func() {
-		signalCh := make(chan *dbus.Message, 10)
-		monitorConn.Eavesdrop(signalCh)
-
-		for {
-			select {
-			case sig := <-signalCh:
-				if sig.Type != dbus.TypeSignal {
-					continue
-				}
-
-				var member string
-				err = sig.Headers[dbus.FieldMember].Store(&member)
-				if err != nil {
-					log.Error().Err(err).Msg("Error getting dbus member field")
-					continue
-				}
-
-				if !strings.HasSuffix(member, "Changed") {
-					continue
-				}
-
-				log.Debug().Str("member", member).Msg("Signal received from PureMaps navigator")
-
-				// The object must be retrieved in this loop in case PureMaps was not
-				// open at the time ITD was started.
-				navigator = conn.Object("io.github.rinigus.PureMaps", "/io/github/rinigus/PureMaps/navigator")
-				member = strings.TrimSuffix(member, "Changed")
-
-				switch member {
-				case "icon":
-					var icon string
-					err = navigator.StoreProperty(iconProperty, &icon)
-					if err != nil {
-						log.Error().Err(err).Str("property", member).Msg("Error getting property")
-						continue
-					}
-
-					err = dev.Navigation.SetFlag(infinitime.NavFlag(icon))
-					if err != nil {
-						log.Error().Err(err).Str("property", member).Msg("Error setting flag")
-						continue
-					}
-				case "narrative":
-					var narrative string
-					err = navigator.StoreProperty(narrativeProperty, &narrative)
-					if err != nil {
-						log.Error().Err(err).Str("property", member).Msg("Error getting property")
-						continue
-					}
-
-					err = dev.Navigation.SetNarrative(narrative)
-					if err != nil {
-						log.Error().Err(err).Str("property", member).Msg("Error setting flag")
-						continue
-					}
-				case "manDist":
-					var manDist string
-					err = navigator.StoreProperty(manDistProperty, &manDist)
-					if err != nil {
-						log.Error().Err(err).Str("property", member).Msg("Error getting property")
-						continue
-					}
-
-					err = dev.Navigation.SetManDist(manDist)
-					if err != nil {
-						log.Error().Err(err).Str("property", member).Msg("Error setting flag")
-						continue
-					}
-				case "progress":
-					var progress int32
-					err = navigator.StoreProperty(progressProperty, &progress)
-					if err != nil {
-						log.Error().Err(err).Str("property", member).Msg("Error getting property")
-						continue
-					}
-
-					err = dev.Navigation.SetProgress(uint8(progress))
-					if err != nil {
-						log.Error().Err(err).Str("property", member).Msg("Error setting flag")
-						continue
-					}
-				}
-			case <-ctx.Done():
-				return
-			}
-		}
-	}()
-
-	if exists {
-		log.Info().Msg("Sending PureMaps data to InfiniTime")
-	}
-
-	return nil
-}
-
-func setAll(navigator dbus.BusObject, dev *infinitime.Device) error {
-	var icon string
-	err := navigator.StoreProperty(iconProperty, &icon)
-	if err != nil {
-		return err
-	}
-
-	err = dev.Navigation.SetFlag(infinitime.NavFlag(icon))
-	if err != nil {
-		return err
-	}
-
-	var narrative string
-	err = navigator.StoreProperty(narrativeProperty, &narrative)
-	if err != nil {
-		return err
-	}
-
-	err = dev.Navigation.SetNarrative(narrative)
-	if err != nil {
-		return err
-	}
-
-	var manDist string
-	err = navigator.StoreProperty(manDistProperty, &manDist)
-	if err != nil {
-		return err
-	}
-
-	err = dev.Navigation.SetManDist(manDist)
-	if err != nil {
-		return err
-	}
-
-	var progress int32
-	err = navigator.StoreProperty(progressProperty, &progress)
-	if err != nil {
-		return err
-	}
-
-	return dev.Navigation.SetProgress(uint8(progress))
-}
-
-// pureMapsExists checks to make sure the PureMaps service exists on the bus
-func pureMapsExists(ctx context.Context, conn *dbus.Conn) (bool, error) {
-	var names []string
-	err := conn.BusObject().CallWithContext(
-		ctx, "org.freedesktop.DBus.ListNames", 0,
-	).Store(&names)
-	if err != nil {
-		return false, err
-	}
-	return strSlcContains(names, "io.github.rinigus.PureMaps"), nil
-}

metrics.go

@@ -1,131 +0,0 @@
-package main
-
-import (
-	"context"
-	"database/sql"
-	"path/filepath"
-	"time"
-
-	"github.com/rs/zerolog/log"
-	"go.arsenm.dev/infinitime"
-	_ "modernc.org/sqlite"
-)
-
-func initMetrics(ctx context.Context, dev *infinitime.Device) error {
-	// If metrics disabled, return nil
-	if !k.Bool("metrics.enabled") {
-		return nil
-	}
-
-	// Open metrics database
-	db, err := sql.Open("sqlite", filepath.Join(cfgDir, "metrics.db"))
-	if err != nil {
-		return err
-	}
-
-	// Create heartRate table
-	_, err = db.Exec("CREATE TABLE IF NOT EXISTS heartRate(time INT, bpm INT);")
-	if err != nil {
-		return err
-	}
-
-	// Create stepCount table
-	_, err = db.Exec("CREATE TABLE IF NOT EXISTS stepCount(time INT, steps INT);")
-	if err != nil {
-		return err
-	}
-
-	// Create battLevel table
-	_, err = db.Exec("CREATE TABLE IF NOT EXISTS battLevel(time INT, percent INT);")
-	if err != nil {
-		return err
-	}
-
-	// Create motion table
-	_, err = db.Exec("CREATE TABLE IF NOT EXISTS motion(time INT, X INT, Y INT, Z INT);")
-	if err != nil {
-		return err
-	}
-
-	// If heart rate metrics enabled in config
-	if k.Bool("metrics.heartRate.enabled") {
-		// Watch heart rate
-		heartRateCh, err := dev.WatchHeartRate(ctx)
-		if err != nil {
-			return err
-		}
-		go func() {
-			// For every heart rate sample
-			for heartRate := range heartRateCh {
-				// Get current time
-				unixTime := time.Now().UnixNano()
-				// Insert sample and time into database
-				db.Exec("INSERT INTO heartRate VALUES (?, ?);", unixTime, heartRate)
-			}
-		}()
-	}
-
-	// If step count metrics enabled in config
-	if k.Bool("metrics.stepCount.enabled") {
-		// Watch step count
-		stepCountCh, err := dev.WatchStepCount(ctx)
-		if err != nil {
-			return err
-		}
-		go func() {
-			// For every step count sample
-			for stepCount := range stepCountCh {
-				// Get current time
-				unixTime := time.Now().UnixNano()
-				// Insert sample and time into database
-				db.Exec("INSERT INTO stepCount VALUES (?, ?);", unixTime, stepCount)
-			}
-		}()
-	}
-
-	// If battery level metrics enabled in config
-	if k.Bool("metrics.battLevel.enabled") {
-		// Watch battery level
-		battLevelCh, err := dev.WatchBatteryLevel(ctx)
-		if err != nil {
-			return err
-		}
-		go func() {
-			// For every battery level sample
-			for battLevel := range battLevelCh {
-				// Get current time
-				unixTime := time.Now().UnixNano()
-				// Insert sample and time into database
-				db.Exec("INSERT INTO battLevel VALUES (?, ?);", unixTime, battLevel)
-			}
-		}()
-	}
-
-	// If motion metrics enabled in config
-	if k.Bool("metrics.motion.enabled") {
-		// Watch motion values
-		motionCh, err := dev.WatchMotion(ctx)
-		if err != nil {
-			return err
-		}
-		go func() {
-			// For every motion sample
-			for motionVals := range motionCh {
-				// Get current time
-				unixTime := time.Now().UnixNano()
-				// Insert sample values and time into database
-				db.Exec(
-					"INSERT INTO motion VALUES (?, ?, ?, ?);",
-					unixTime,
-					motionVals.X,
-					motionVals.Y,
-					motionVals.Z,
-				)
-			}
-		}()
-	}
-
-	log.Info().Msg("Initialized metrics collection")
-
-	return nil
-}

music.go

@@ -19,33 +19,52 @@
 package main
 
 import (
-	"github.com/rs/zerolog/log"
 	"go.arsenm.dev/infinitime"
 	"go.arsenm.dev/infinitime/pkg/player"
-	"go.arsenm.dev/itd/translit"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/viper"
 )
 
 func initMusicCtrl(dev *infinitime.Device) error {
-	player.Init()
-
-	maps := k.Strings("notifs.translit.use")
-	translit.Transliterators["custom"] = translit.Map(k.Strings("notifs.translit.custom"))
-
-	player.OnChange(func(ct player.ChangeType, val string) {
-		newVal := translit.Transliterate(val, maps...)
+	// On player status change, set status
+	err := player.Status(func(newStatus bool) {
 		if !firmwareUpdating {
-			switch ct {
-			case player.ChangeTypeStatus:
-				dev.Music.SetStatus(val == "Playing")
-			case player.ChangeTypeTitle:
-				dev.Music.SetTrack(newVal)
-			case player.ChangeTypeAlbum:
-				dev.Music.SetAlbum(newVal)
-			case player.ChangeTypeArtist:
-				dev.Music.SetArtist(newVal)
-			}
+			dev.Music.SetStatus(newStatus)
 		}
 	})
+	if err != nil {
+		return err
+	}
+
+	// On player title change, set track
+	err = player.Metadata("title", func(newTitle string) {
+		if !firmwareUpdating {
+			dev.Music.SetTrack(newTitle)
+		}
+	})
+	if err != nil {
+		return err
+	}
+
+	// On player album change, set album
+	err = player.Metadata("album", func(newAlbum string) {
+		if !firmwareUpdating {
+			dev.Music.SetAlbum(newAlbum)
+		}
+	})
+	if err != nil {
+		return err
+	}
+
+	// On player artist change, set artist
+	err = player.Metadata("artist", func(newArtist string) {
+		if !firmwareUpdating {
+			dev.Music.SetArtist(newArtist)
+		}
+	})
+	if err != nil {
+		return err
+	}
 
 	// Watch for music events
 	musicEvtCh, err := dev.Music.WatchEvents()
@@ -66,9 +85,9 @@ func initMusicCtrl(dev *infinitime.Device) error {
 			case infinitime.MusicEventPrev:
 				player.Prev()
 			case infinitime.MusicEventVolUp:
-				player.VolUp(uint(k.Int("music.vol.interval")))
+				player.VolUp(viper.GetUint("music.volInterval"))
 			case infinitime.MusicEventVolDown:
-				player.VolDown(uint(k.Int("music.vol.interval")))
+				player.VolDown(viper.GetUint("music.volInterval"))
 			}
 		}
 	}()

notifs.go

@@ -19,18 +19,17 @@
 package main
 
 import (
-	"context"
 	"fmt"
 
 	"github.com/godbus/dbus/v5"
 	"github.com/rs/zerolog/log"
+	"github.com/spf13/viper"
 	"go.arsenm.dev/infinitime"
-	"go.arsenm.dev/itd/translit"
 )
 
-func initNotifRelay(ctx context.Context, dev *infinitime.Device) error {
+func initNotifRelay(dev *infinitime.Device) error {
 	// Connect to dbus session bus
-	bus, err := newSessionBusConn(ctx)
+	bus, err := dbus.SessionBus()
 	if err != nil {
 		return err
 	}
@@ -41,9 +40,7 @@ func initNotifRelay(ctx context.Context, dev *infinitime.Device) error {
 	}
 	var flag uint = 0
 	// Becode monitor for notifications
-	call := bus.BusObject().CallWithContext(
-		ctx, "org.freedesktop.DBus.Monitoring.BecomeMonitor", 0, rules, flag,
-	)
+	call := bus.BusObject().Call("org.freedesktop.DBus.Monitoring.BecomeMonitor", 0, rules, flag)
 	if call.Err != nil {
 		return call.Err
 	}
@@ -74,12 +71,6 @@ func initNotifRelay(ctx context.Context, dev *infinitime.Device) error {
 				continue
 			}
 
-			maps := k.Strings("notifs.translit.use")
-			translit.Transliterators["custom"] = translit.Map(k.Strings("notifs.translit.custom"))
-			sender = translit.Transliterate(sender, maps...)
-			summary = translit.Transliterate(summary, maps...)
-			body = translit.Transliterate(body, maps...)
-
 			var msg string
 			// If summary does not exist, set message to body.
 			// If it does, set message to summary, two newlines, and then body
@@ -99,9 +90,9 @@ func initNotifRelay(ctx context.Context, dev *infinitime.Device) error {
 
 // ignored checks whether any fields were ignored in the config
 func ignored(sender, summary, body string) bool {
-	ignoreSender := k.Strings("notifs.ignore.sender")
-	ignoreSummary := k.Strings("notifs.ignore.summary")
-	ignoreBody := k.Strings("notifs.ignore.body")
+	ignoreSender := viper.GetStringSlice("notifications.ignore.sender")
+	ignoreSummary := viper.GetStringSlice("notifications.ignore.summary")
+	ignoreBody := viper.GetStringSlice("notifications.ignore.body")
 	return strSlcContains(ignoreSender, sender) ||
 		strSlcContains(ignoreSummary, summary) ||
 		strSlcContains(ignoreBody, body)

scripts/gen-version.sh

@@ -1,3 +0,0 @@
-#!/bin/bash
-
-git describe --tags > version.txt

socket.go

@@ -19,470 +19,278 @@
 package main
 
 import (
-	"context"
-	"errors"
-	"io"
+	"bufio"
+	"encoding/json"
+	"fmt"
 	"net"
 	"os"
 	"path/filepath"
 	"time"
 
+	"github.com/mitchellh/mapstructure"
 	"github.com/rs/zerolog/log"
 	"go.arsenm.dev/infinitime"
-	"go.arsenm.dev/infinitime/blefs"
-	"go.arsenm.dev/itd/api"
-	"go.arsenm.dev/lrpc/codec"
-	"go.arsenm.dev/lrpc/server"
+	"go.arsenm.dev/itd/internal/types"
 )
 
-var (
-	ErrDFUInvalidFile    = errors.New("provided file is invalid for given upgrade type")
-	ErrDFUNotEnoughFiles = errors.New("not enough files provided for given upgrade type")
-	ErrDFUInvalidUpgType = errors.New("invalid upgrade type")
+const SockPath = "/tmp/itd/socket"
+
+const (
+	ReqTypeHeartRate = "hrt"
+	ReqTypeBattLevel = "battlvl"
+	ReqTypeFwVersion = "fwver"
+	ReqTypeFwUpgrade = "fwupg"
+	ReqTypeBtAddress = "btaddr"
+	ReqTypeNotify    = "notify"
+	ReqTypeSetTime   = "settime"
 )
 
-func startSocket(ctx context.Context, dev *infinitime.Device) error {
-	// Make socket directory if non-existant
-	err := os.MkdirAll(filepath.Dir(k.String("socket.path")), 0755)
+const (
+	UpgradeTypeArchive = iota
+	UpgradeTypeFiles
+)
+
+func startSocket(dev *infinitime.Device) error {
+	// Make socket directory if non existant
+	err := os.MkdirAll(filepath.Dir(SockPath), 0755)
 	if err != nil {
 		return err
 	}
 
 	// Remove old socket if it exists
-	err = os.RemoveAll(k.String("socket.path"))
+	err = os.RemoveAll(SockPath)
 	if err != nil {
 		return err
 	}
 
 	// Listen on socket path
-	ln, err := net.Listen("unix", k.String("socket.path"))
+	ln, err := net.Listen("unix", SockPath)
 	if err != nil {
 		return err
 	}
 
-	fs, err := dev.FS()
+	go func() {
+		for {
+			// Accept socket connection
+			conn, err := ln.Accept()
 			if err != nil {
-		log.Warn().Err(err).Msg("Error getting BLE filesystem")
+				log.Error().Err(err).Msg("Error accepting connection")
 			}
 
-	srv := server.New()
-
-	itdAPI := &ITD{
-		dev: dev,
+			// Concurrently handle connection
+			go handleConnection(conn, dev)
 		}
-	err = srv.Register(itdAPI)
-	if err != nil {
-		return err
-	}
-
-	fsAPI := &FS{
-		dev: dev,
-		fs:  fs,
-	}
-	err = srv.Register(fsAPI)
-	if err != nil {
-		return err
-	}
-
-	go srv.Serve(ctx, ln, codec.Default)
+	}()
 
 	// Log socket start
-	log.Info().Str("path", k.String("socket.path")).Msg("Started control socket")
+	log.Info().Str("path", SockPath).Msg("Started control socket")
 
 	return nil
 }
 
-type ITD struct {
-	dev *infinitime.Device
+func handleConnection(conn net.Conn, dev *infinitime.Device) {
+	defer conn.Close()
+	// If firmware is updating, return error
+	if firmwareUpdating {
+		connErr(conn, nil, "Firmware update in progress")
+		return
 	}
 
-func (i *ITD) HeartRate(_ *server.Context) (uint8, error) {
-	return i.dev.HeartRate()
-}
-
-func (i *ITD) WatchHeartRate(ctx *server.Context) error {
-	ch, err := ctx.MakeChannel()
+	// Create new scanner on connection
+	scanner := bufio.NewScanner(conn)
+	for scanner.Scan() {
+		var req types.Request
+		// Decode scanned message into types.Request
+		err := json.Unmarshal(scanner.Bytes(), &req)
 		if err != nil {
-		return err
+			connErr(conn, err, "Error decoding JSON input")
+			continue
 		}
 
-	heartRateCh, err := i.dev.WatchHeartRate(ctx)
+		switch req.Type {
+		case ReqTypeHeartRate:
+			// Get heart rate from watch
+			heartRate, err := dev.HeartRate()
 			if err != nil {
-		return err
+				connErr(conn, err, "Error getting heart rate")
+				break
 			}
-
-	go func() {
-		// For every heart rate value
-		for heartRate := range heartRateCh {
-			ch <- heartRate
-		}
-	}()
-
-	return nil
-}
-
-func (i *ITD) BatteryLevel(_ *server.Context) (uint8, error) {
-	return i.dev.BatteryLevel()
-}
-
-func (i *ITD) WatchBatteryLevel(ctx *server.Context) error {
-	ch, err := ctx.MakeChannel()
+			// Encode heart rate to connection
+			json.NewEncoder(conn).Encode(types.Response{
+				Value: heartRate,
+			})
+		case ReqTypeBattLevel:
+			// Get battery level from watch
+			battLevel, err := dev.BatteryLevel()
 			if err != nil {
-		return err
+				connErr(conn, err, "Error getting battery level")
+				break
 			}
-
-	battLevelCh, err := i.dev.WatchBatteryLevel(ctx)
+			// Encode battery level to connection
+			json.NewEncoder(conn).Encode(types.Response{
+				Value: battLevel,
+			})
+		case ReqTypeFwVersion:
+			// Get firmware version from watch
+			version, err := dev.Version()
 			if err != nil {
-		return err
+				connErr(conn, err, "Error getting battery level")
+				break
 			}
-
-	go func() {
-		// For every heart rate value
-		for battLevel := range battLevelCh {
-			ch <- battLevel
+			// Encode version to connection
+			json.NewEncoder(conn).Encode(types.Response{
+				Value: version,
+			})
+		case ReqTypeBtAddress:
+			// Encode bluetooth address to connection
+			json.NewEncoder(conn).Encode(types.Response{
+				Value: dev.Address(),
+			})
+		case ReqTypeNotify:
+			// If no data, return error
+			if req.Data == nil {
+				connErr(conn, nil, "Data required for notify types.Request")
+				break
 			}
-	}()
-
-	return nil
-}
-
-func (i *ITD) Motion(_ *server.Context) (infinitime.MotionValues, error) {
-	return i.dev.Motion()
-}
-
-func (i *ITD) WatchMotion(ctx *server.Context) error {
-	ch, err := ctx.MakeChannel()
+			var reqData types.ReqDataNotify
+			// Decode data map to notify types.Request data
+			err = mapstructure.Decode(req.Data, &reqData)
 			if err != nil {
-		return err
+				connErr(conn, err, "Error decoding types.Request data")
+				break
 			}
-
-	motionValsCh, err := i.dev.WatchMotion(ctx)
+			// Send notification to watch
+			err = dev.Notify(reqData.Title, reqData.Body)
 			if err != nil {
-		return err
+				connErr(conn, err, "Error sending notification")
+				break
+			}
+			// Encode empty types.Response to connection
+			json.NewEncoder(conn).Encode(types.Response{})
+		case ReqTypeSetTime:
+			// If no data, return error
+			if req.Data == nil {
+				connErr(conn, nil, "Data required for settime types.Request")
+				break
+			}
+			// Get string from data or return error
+			reqTimeStr, ok := req.Data.(string)
+			if !ok {
+				connErr(conn, nil, "Data for settime types.Request must be RFC3339 formatted time string")
+				break
 			}
 
-	go func() {
-		// For every heart rate value
-		for motionVals := range motionValsCh {
-			ch <- motionVals
-		}
-	}()
-
-	return nil
-}
-
-func (i *ITD) StepCount(_ *server.Context) (uint32, error) {
-	return i.dev.StepCount()
-}
-
-func (i *ITD) WatchStepCount(ctx *server.Context) error {
-	ch, err := ctx.MakeChannel()
+			var reqTime time.Time
+			if reqTimeStr == "now" {
+				reqTime = time.Now()
+			} else {
+				// Parse time as RFC3339/ISO9601
+				reqTime, err = time.Parse(time.RFC3339, reqTimeStr)
 				if err != nil {
-		return err
+					connErr(conn, err, "Invalid time format. Time string must be formatted as ISO8601 or the word `now`")
+					break
 				}
-
-	stepCountCh, err := i.dev.WatchStepCount(ctx)
+			}
+			// Set time on watch
+			err = dev.SetTime(reqTime)
 			if err != nil {
-		return err
+				connErr(conn, err, "Error setting device time")
+				break
 			}
-
-	go func() {
-		// For every heart rate value
-		for stepCount := range stepCountCh {
-			ch <- stepCount
+			// Encode empty types.Response to connection
+			json.NewEncoder(conn).Encode(types.Response{})
+		case ReqTypeFwUpgrade:
+			// If no data, return error
+			if req.Data == nil {
+				connErr(conn, nil, "Data required for firmware upgrade types.Request")
+				break
 			}
-	}()
-
-	return nil
+			var reqData types.ReqDataFwUpgrade
+			// Decode data map to firmware upgrade types.Request data
+			err = mapstructure.Decode(req.Data, &reqData)
+			if err != nil {
+				connErr(conn, err, "Error decoding types.Request data")
+				break
 			}
-
-func (i *ITD) Version(_ *server.Context) (string, error) {
-	return i.dev.Version()
-}
-
-func (i *ITD) Address(_ *server.Context) string {
-	return i.dev.Address()
-}
-
-func (i *ITD) Notify(_ *server.Context, data api.NotifyData) error {
-	return i.dev.Notify(data.Title, data.Body)
-}
-
-func (i *ITD) SetTime(_ *server.Context, t *time.Time) error {
-	return i.dev.SetTime(*t)
-}
-
-func (i *ITD) WeatherUpdate(_ *server.Context) {
-	sendWeatherCh <- struct{}{}
-}
-
-func (i *ITD) FirmwareUpgrade(ctx *server.Context, reqData api.FwUpgradeData) error {
-	i.dev.DFU.Reset()
-
 			switch reqData.Type {
-	case api.UpgradeTypeArchive:
+			case UpgradeTypeArchive:
 				// If less than one file, return error
 				if len(reqData.Files) < 1 {
-			return ErrDFUNotEnoughFiles
+					connErr(conn, nil, "Archive upgrade requires one file with .zip extension")
+					break
 				}
 				// If file is not zip archive, return error
 				if filepath.Ext(reqData.Files[0]) != ".zip" {
-			return ErrDFUInvalidFile
+					connErr(conn, nil, "Archive upgrade file must be a zip archive")
+					break
 				}
 				// Load DFU archive
-		err := i.dev.DFU.LoadArchive(reqData.Files[0])
+				err := dev.DFU.LoadArchive(reqData.Files[0])
 				if err != nil {
-			return err
+					connErr(conn, err, "Error loading archive file")
+					break
 				}
-	case api.UpgradeTypeFiles:
+			case UpgradeTypeFiles:
 				// If less than two files, return error
 				if len(reqData.Files) < 2 {
-			return ErrDFUNotEnoughFiles
+					connErr(conn, nil, "Files upgrade requires two files. First with .dat and second with .bin extension.")
+					break
 				}
 				// If first file is not init packet, return error
 				if filepath.Ext(reqData.Files[0]) != ".dat" {
-			return ErrDFUInvalidFile
+					connErr(conn, nil, "First file must be a .dat file")
+					break
 				}
 				// If second file is not firmware image, return error
 				if filepath.Ext(reqData.Files[1]) != ".bin" {
-			return ErrDFUInvalidFile
+					connErr(conn, nil, "Second file must be a .bin file")
+					break
 				}
 				// Load individual DFU files
-		err := i.dev.DFU.LoadFiles(reqData.Files[0], reqData.Files[1])
+				err := dev.DFU.LoadFiles(reqData.Files[0], reqData.Files[1])
 				if err != nil {
-			return err
+					connErr(conn, err, "Error loading firmware files")
+					break
 				}
-	default:
-		return ErrDFUInvalidUpgType
-	}
-
-	ch, err := ctx.MakeChannel()
-	if err != nil {
-		return err
 			}
 
 			go func() {
+				// Get progress
+				progress := dev.DFU.Progress()
 				// For every progress event
-		for event := range i.dev.DFU.Progress() {
-			ch <- event
+				for event := range progress {
+					// Encode event on connection
+					json.NewEncoder(conn).Encode(types.Response{
+						Value: event,
+					})
 				}
-
-		firmwareUpdating = false
-		// Send zero object to signal completion
-		close(ch)
 			}()
 
 			// Set firmwareUpdating
 			firmwareUpdating = true
-
-	go func() {
 			// Start DFU
-		err := i.dev.DFU.Start()
+			err = dev.DFU.Start()
 			if err != nil {
-			log.Error().Err(err).Msg("Error while upgrading firmware")
+				connErr(conn, err, "Error performing upgrade")
+				break
+			}
 			firmwareUpdating = false
-			return
 		}
-	}()
-
-	return nil
+	}
 }
 
-type FS struct {
-	dev *infinitime.Device
-	fs  *blefs.FS
-}
-
-func (fs *FS) RemoveAll(_ *server.Context, paths []string) error {
-	fs.updateFS()
-	for _, path := range paths {
-		err := fs.fs.RemoveAll(path)
+func connErr(conn net.Conn, err error, msg string) {
+	var res types.Response
+	// If error exists, add to types.Response, otherwise don't
 	if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (fs *FS) Remove(_ *server.Context, paths []string) error {
-	fs.updateFS()
-	for _, path := range paths {
-		err := fs.fs.Remove(path)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (fs *FS) Rename(_ *server.Context, paths [2]string) error {
-	fs.updateFS()
-	return fs.fs.Rename(paths[0], paths[1])
-}
-
-func (fs *FS) MkdirAll(_ *server.Context, paths []string) error {
-	fs.updateFS()
-	for _, path := range paths {
-		err := fs.fs.MkdirAll(path)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (fs *FS) Mkdir(_ *server.Context, paths []string) error {
-	fs.updateFS()
-	for _, path := range paths {
-		err := fs.fs.Mkdir(path)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (fs *FS) ReadDir(_ *server.Context, dir string) ([]api.FileInfo, error) {
-	fs.updateFS()
-
-	entries, err := fs.fs.ReadDir(dir)
-	if err != nil {
-		return nil, err
-	}
-	var fileInfo []api.FileInfo
-	for _, entry := range entries {
-		info, err := entry.Info()
-		if err != nil {
-			return nil, err
-		}
-		fileInfo = append(fileInfo, api.FileInfo{
-			Name:  info.Name(),
-			Size:  info.Size(),
-			IsDir: info.IsDir(),
-		})
-	}
-
-	return fileInfo, nil
-}
-
-func (fs *FS) Upload(ctx *server.Context, paths [2]string) error {
-	fs.updateFS()
-
-	localFile, err := os.Open(paths[1])
-	if err != nil {
-		return err
-	}
-
-	localInfo, err := localFile.Stat()
-	if err != nil {
-		return err
-	}
-
-	remoteFile, err := fs.fs.Create(paths[0], uint32(localInfo.Size()))
-	if err != nil {
-		return err
-	}
-
-	ch, err := ctx.MakeChannel()
-	if err != nil {
-		return err
-	}
-	go func() {
-		// For every progress event
-		for sent := range remoteFile.Progress() {
-			ch <- api.FSTransferProgress{
-				Total: remoteFile.Size(),
-				Sent:  sent,
-			}
-		}
-
-		// Send zero object to signal completion
-		close(ch)
-	}()
-
-	go func() {
-		io.Copy(remoteFile, localFile)
-		localFile.Close()
-		remoteFile.Close()
-	}()
-
-	return nil
-}
-
-func (fs *FS) Download(ctx *server.Context, paths [2]string) error {
-	fs.updateFS()
-
-	localFile, err := os.Create(paths[0])
-	if err != nil {
-		return err
-	}
-
-	remoteFile, err := fs.fs.Open(paths[1])
-	if err != nil {
-		return err
-	}
-
-	ch, err := ctx.MakeChannel()
-	if err != nil {
-		return err
-	}
-	go func() {
-		// For every progress event
-		for sent := range remoteFile.Progress() {
-			ch <- api.FSTransferProgress{
-				Total: remoteFile.Size(),
-				Sent:  sent,
-			}
-		}
-
-		// Send zero object to signal completion
-		close(ch)
-		localFile.Close()
-		remoteFile.Close()
-	}()
-
-	go io.Copy(localFile, remoteFile)
-
-	return nil
-}
-
-func (fs *FS) LoadResources(ctx *server.Context, path string) error {
-	resFl, err := os.Open(path)
-	if err != nil {
-		return err
-	}
-
-	progCh, err := infinitime.LoadResources(resFl, fs.fs)
-	if err != nil {
-		return err
-	}
-
-	ch, err := ctx.MakeChannel()
-	if err != nil {
-		return err
-	}
-
-	go func() {
-		for evt := range progCh {
-			ch <- evt
-		}
-		close(ch)
-	}()
-
-	return nil
-}
-
-func (fs *FS) updateFS() {
-	if fs.fs == nil || updateFS {
-		// Get new FS
-		newFS, err := fs.dev.FS()
-		if err != nil {
-			log.Warn().Err(err).Msg("Error updating BLE filesystem")
+		log.Error().Err(err).Msg(msg)
+		res = types.Response{Message: fmt.Sprintf("%s: %s", msg, err)}
 	} else {
-			// Set FS pointer to new FS
-			fs.fs = newFS
-			// Reset updateFS
-			updateFS = false
-		}
+		log.Error().Msg(msg)
+		res = types.Response{Message: msg}
 	}
+	res.Error = true
+
+	// Encode error to connection
+	json.NewEncoder(conn).Encode(res)
 }

translit/armenian.go

@@ -1,150 +0,0 @@
-package translit
-
-import (
-	"strings"
-)
-
-type ArmenianTranslit struct {
-	initComplete bool
-}
-
-var armenianMap = []string{
-	"աու", "au",
-	"բու", "bu",
-	"գու", "gu",
-	"դու", "du",
-	"եու", "eu",
-	"զու", "zu",
-	"էու", "eu",
-	"ըու", "yu",
-	"թու", "tu",
-	"ժու", "ju",
-	"իու", "iu",
-	"լու", "lu",
-	"խու", "xu",
-	"ծու", "cu",
-	"կու", "ku",
-	"հու", "hu",
-	"ձու", "dzu",
-	"ղու", "xu",
-	"ճու", "cu",
-	"մու", "mu",
-	"յու", "yu",
-	"նու", "nu",
-	"շու", "shu",
-	"չու", "chu",
-	"պու", "pu",
-	"ջու", "ju",
-	"ռու", "ru",
-	"սու", "su",
-	"վու", "vu",
-	"տու", "tu",
-	"րու", "ru",
-	"ցու", "cu",
-	"փու", "pu",
-	"քու", "qu",
-	"օու", "ou",
-	"ևու", "eu",
-	"ֆու", "fu",
-	"ոու", "vou",
-	"ու", "u",
-	"բո", "bo",
-	"գո", "go",
-	"դո", "do",
-	"զո", "zo",
-	"թո", "to",
-	"ժո", "jo",
-	"լո", "lo",
-	"խո", "xo",
-	"ծո", "co",
-	"կո", "ko",
-	"հո", "ho",
-	"ձո", "dzo",
-	"ղո", "xo",
-	"ճո", "co",
-	"մո", "mo",
-	"յո", "yo",
-	"նո", "no",
-	"շո", "so",
-	"չո", "co",
-	"պո", "po",
-	"ջո", "jo",
-	"ռո", "ro",
-	"սո", "so",
-	"վո", "vo",
-	"տո", "to",
-	"րո", "ro",
-	"ցո", "co",
-	"փո", "po",
-	"քո", "qo",
-	"ևո", "eo",
-	"ֆո", "fo",
-	"ո", "vo",
-	"եւ", "ev",
-	"եվ", "ev",
-	"ա", "a",
-	"բ", "b",
-	"գ", "g",
-	"դ", "d",
-	"ե", "e",
-	"զ", "z",
-	"է", "e",
-	"ը", "y",
-	"թ", "t",
-	"ժ", "j",
-	"ի", "i",
-	"լ", "l",
-	"խ", "x",
-	"ծ", "c",
-	"կ", "k",
-	"հ", "h",
-	"ձ", "dz",
-	"ղ", "x",
-	"ճ", "c",
-	"մ", "m",
-	"յ", "y",
-	"ն", "n",
-	"շ", "sh",
-	"չ", "ch",
-	"պ", "p",
-	"ջ", "j",
-	"ռ", "r",
-	"ս", "s",
-	"վ", "v",
-	"տ", "t",
-	"ր", "r",
-	"ց", "c",
-	"փ", "p",
-	"ք", "q",
-	"օ", "o",
-	"և", "ev",
-	"ֆ", "f",
-	"ւ", "",
-}
-
-func (at *ArmenianTranslit) Init() {
-	if !at.initComplete {
-		// Copy map as original will be changed
-		lower := armenianMap
-		// For every value in copied map
-		for i, val := range lower {
-			// If index is odd, skip
-			if i%2 == 1 {
-				continue
-			}
-			// Capitalize first letter
-			capital := strings.Title(val)
-			// If capital is not the same as lowercase
-			if capital != val {
-				// Add capital to map
-				armenianMap = append(armenianMap, capital, strings.Title(armenianMap[i+1]))
-			}
-		}
-		// Set init complete to true so it is not run again
-		at.initComplete = true
-	}
-}
-
-func (at *ArmenianTranslit) Transliterate(s string) string {
-	return strings.NewReplacer(armenianMap...).Replace(s)
-}

translit/chinese.go

@@ -1,53 +0,0 @@
-package translit
-
-import (
-	"bytes"
-	"strings"
-	"unicode"
-
-	"github.com/mozillazg/go-pinyin"
-)
-
-// ChineseTranslit implements Transliterator using a pinyin
-// conversion library.
-type ChineseTranslit struct{}
-
-func (ChineseTranslit) Init() {}
-
-func (ct *ChineseTranslit) Transliterate(s string) string {
-	// Create buffer for final output
-	outBuf := &bytes.Buffer{}
-	// Create buffer to temporarily store chinese characters
-	tmpBuf := &bytes.Buffer{}
-	// For every character in string
-	for _, char := range s {
-		// If character in Han range
-		if unicode.Is(unicode.Han, char) {
-			// Write character to temporary buffer
-			tmpBuf.WriteRune(char)
-		} else {
-			// If buffer contains characters
-			if tmpBuf.Len() > 0 {
-				// Convert to pinyin (without tones)
-				out := pinyin.LazyConvert(tmpBuf.String(), nil)
-				// Write space-separated string to output
-				outBuf.WriteString(strings.Join(out, " "))
-				// Reset temporary buffer
-				tmpBuf.Reset()
-			}
-			// Write character to output
-			outBuf.WriteRune(char)
-		}
-	}
-	// If buffer contains characters
-	if tmpBuf.Len() > 0 {
-		// Convert to pinyin (without tones)
-		out := pinyin.LazyConvert(tmpBuf.String(), nil)
-		// Write space-separated string to output
-		outBuf.WriteString(strings.Join(out, " "))
-		// Reset temporary buffer
-		tmpBuf.Reset()
-	}
-	// Return output string
-	return outBuf.String()
-}

translit/korean.go

@@ -1,472 +0,0 @@
-package translit
-
-import (
-	"strings"
-	"unicode"
-
-	"golang.org/x/text/unicode/norm"
-)
-
-// https://en.wikipedia.org/wiki/Hangul_Jamo_%28Unicode_block%29
-var jamoBlock = &unicode.RangeTable{
-	R16: []unicode.Range16{{
-		Lo:     0x1100,
-		Hi:     0x11FF,
-		Stride: 1,
-	}},
-}
-
-// https://en.wikipedia.org/wiki/Hangul_Syllables
-var syllablesBlock = &unicode.RangeTable{
-	R16: []unicode.Range16{{
-		Lo:     0xAC00,
-		Hi:     0xD7A3,
-		Stride: 1,
-	}},
-}
-
-// https://en.wikipedia.org/wiki/Hangul_Compatibility_Jamo
-var compatJamoBlock = &unicode.RangeTable{
-	R16: []unicode.Range16{{
-		Lo:     0x3131,
-		Hi:     0x318E,
-		Stride: 1,
-	}},
-}
-
-// KoreanTranslit implements transliteration for Korean.
-//
-// This was translated to Go from the code in https://codeberg.org/Freeyourgadget/Gadgetbridge
-type KoreanTranslit struct{}
-
-func (KoreanTranslit) Init() {}
-
-// User input consisting of isolated jamo is usually mapped to the KS X 1001 compatibility
-// block, but jamo resulting from decomposed syllables are mapped to the modern one. This
-// function maps compat jamo to modern ones where possible and returns all other characters
-// unmodified.
-//
-// https://en.wikipedia.org/wiki/Hangul_Compatibility_Jamo
-// https://en.wikipedia.org/wiki/Hangul_Jamo_%28Unicode_block%29
-func decompatJamo(jamo rune) rune {
-	// KS X 1001 Hangul filler, not used in modern Unicode. A useful landmark in the
-	// compatibility jamo block.
-	// https://en.wikipedia.org/wiki/KS_X_1001#Hangul_Filler
-	var hangulFiller rune = 0x3164
-
-	// Ignore characters outside compatibility jamo block
-	if !unicode.In(jamo, compatJamoBlock) {
-		return jamo
-	}
-
-	// Vowels are contiguous, in the same order, and unambiguous so it's a simple offset.
-	if jamo >= 0x314F && jamo < hangulFiller {
-		return jamo - 0x1FEE
-	}
-
-	// Consonants are organized differently. No clean way to do this.
-	// The compatibility jamo block doesn't distinguish between Choseong (leading) and Jongseong
-	// (final) positions, but the modern block does. We map to Choseong here.
-	switch jamo {
-	case 0x3131:
-		return 0x1100 // ㄱ
-	case 0x3132:
-		return 0x1101 // ㄲ
-	case 0x3134:
-		return 0x1102 // ㄴ
-	case 0x3137:
-		return 0x1103 // ㄷ
-	case 0x3138:
-		return 0x1104 // ㄸ
-	case 0x3139:
-		return 0x1105 // ㄹ
-	case 0x3141:
-		return 0x1106 // ㅁ
-	case 0x3142:
-		return 0x1107 // ㅂ
-	case 0x3143:
-		return 0x1108 // ㅃ
-	case 0x3145:
-		return 0x1109 // ㅅ
-	case 0x3146:
-		return 0x110A // ㅆ
-	case 0x3147:
-		return 0x110B // ㅇ
-	case 0x3148:
-		return 0x110C // ㅈ
-	case 0x3149:
-		return 0x110D // ㅉ
-	case 0x314A:
-		return 0x110E // ㅊ
-	case 0x314B:
-		return 0x110F // ㅋ
-	case 0x314C:
-		return 0x1110 // ㅌ
-	case 0x314D:
-		return 0x1111 // ㅍ
-	case 0x314E:
-		return 0x1112 // ㅎ
-	}
-
-	// The rest of the compatibility block consists of archaic compounds that are
-	// unlikely to be encountered in modern systems. Just leave them alone.
-	return jamo
-}
-
-// Transliterates one jamo at a time.
-// Does nothing if it isn't in the modern jamo block.
-func translitSingleJamo(jamo rune) string {
-	jamo = decompatJamo(jamo)
-
-	switch jamo {
-	// Choseong (leading position consonants)
-	case 0x1100:
-		return "g" // ㄱ
-	case 0x1101:
-		return "kk" // ㄲ
-	case 0x1102:
-		return "n" // ㄴ
-	case 0x1103:
-		return "d" // ㄷ
-	case 0x1104:
-		return "tt" // ㄸ
-	case 0x1105:
-		return "r" // ㄹ
-	case 0x1106:
-		return "m" // ㅁ
-	case 0x1107:
-		return "b" // ㅂ
-	case 0x1108:
-		return "pp" // ㅃ
-	case 0x1109:
-		return "s" // ㅅ
-	case 0x110A:
-		return "ss" // ㅆ
-	case 0x110B:
-		return "" // ㅇ
-	case 0x110C:
-		return "j" // ㅈ
-	case 0x110D:
-		return "jj" // ㅉ
-	case 0x110E:
-		return "ch" // ㅊ
-	case 0x110F:
-		return "k" // ㅋ
-	case 0x1110:
-		return "t" // ㅌ
-	case 0x1111:
-		return "p" // ㅍ
-	case 0x1112:
-		return "h" // ㅎ
-	// Jungseong (vowels)
-	case 0x1161:
-		return "a" // ㅏ
-	case 0x1162:
-		return "ae" // ㅐ
-	case 0x1163:
-		return "ya" // ㅑ
-	case 0x1164:
-		return "yae" // ㅒ
-	case 0x1165:
-		return "eo" // ㅓ
-	case 0x1166:
-		return "e" // ㅔ
-	case 0x1167:
-		return "yeo" // ㅕ
-	case 0x1168:
-		return "ye" // ㅖ
-	case 0x1169:
-		return "o" // ㅗ
-	case 0x116A:
-		return "wa" // ㅘ
-	case 0x116B:
-		return "wae" // ㅙ
-	case 0x116C:
-		return "oe" // ㅚ
-	case 0x116D:
-		return "yo" // ㅛ
-	case 0x116E:
-		return "u" // ㅜ
-	case 0x116F:
-		return "wo" // ㅝ
-	case 0x1170:
-		return "we" // ㅞ
-	case 0x1171:
-		return "wi" // ㅟ
-	case 0x1172:
-		return "yu" // ㅠ
-	case 0x1173:
-		return "eu" // ㅡ
-	case 0x1174:
-		return "ui" // ㅢ
-	case 0x1175:
-		return "i" // ㅣ
-	// Jongseong (final position consonants)
-	case 0x11A8:
-		return "k" // ㄱ
-	case 0x11A9:
-		return "k" // ㄲ
-	case 0x11AB:
-		return "n" // ㄴ
-	case 0x11AE:
-		return "t" // ㄷ
-	case 0x11AF:
-		return "l" // ㄹ
-	case 0x11B7:
-		return "m" // ㅁ
-	case 0x11B8:
-		return "p" // ㅂ
-	case 0x11BA:
-		return "t" // ㅅ
-	case 0x11BB:
-		return "t" // ㅆ
-	case 0x11BC:
-		return "ng" // ㅇ
-	case 0x11BD:
-		return "t" // ㅈ
-	case 0x11BE:
-		return "t" // ㅊ
-	case 0x11BF:
-		return "k" // ㅋ
-	case 0x11C0:
-		return "t" // ㅌ
-	case 0x11C1:
-		return "p" // ㅍ
-	case 0x11C2:
-		return "t" // ㅎ
-	}
-
-	return string(jamo)
-}
-
-// Some combinations of ending jamo in one syllable and initial jamo in the next are romanized
-// irregularly. These exceptions are called "special provisions". In cases where multiple
-// romanizations are permitted, we use the one that's least commonly used elsewhere.
-//
-// Returns empty strring and false if either character is not in the modern jamo block,
-// or if there is no special provision for that pair of jamo.
-func translitSpecialProvisions(previousEnding rune, nextInitial rune) (string, bool) {
-	// Return false if previousEnding not in modern jamo block
-	if !unicode.In(previousEnding, jamoBlock) {
-		return "", false
-	}
-	// Return false if nextInitial not in modern jamo block
-	if !unicode.In(nextInitial, jamoBlock) {
-		return "", false
-	}
-
-	// Jongseong (final position) ㅎ has a number of special provisions.
-	if previousEnding == 0x11C2 {
-		switch nextInitial {
-		case 0x110B:
-			return "h", true // ㅇ
-		case 0x1100:
-			return "k", true // ㄱ
-		case 0x1102:
-			return "nn", true // ㄴ
-		case 0x1103:
-			return "t", true // ㄷ
-		case 0x1105:
-			return "nn", true // ㄹ
-		case 0x1106:
-			return "nm", true // ㅁ
-		case 0x1107:
-			return "p", true // ㅂ
-		case 0x1109:
-			return "hs", true // ㅅ
-		case 0x110C:
-			return "ch", true // ㅈ
-		case 0x1112:
-			return "t", true // ㅎ
-		default:
-			return "", false
-		}
-	}
-
-	// Otherwise, special provisions are denser when grouped by the second jamo.
-	switch nextInitial {
-	case 0x1100: // ㄱ
-		switch previousEnding {
-		case 0x11AB:
-			return "n-g", true // ㄴ
-		default:
-			return "", false
-		}
-	case 0x1102: // ㄴ
-		switch previousEnding {
-		case 0x11A8:
-			return "ngn", true // ㄱ
-		case 0x11AE:
-			fallthrough // ㄷ
-		case 0x11BA:
-			fallthrough // ㅅ
-		case 0x11BD:
-			fallthrough // ㅈ
-		case 0x11BE:
-			fallthrough // ㅊ
-		case 0x11C0: // ㅌ
-			return "nn", true
-		case 0x11AF:
-			return "ll", true // ㄹ
-		case 0x11B8:
-			return "mn", true // ㅂ
-		default:
-			return "", false
-		}
-	case 0x1105: // ㄹ
-		switch previousEnding {
-		case 0x11A8:
-			fallthrough // ㄱ
-		case 0x11AB:
-			fallthrough // ㄴ
-		case 0x11AF: // ㄹ
-			return "ll", true
-		case 0x11AE:
-			fallthrough // ㄷ
-		case 0x11BA:
-			fallthrough // ㅅ
-		case 0x11BD:
-			fallthrough // ㅈ
-		case 0x11BE:
-			fallthrough // ㅊ
-		case 0x11C0: // ㅌ
-			return "nn", true
-		case 0x11B7:
-			fallthrough // ㅁ
-		case 0x11B8: // ㅂ
-			return "mn", true
-		case 0x11BC:
-			return "ngn", true // ㅇ
-		default:
-			return "", false
-		}
-	case 0x1106: // ㅁ
-		switch previousEnding {
-		case 0x11A8:
-			return "ngm", true // ㄱ
-		case 0x11AE:
-			fallthrough // ㄷ
-		case 0x11BA:
-			fallthrough // ㅅ
-		case 0x11BD:
-			fallthrough // ㅈ
-		case 0x11BE:
-			fallthrough // ㅊ
-		case 0x11C0: // ㅌ
-			return "nm", true
-		case 0x11B8:
-			return "mm", true // ㅂ
-		default:
-			return "", false
-		}
-	case 0x110B: // ㅇ
-		switch previousEnding {
-		case 0x11A8:
-			return "g", true // ㄱ
-		case 0x11AE:
-			return "d", true // ㄷ
-		case 0x11AF:
-			return "r", true // ㄹ
-		case 0x11B8:
-			return "b", true // ㅂ
-		case 0x11BA:
-			return "s", true // ㅅ
-		case 0x11BC:
-			return "ng-", true // ㅇ
-		case 0x11BD:
-			return "j", true // ㅈ
-		case 0x11BE:
-			return "ch", true // ㅊ
-		default:
-			return "", false
-		}
-	case 0x110F: // ㅋ
-		switch previousEnding {
-		case 0x11A8:
-			return "k-k", true // ㄱ
-		default:
-			return "", false
-		}
-	case 0x1110: // ㅌ
-		switch previousEnding {
-		case 0x11AE:
-			fallthrough // ㄷ
-		case 0x11BA:
-			fallthrough // ㅅ
-		case 0x11BD:
-			fallthrough // ㅈ
-		case 0x11BE:
-			fallthrough // ㅊ
-		case 0x11C0: // ㅌ
-			return "t-t", true
-		default:
-			return "", false
-		}
-	case 0x1111: // ㅍ
-		switch previousEnding {
-		case 0x11B8:
-			return "p-p", true // ㅂ
-		default:
-			return "", false
-		}
-	default:
-		return "", false
-	}
-}
-
-// Decompose a syllable into several jamo. Does nothing if that isn't possible.
-func decompose(syllable rune) string {
-	return norm.NFD.String(string(syllable))
-}
-
-// Transliterate any Hangul in the given string.
-// Leaves any non-Hangul characters unmodified.
-func (kt *KoreanTranslit) Transliterate(s string) string {
-	if len(s) == 0 {
-		return s
-	}
-
-	builder := &strings.Builder{}
-
-	nextInitialJamoConsumed := false
-
-	for i, syllable := range s {
-		// If character not in blocks, leave it unmodified
-		if !unicode.In(syllable, jamoBlock, syllablesBlock, compatJamoBlock) {
-			builder.WriteRune(syllable)
-			continue
-		}
-
-		jamo := decompose(syllable)
-		for j, char := range jamo {
-			// If we already transliterated the first jamo of this syllable as part of a special
-			// provision, skip it. Otherwise, handle it in the unconditional else branch.
-			if j == 0 && nextInitialJamoConsumed {
-				nextInitialJamoConsumed = false
-				continue
-			}
-
-			// If this is the last jamo of this syllable and not the last syllable of the
-			// string, check for special provisions. If the next char is whitespace or not
-			// Hangul, run translitSpecialProvisions() should return no value.
-			if j == len(jamo)-1 && i < len(s)-1 {
-				nextSyllable := s[i+1]
-				nextJamo := decompose(rune(nextSyllable))[0]
-
-				// Attempt to handle special provision
-				specialProvision, ok := translitSpecialProvisions(char, rune(nextJamo))
-				if ok {
-					builder.WriteString(specialProvision)
-					nextInitialJamoConsumed = true
-				} else {
-					// Not a special provision, transliterate normally
-					builder.WriteString(translitSingleJamo(char))
-				}
-				continue
-			}
-			// Transliterate normally
-			builder.WriteString(translitSingleJamo(char))
-		}
-	}
-	return builder.String()
-}

translit/translit.go

@@ -1,415 +0,0 @@
-package translit
-
-import (
-	"strings"
-)
-
-// Transliterate runs the given maps on s and returns the result
-func Transliterate(s string, useMaps ...string) string {
-	// Create variable to store modified string
-	out := s
-	// If custom map exists
-	if custom, ok := Transliterators["custom"]; ok {
-		// Perform transliteration with it
-		out = custom.Transliterate(out)
-	}
-	// For every map to use
-	for _, useMap := range useMaps {
-		// If custom, skip
-		if useMap == "custom" {
-			continue
-		}
-		// Get requested map
-		transliterator, ok := Transliterators[useMap]
-		if !ok {
-			continue
-		}
-		transliterator.Init()
-		// Perform transliteration
-		out = transliterator.Transliterate(out)
-	}
-	// Return result
-	return out
-}
-
-// Transliterator is implemented by anything with a
-// Transliterate method, which performs transliteration
-// and returns the resulting string.
-type Transliterator interface {
-	Transliterate(string) string
-	Init()
-}
-
-// Map implements Transliterator using a slice where
-// every even element is a key and every odd one is a value
-// which replaces the key.
-type Map []string
-
-func (mt Map) Transliterate(s string) string {
-	return strings.NewReplacer(mt...).Replace(s)
-}
-
-func (Map) Init() {}
-
-// Transliterators stores transliterator implementations for each supported language.
-// Some of these were sourced from https://codeberg.org/Freeyourgadget/Gadgetbridge
-var Transliterators = map[string]Transliterator{
-	"eASCII": Map{
-		"œ", "oe",
-		"ª", "a",
-		"°", "o",
-		"«", `"`,
-		"»", `"`,
-	},
-	"Scandinavian": Map{
-		"Æ", "Ae",
-		"æ", "ae",
-		"Ø", "Oe",
-		"ø", "oe",
-		"Å", "Aa",
-		"å", "aa",
-	},
-	"German": Map{
-		"ä", "ae",
-		"ö", "oe",
-		"ü", "ue",
-		"Ä", "Ae",
-		"Ö", "Oe",
-		"Ü", "Ue",
-		"ß", "ss",
-		"ẞ", "SS",
-	},
-	"Hebrew": Map{
-		"א", "a",
-		"ב", "b",
-		"ג", "g",
-		"ד", "d",
-		"ה", "h",
-		"ו", "u",
-		"ז", "z",
-		"ח", "kh",
-		"ט", "t",
-		"י", "y",
-		"כ", "c",
-		"ל", "l",
-		"מ", "m",
-		"נ", "n",
-		"ס", "s",
-		"ע", "'",
-		"פ", "p",
-		"צ", "ts",
-		"ק", "k",
-		"ר", "r",
-		"ש", "sh",
-		"ת", "th",
-		"ף", "f",
-		"ץ", "ts",
-		"ך", "ch",
-		"ם", "m",
-		"ן", "n",
-	},
-	"Greek": Map{
-		"α", "a",
-		"ά", "a",
-		"β", "v",
-		"γ", "g",
-		"δ", "d",
-		"ε", "e",
-		"έ", "e",
-		"ζ", "z",
-		"η", "i",
-		"ή", "i",
-		"θ", "th",
-		"ι", "i",
-		"ί", "i",
-		"ϊ", "i",
-		"ΐ", "i",
-		"κ", "k",
-		"λ", "l",
-		"μ", "m",
-		"ν", "n",
-		"ξ", "ks",
-		"ο", "o",
-		"ό", "o",
-		"π", "p",
-		"ρ", "r",
-		"σ", "s",
-		"ς", "s",
-		"τ", "t",
-		"υ", "y",
-		"ύ", "y",
-		"ϋ", "y",
-		"ΰ", "y",
-		"φ", "f",
-		"χ", "ch",
-		"ψ", "ps",
-		"ω", "o",
-		"ώ", "o",
-		"Α", "A",
-		"Ά", "A",
-		"Β", "B",
-		"Γ", "G",
-		"Δ", "D",
-		"Ε", "E",
-		"Έ", "E",
-		"Ζ", "Z",
-		"Η", "I",
-		"Ή", "I",
-		"Θ", "Th",
-		"Ι", "I",
-		"Ί", "I",
-		"Ϊ", "I",
-		"Κ", "K",
-		"Λ", "L",
-		"Μ", "M",
-		"Ν", "N",
-		"Ξ", "Ks",
-		"Ο", "O",
-		"Ό", "O",
-		"Π", "P",
-		"Ρ", "R",
-		"Σ", "S",
-		"Τ", "T",
-		"Υ", "Y",
-		"Ύ", "Y",
-		"Ϋ", "Y",
-		"Φ", "F",
-		"Χ", "Ch",
-		"Ψ", "Ps",
-		"Ω", "O",
-		"Ώ", "O",
-	},
-	"Russian": Map{
-		"Ё", "Йo",
-		"ё", "йo",
-	},
-	"Ukranian": Map{
-		"ґ", "gh",
-		"є", "je",
-		"і", "i",
-		"ї", "ji",
-		"Ґ", "Gh",
-		"Є", "Je",
-		"І", "I",
-		"Ї", "JI",
-	},
-	"Arabic": Map{
-		"ا", "a",
-		"ب", "b",
-		"ت", "t",
-		"ث", "th",
-		"ج", "j",
-		"ح", "7",
-		"خ", "5",
-		"د", "d",
-		"ذ", "th",
-		"ر", "r",
-		"ز", "z",
-		"س", "s",
-		"ش", "sh",
-		"ص", "9",
-		"ض", "9'",
-		"ط", "6",
-		"ظ", "6'",
-		"ع", "3",
-		"غ", "3'",
-		"ف", "f",
-		"ق", "q",
-		"ك", "k",
-		"ل", "l",
-		"م", "m",
-		"ن", "n",
-		"ه", "h",
-		"و", "w",
-		"ي", "y",
-		"ى", "a",
-		"ﺓ", "",
-		"آ", "2",
-		"ئ", "2",
-		"إ", "2",
-		"ؤ", "2",
-		"أ", "2",
-		"ء", "2",
-		"٠", "0",
-		"١", "1",
-		"٢", "2",
-		"٣", "3",
-		"٤", "4",
-		"٥", "5",
-		"٦", "6",
-		"٧", "7",
-		"٨", "8",
-		"٩", "9",
-	},
-	"Farsi": Map{
-		"پ", "p",
-		"چ", "ch",
-		"ژ", "zh",
-		"ک", "k",
-		"گ", "g",
-		"ی", "y",
-		"\u200c", " ",
-		"؟", "?",
-		"٪", "%",
-		"؛", ";",
-		"،", ":",
-		"۱", "1",
-		"۲", "2",
-		"۳", "3",
-		"۴", "4",
-		"۵", "5",
-		"۶", "6",
-		"۷", "7",
-		"۸", "8",
-		"۹", "9",
-		"۰", "0",
-		"»", "<",
-		"«", ">",
-		"ِ", "e",
-		"َ", "a",
-		"ُ", "o",
-		"ّ", "",
-	},
-	"Polish": Map{
-		"Ł", "L",
-		"ł", "l",
-	},
-	"Lithuanian": Map{
-		"ą", "a",
-		"č", "c",
-		"ę", "e",
-		"ė", "e",
-		"į", "i",
-		"š", "s",
-		"ų", "u",
-		"ū", "u",
-		"ž", "z",
-	},
-	"Estonian": Map{
-		"ä", "a",
-		"Ä", "A",
-		"ö", "o",
-		"õ", "o",
-		"Ö", "O",
-		"Õ", "O",
-		"ü", "u",
-		"Ü", "U",
-	},
-	"Icelandic": Map{
-		"Þ", "Th",
-		"þ", "th",
-		"Ð", "D",
-		"ð", "d",
-	},
-	"Czech": Map{
-		"ř", "r",
-		"ě", "e",
-		"ý", "y",
-		"á", "a",
-		"í", "i",
-		"é", "e",
-		"ó", "o",
-		"ú", "u",
-		"ů", "u",
-		"ď", "d",
-		"ť", "t",
-		"ň", "n",
-	},
-	"French": Map{
-		"à", "a",
-		"â", "a",
-		"é", "e",
-		"è", "e",
-		"ê", "e",
-		"ë", "e",
-		"ù", "u",
-		"ü", "u",
-		"ÿ", "y",
-		"ç", "c",
-	},
-	"Romanian": Map{
-		"ă", "a",
-		"Ă", "A",
-		"â", "a",
-		"Â", "A",
-		"î", "i",
-		"Î", "I",
-		"ș", "s",
-		"Ș", "S",
-		"ț", "t",
-		"Ț", "T",
-		"ş", "s",
-		"Ş", "S",
-		"ţ", "t",
-		"Ţ", "T",
-		"„", "\"",
-		"”", "\"",
-	},
-	"Emoji": Map{
-		"😂", "XD",
-		"🤣", "XD",
-		"😊", ":)",
-		"☺️", ":)",
-		"😌", ":)",
-		"😃", ":D",
-		"😁", ":D",
-		"😋", ":P",
-		"😛", ":P",
-		"😜", ";P",
-		"🙃", "(:",
-		"😎", "8)",
-		"😶", ":#",
-		"😩", "-_-",
-		"😕", ":(",
-		"😏", ":‑J",
-		"💜", "<3",
-		"💖", "<3",
-		"💗", "<3",
-		"❤️", "<3",
-		"💕", "<3",
-		"💞", "<3",
-		"💘", "<3",
-		"💓", "<3",
-		"💚", "<3",
-		"💙", "<3",
-		"💟", "<3",
-		"❣️", "<3!",
-		"💔", "</3",
-		"😱", "D:",
-		"😮", ":O",
-		"😯", ":O",
-		"😝", "xP",
-		"🤔", "',:-|",
-		"😔", ":|",
-		"😍", ":*",
-		"😘", ":*",
-		"😚", ":*",
-		"😙", ":*",
-		"👍", ":thumbsup:",
-		"👌", ":ok_hand:",
-		"🤞", ":crossed_fingers:",
-		"✌️", ":victory_hand:",
-		"🌄", ":sunrise_over_mountains:",
-		"🌞", ":sun_with_face:",
-		"🤗", ":hugging_face:",
-		"🌻", ":sunflower:",
-		"🥱", ":yawning_face:",
-		"🙄", ":face_with_rolling_eyes:",
-		"🔫", ":gun:",
-		"🥔", ":potato:",
-		"😬", ":E",
-		"✨", "***",
-		"🌌", "***",
-		"💀", "8-X",
-		"😅", "':D",
-		"😢", ":'(",
-		"💯", ":100:",
-		"🔥", ":fire:",
-		"😉", ";)",
-		"😴", ":zzz:",
-		"💤", ":zzz:",
-	},
-	"Korean":   &KoreanTranslit{},
-	"Chinese":  &ChineseTranslit{},
-	"Armenian": &ArmenianTranslit{},
-}

version.go

@@ -1,8 +0,0 @@
-package main
-
-import _ "embed"
-
-//go:generate scripts/gen-version.sh
-
-//go:embed version.txt
-var version string

weather.go

@@ -1,283 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"math"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/rs/zerolog/log"
-	"go.arsenm.dev/infinitime"
-	"go.arsenm.dev/infinitime/weather"
-)
-
-// METResponse represents a response from
-// the MET Norway API
-type METResponse struct {
-	Properties struct {
-		Timeseries []struct {
-			Time time.Time
-			Data METData
-		}
-	}
-}
-
-// METData represents data in a METResponse
-type METData struct {
-	Instant struct {
-		Details struct {
-			AirPressure       float32 `json:"air_pressure_at_sea_level"`
-			AirTemperature    float32 `json:"air_temperature"`
-			DewPoint          float32 `json:"dew_point_temperature"`
-			CloudAreaFraction float32 `json:"cloud_area_fraction"`
-			FogAreaFraction   float32 `json:"fog_area_fraction"`
-			RelativeHumidity  float32 `json:"relative_humidity"`
-			UVIndex           float32 `json:"ultraviolet_index_clear_sky"`
-			WindDirection     float32 `json:"wind_from_direction"`
-			WindSpeed         float32 `json:"wind_speed"`
-		}
-	}
-	NextHour struct {
-		Summary struct {
-			SymbolCode string `json:"symbol_code"`
-		}
-		Details struct {
-			PrecipitationAmount float32 `json:"precipitation_amount"`
-		}
-	} `json:"next_1_hours"`
-}
-
-// OSMData represents lat/long data from
-// OpenStreetMap Nominatim
-type OSMData []struct {
-	Lat string `json:"lat"`
-	Lon string `json:"lon"`
-}
-
-var sendWeatherCh = make(chan struct{}, 1)
-
-func initWeather(ctx context.Context, dev *infinitime.Device) error {
-	if !k.Bool("weather.enabled") {
-		return nil
-	}
-
-	// Get location based on string in config
-	lat, lon, err := getLocation(ctx, k.String("weather.location"))
-	if err != nil {
-		return err
-	}
-
-	timer := time.NewTimer(time.Hour)
-
-	go func() {
-		for {
-			// Attempt to get weather
-			data, err := getWeather(ctx, lat, lon)
-			if err != nil {
-				log.Warn().Err(err).Msg("Error getting weather data")
-				// Wait 15 minutes before retrying
-				time.Sleep(15 * time.Minute)
-				continue
-			}
-
-			// Get current data
-			current := data.Properties.Timeseries[0]
-			currentData := current.Data.Instant.Details
-
-			// Add temperature event
-			err = dev.AddWeatherEvent(weather.TemperatureEvent{
-				TimelineHeader: weather.NewHeader(
-					weather.EventTypeTemperature,
-					time.Hour,
-				),
-				Temperature: int16(round(currentData.AirTemperature * 100)),
-				DewPoint:    int16(round(currentData.DewPoint)),
-			})
-			if err != nil {
-				log.Error().Err(err).Msg("Error adding temperature event")
-			}
-
-			// Add precipitation event
-			err = dev.AddWeatherEvent(weather.PrecipitationEvent{
-				TimelineHeader: weather.NewHeader(
-					weather.EventTypePrecipitation,
-					time.Hour,
-				),
-				Type:   parseSymbol(current.Data.NextHour.Summary.SymbolCode),
-				Amount: uint8(round(current.Data.NextHour.Details.PrecipitationAmount)),
-			})
-			if err != nil {
-				log.Error().Err(err).Msg("Error adding precipitation event")
-			}
-
-			// Add wind event
-			err = dev.AddWeatherEvent(weather.WindEvent{
-				TimelineHeader: weather.NewHeader(
-					weather.EventTypeWind,
-					time.Hour,
-				),
-				SpeedMin:     uint8(round(currentData.WindSpeed)),
-				SpeedMax:     uint8(round(currentData.WindSpeed)),
-				DirectionMin: uint8(round(currentData.WindDirection)),
-				DirectionMax: uint8(round(currentData.WindDirection)),
-			})
-			if err != nil {
-				log.Error().Err(err).Msg("Error adding wind event")
-			}
-
-			// Add cloud event
-			err = dev.AddWeatherEvent(weather.CloudsEvent{
-				TimelineHeader: weather.NewHeader(
-					weather.EventTypeClouds,
-					time.Hour,
-				),
-				Amount: uint8(round(currentData.CloudAreaFraction)),
-			})
-			if err != nil {
-				log.Error().Err(err).Msg("Error adding clouds event")
-			}
-
-			// Add humidity event
-			err = dev.AddWeatherEvent(weather.HumidityEvent{
-				TimelineHeader: weather.NewHeader(
-					weather.EventTypeHumidity,
-					time.Hour,
-				),
-				Humidity: uint8(round(currentData.RelativeHumidity)),
-			})
-			if err != nil {
-				log.Error().Err(err).Msg("Error adding humidity event")
-			}
-
-			// Add pressure event
-			err = dev.AddWeatherEvent(weather.PressureEvent{
-				TimelineHeader: weather.NewHeader(
-					weather.EventTypePressure,
-					time.Hour,
-				),
-				Pressure: int16(round(currentData.AirPressure)),
-			})
-			if err != nil {
-				log.Error().Err(err).Msg("Error adding pressure event")
-			}
-
-			// Reset timer to 1 hour
-			timer.Stop()
-			timer.Reset(time.Hour)
-
-			// Wait for timer to fire or manual update signal
-			select {
-			case <-timer.C:
-			case <-sendWeatherCh:
-			}
-		}
-	}()
-	return nil
-}
-
-// getLocation returns the latitude and longitude
-// given a location
-func getLocation(ctx context.Context, loc string) (lat, lon float64, err error) {
-	// Create request URL and perform GET request
-	reqURL := fmt.Sprintf("https://nominatim.openstreetmap.org/search.php?q=%s&format=jsonv2", url.QueryEscape(loc))
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, reqURL, nil)
-	if err != nil {
-		return
-	}
-	res, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return
-	}
-
-	// Decode JSON from response into OSMData
-	data := OSMData{}
-	err = json.NewDecoder(res.Body).Decode(&data)
-	if err != nil {
-		return
-	}
-	// If no data points
-	if len(data) == 0 {
-		return
-	}
-
-	// Get first data point
-	out := data[0]
-
-	// Attempt to parse latitude
-	lat, err = strconv.ParseFloat(out.Lat, 64)
-	if err != nil {
-		return
-	}
-	// Attempt to parse longitude
-	lon, err = strconv.ParseFloat(out.Lon, 64)
-	if err != nil {
-		return
-	}
-
-	return
-}
-
-// getWeather gets weather data given a latitude and longitude
-func getWeather(ctx context.Context, lat, lon float64) (*METResponse, error) {
-	// Create new GET request
-	req, err := http.NewRequestWithContext(
-		ctx,
-		http.MethodGet,
-		fmt.Sprintf(
-			"https://api.met.no/weatherapi/locationforecast/2.0/complete?lat=%.2f&lon=%.2f",
-			lat,
-			lon,
-		),
-		nil,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	// Set identifying user agent as per NMI requirements
-	req.Header.Set("User-Agent", fmt.Sprintf("ITD/%s gitea.arsenm.dev/Arsen6331/itd", version))
-
-	// Perform request
-	res, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-
-	// Decode JSON from response to METResponse struct
-	out := &METResponse{}
-	err = json.NewDecoder(res.Body).Decode(out)
-	if err != nil {
-		return nil, err
-	}
-
-	return out, nil
-}
-
-// parseSymbol determines what type of precipitation a symbol code
-// codes for.
-func parseSymbol(symCode string) weather.PrecipitationType {
-	switch {
-	case strings.Contains(symCode, "lightrain"):
-		return weather.PrecipitationTypeRain
-	case strings.Contains(symCode, "rain"):
-		return weather.PrecipitationTypeRain
-	case strings.Contains(symCode, "snow"):
-		return weather.PrecipitationTypeSnow
-	case strings.Contains(symCode, "sleet"):
-		return weather.PrecipitationTypeSleet
-	case strings.Contains(symCode, "snow"):
-		return weather.PrecipitationTypeSnow
-	default:
-		return weather.PrecipitationTypeNone
-	}
-}
-
-// round rounds 32-bit floats to 32-bit integers
-func round(f float32) int32 {
-	return int32(math.Round(float64(f)))
-}