File actuated-cli-0.2.6.obscpio of Package actuated-cli

Overview Repositories Revisions Requests Users Attributes Meta

File actuated-cli-0.2.6.obscpio of Package actuated-cli (Revision 220dba8fe3716023744439e1ff1f6e69)

Currently displaying revision 220dba8fe3716023744439e1ff1f6e69 , Show latest

07070100000000000081A400000000000000000000000166C357AD0000005A000000000000000000000000000000000000001E00000000actuated-cli-0.2.6/.DEREK.ymlredirect: https://raw.githubusercontent.com/self-actuated/actions-usage/master/.DEREK.yml
07070100000001000041ED00000000000000000000000266C357AD00000000000000000000000000000000000000000000001B00000000actuated-cli-0.2.6/.github07070100000002000041ED00000000000000000000000266C357AD00000000000000000000000000000000000000000000002500000000actuated-cli-0.2.6/.github/workflows07070100000003000081A400000000000000000000000166C357AD00000175000000000000000000000000000000000000002F00000000actuated-cli-0.2.6/.github/workflows/build.ymlname: build

on:
  push:
    branches:
    - '*'
  pull_request:
    branches:
    - '*'

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@master
        with:
          fetch-depth: 1
      - name: Install Go
        uses: actions/setup-go@master
        with:
          go-version: 1.22.x
      - name: Make dist
        run: make dist
07070100000004000081A400000000000000000000000166C357AD00000219000000000000000000000000000000000000003100000000actuated-cli-0.2.6/.github/workflows/publish.ymlname: publish

on:
  push:
    tags:
      - '*'

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@master
        with:
          fetch-depth: 1
      - name: Install Go
        uses: actions/setup-go@master
        with:
          go-version: 1.22.x
      - name: Make dist
        run: make dist
      - name: Upload release binaries
        uses: alexellis/upload-assets@0.4.1
        env:
          GITHUB_TOKEN: ${{ github.token }}
        with:
          asset_paths: '["./bin/actuated-cli*"]'
07070100000005000081A400000000000000000000000166C357AD00000013000000000000000000000000000000000000001E00000000actuated-cli-0.2.6/.gitignore/actuated-cli
/bin
07070100000006000081A400000000000000000000000166C357AD0000042E000000000000000000000000000000000000001B00000000actuated-cli-0.2.6/LICENSEMIT License

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
07070100000007000081A400000000000000000000000166C357AD00000463000000000000000000000000000000000000001C00000000actuated-cli-0.2.6/MakefileSOURCE_DIRS = main.go cmd pkg
export GO111MODULE=on

Version := $(shell git describe --tags --dirty)
GitCommit := $(shell git rev-parse HEAD)

LDFLAGS := "-s -w -X github.com/self-actuated/actuated-cli/pkg.Version=$(Version) -X github.com/self-actuated/actuated-cli/pkg.GitCommit=$(GitCommit)"

.PHONY: all
all: gofmt test build dist

.PHONY: build
build:
	go build

.PHONY: gofmt
gofmt:
	@test -z $(shell gofmt -l -s $(SOURCE_DIRS) ./ | tee /dev/stderr) || (echo "[WARN] Fix formatting issues with 'make gofmt'" && exit 1)

.PHONY: test
test:
	CGO_ENABLED=0 go test $(shell go list ./... | grep -v /vendor/|xargs echo) -cover

.PHONY: dist
dist:
	mkdir -p bin
	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags $(LDFLAGS) -o bin/actuated-cli
	CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags $(LDFLAGS) -o bin/actuated-cli-arm64
	CGO_ENABLED=0 GOOS=darwin go build -ldflags $(LDFLAGS) -o bin/actuated-cli-darwin
	CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -ldflags $(LDFLAGS)  -o bin/actuated-cli-darwin-arm64
	CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -ldflags $(LDFLAGS) -o bin/actuated-cli.exe
07070100000008000081A400000000000000000000000166C357AD00000FA8000000000000000000000000000000000000001D00000000actuated-cli-0.2.6/README.md# actuated-cli

The actuated-cli requires an access token for GitHub and is designed to be used by a user with access to the actuated dashboard.

Most of the operations on the actuated dashboard are available as CLI commands.

## Installation

Download the latest release from the [releases page](https://github.com/self-actuated/actuated-cli/releases).

Then add the URL to either .bashrc or .zshrc:

```bash
export ACTUATED_URL=https://example.com
```

Or, run this command in a shell before executing any of the CLI commands.

## Obtain a token from GitHub for your own account

You can perform this step using GitHub's Device Flow:

```bash
actuated-cli auth
```

Or you can obtain a Personal Access Token (PAT) manually from [https://github.com/settings/tokens](https://github.com/settings/tokens)

In either case, saving the token to `$HOME/.actuated/PAT` will mean you can avoid having to pass in the `--token` flag to each command.

## View queued jobs

```bash
actuated-cli jobs actuated-samples
```

## View runners for organization

```bash
actuated-cli runners actuated-samples
```

## View SSH sessions available:

```bash
actuated-cli ssh ls
```

Hosts are ordered by the connected time.

```bash
| NO  |   ACTOR   |                 HOSTNAME                 |  RX   |  TX   | CONNECTED |
|-----|-----------|------------------------------------------|-------|-------|-----------|
|   1 | alexellis | 6aafd53144e2f00ef5cd2c16681eeab4712561a6 | 13679 | 10371 | 6m4s      |
|   2 | alexellis | fv-az268-245                             | 23124 | 13828 | 12m2s     |
```

## Connect to an SSH session

Connect to the first available session from your account:

```bash
actuated-cli ssh connect
```

Connected to the second session in the list:

```bash
actuated-cli ssh connect 2
```

Connect to a specific session by hostname:

```bash
actuated-cli ssh connect runner1
```

Connect to a specific session with a host prefix:

```bash
actuated-cli ssh connect 6aafd
```

## Check the logs of VMs

View the serial console and systemd output of the VMs launched on a specific server.

* Check for timeouts with GitHub's control-plane
* View output from the GitHub runner binary
* See boot-up messages
* Check for errors if the GitHub Runner binary is out of date

```bash
actuated-cli logs \
    --owner actuated-samples \
    --age 15m \
    server1
```

The age is specified as a Go duration i.e. `60m` or `24h`.

You can also get the logs for a specific runner by using the `--id` flag.

```bash
actuated-cli logs \
    --owner actuated-samples \
    --id ea5c285282620927689d90af3cfa3be2d5e2d004 \
    server1
```

## Check the logs of the actuated agent service

Show the logs of the actuated agent binary running on your server.

View VM launch times, etc.

```bash
actuated-cli agent-logs \
    --owner actuated-samples \
    --age 15m \
    server1
```

## Schedule a repair to re-queue jobs

If a job has been retried for 30 minutes, without a runner to take it, it'll be taken off the queue.

This command will re-queue all jobs that are in a "queued" state.

Run with sparingly because it will launch one VM per job queued.

```bash
actuated-cli repair \
    actuated-samples
```

## Rescue a remote server

Restart the agent by sending a `kill -9` signal:

```bash
actuated-cli restart \
    --owner actuated-samples \
    server1
```

Any inflight VMs will be killed, see also: `actuated-cli update --force`

Reboot the machine, if in an unrecoverable position:

```bash
actuated-cli restart \
    --owner actuated-samples \
    --reboot \
    server1
```

Use with caution, since this may not perform a safe and clean shutdown.

## JSON mode

Add `--json` to any command to get JSON output for scripting.

API rate limits apply, so do not run the CLI within a loop or `watch` command.

## Staff mode

The `--staff` flag can be added to the `runners`, `jobs` and the `repair` commands by OpenFaaS Ltd staff to support actuated customers.

## Help & support

Reach out to our team on Slack.
07070100000009000041ED00000000000000000000000266C357AD00000000000000000000000000000000000000000000001700000000actuated-cli-0.2.6/cmd0707010000000A000081A400000000000000000000000166C357AD00000683000000000000000000000000000000000000002500000000actuated-cli-0.2.6/cmd/agent_logs.gopackage cmd

import (
	"fmt"
	"net/http"
	"os"
	"strings"
	"time"

"github.com/self-actuated/actuated-cli/pkg"
	"github.com/spf13/cobra"
)

func makeAgentLogs() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "agent-logs",
		Short: "Fetch logs from the agent's systemd service",
		Example: `  # Latest logs for a given host:
  actuated agent-logs --owner OWNER HOST

# Latest logs for a given time-range
  actuated agent-logs --owner OWNER --age 1h HOST
  `,
		Aliases: []string{"service-logs"},
	}

cmd.RunE = runAgentLogsE

cmd.Flags().StringP("owner", "o", "", "Owner for the logs")
	cmd.Flags().DurationP("age", "a", time.Minute*15, "Age of logs to fetch")

return cmd
}

func runAgentLogsE(cmd *cobra.Command, args []string) error {
	if len(args) < 1 {
		return fmt.Errorf("specify the host as an argument")
	}
	host := strings.TrimSpace(args[0])

pat, err := getPat(cmd)
	if err != nil {
		return err
	}

staff, err := cmd.Flags().GetBool("staff")
	if err != nil {
		return err
	}

owner, err := cmd.Flags().GetString("owner")
	if err != nil {
		return err
	}

age, err := cmd.Flags().GetDuration("age")
	if err != nil {
		return err
	}

if len(host) == 0 {
		return fmt.Errorf("host is required")
	}

if len(owner) == 0 {
		return fmt.Errorf("owner is required")
	}

if len(pat) == 0 {
		return fmt.Errorf("pat is required")
	}

c := pkg.NewClient(http.DefaultClient, os.Getenv("ACTUATED_URL"))

res, status, err := c.GetAgentLogs(pat, owner, host, age, staff)

if err != nil {
		return err
	}

if status != http.StatusAccepted {
		return fmt.Errorf("unexpected status code: %d, body: %s", status, res)
	}

fmt.Println(res)

return nil

}
0707010000000B000081A400000000000000000000000166C357AD00000C16000000000000000000000000000000000000001F00000000actuated-cli-0.2.6/cmd/auth.go// MIT License
// Copyright (c) 2023 Alex Ellis, OpenFaaS Ltd

package cmd

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"path"
	"time"

"github.com/spf13/cobra"
)

func makeAuth() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "auth",
		Short: "Authenticate to GitHub to obtain a token and save it to $HOME/.actuated/PAT",
	}

cmd.RunE = runAuthE

return cmd
}

func runAuthE(cmd *cobra.Command, args []string) error {

token := ""

clientID := "8c5dc5d9750ff2a8396a"

dcParams := url.Values{}
	dcParams.Set("client_id", clientID)
	dcParams.Set("redirect_uri", "http://127.0.0.1:31111/oauth/callback")
	dcParams.Set("scope", "read:user,read:org,user:email")

req, err := http.NewRequest(http.MethodPost, "https://github.com/login/device/code", bytes.NewBuffer([]byte(dcParams.Encode())))

if err != nil {
		return err
	}

req.Header.Set("Accept", "application/json")
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}

body, _ := io.ReadAll(res.Body)

if res.StatusCode != http.StatusOK {
		return fmt.Errorf("unexpected status code: %d, body: %s", res.StatusCode, string(body))
	}

auth := DeviceAuth{}

if err := json.Unmarshal(body, &auth); err != nil {
		return err
	}

fmt.Printf("Please visit: %s\n", auth.VerificationURI)
	fmt.Printf("and enter the code: %s\n", auth.UserCode)

for i := 0; i < 60; i++ {
		urlv := url.Values{}
		urlv.Set("client_id", clientID)
		urlv.Set("device_code", auth.DeviceCode)

urlv.Set("grant_type", "urn:ietf:params:oauth:grant-type:device_code")
		req.Header.Set("Accept", "application/json")
		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")

req, err := http.NewRequest(http.MethodPost, "https://github.com/login/oauth/access_token", bytes.NewBuffer([]byte(urlv.Encode())))
		if err != nil {
			return err
		}

res, err := http.DefaultClient.Do(req)
		if err != nil {
			return err
		}

body, _ := io.ReadAll(res.Body)
		parts, err := url.ParseQuery(string(body))
		if err != nil {
			return err
		}
		if parts.Get("error") == "authorization_pending" {
			fmt.Println("Waiting for authorization...")
			time.Sleep(time.Second * 5)
			continue
		} else if parts.Get("access_token") != "" {
			// fmt.Println(parts)
			token = parts.Get("access_token")

break
		} else {
			return fmt.Errorf("something went wrong")
		}
	}

const basePath = "$HOME/.actuated"
	os.Mkdir(os.ExpandEnv(basePath), 0755)

if err := os.WriteFile(os.ExpandEnv(path.Join(basePath, "PAT")), []byte(token), 0644); err != nil {
		return err
	}

fmt.Printf("Access token written to: %s\n", os.ExpandEnv(path.Join(basePath, "PAT")))

return nil
}

// DeviceAuth is the device auth response from GitHub and is
// used to exchange for a personal access token
type DeviceAuth struct {
	DeviceCode      string `json:"device_code"`
	UserCode        string `json:"user_code"`
	VerificationURI string `json:"verification_uri"`
	ExpiresIn       int    `json:"expires_in"`
	Interval        int    `json:"interval"`
}
0707010000000C000081A400000000000000000000000166C357AD0000015B000000000000000000000000000000000000002500000000actuated-cli-0.2.6/cmd/controller.gopackage cmd

import (
	"github.com/spf13/cobra"
)

func makeController() *cobra.Command {

controller := &cobra.Command{
		Use:           "controller",
		Short:         "Staff commands for the controller",
		Hidden:        true,
		SilenceErrors: true,
		SilenceUsage:  true,
	}

controller.AddCommand(makeControllerLogs())

return controller
}
0707010000000D000081A400000000000000000000000166C357AD000004D7000000000000000000000000000000000000002A00000000actuated-cli-0.2.6/cmd/controller_logs.gopackage cmd

import (
	"fmt"
	"net/http"
	"os"
	"time"

"github.com/self-actuated/actuated-cli/pkg"
	"github.com/spf13/cobra"
)

func makeControllerLogs() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "logs",
		Short: "Fetch logs from the controller's systemd service",
		Example: `  # Latest logs for a given host:
  actuated controller logs --age 15m
  `,
	}

cmd.RunE = runControllerLogsE

cmd.Flags().DurationP("age", "a", time.Minute*15, "Age of logs to fetch")
	cmd.Flags().StringP("output", "o", "cat", "Output format, use \"cat\" for brevity")

return cmd
}

func runControllerLogsE(cmd *cobra.Command, args []string) error {

pat, err := getPat(cmd)
	if err != nil {
		return err
	}

outputFormat, err := cmd.Flags().GetString("output")
	if err != nil {
		return err
	}
	age, err := cmd.Flags().GetDuration("age")
	if err != nil {
		return err
	}

if len(pat) == 0 {
		return fmt.Errorf("pat is required")
	}

c := pkg.NewClient(http.DefaultClient, os.Getenv("ACTUATED_URL"))

res, status, err := c.GetControllerLogs(pat, outputFormat, age)

if err != nil {
		return err
	}

if status != http.StatusOK {
		return fmt.Errorf("unexpected status code: %d, body: %s", status, res)
	}

fmt.Println(res)

return nil

}
0707010000000E000081A400000000000000000000000166C357AD000005F2000000000000000000000000000000000000002200000000actuated-cli-0.2.6/cmd/disable.gopackage cmd

import (
	"fmt"
	"net/http"
	"os"
	"strings"

"github.com/self-actuated/actuated-cli/pkg"
	"github.com/spf13/cobra"
)

func makeDisable() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "disable",
		Short: "Disable the actuated service remotely.",
		Example: `  # Disable the actuated systemd service from restarting

actuated-cli disable --owner ORG HOST
`,
	}

cmd.RunE = runDisableE

cmd.Flags().StringP("owner", "o", "", "Owner")

return cmd
}

func runDisableE(cmd *cobra.Command, args []string) error {
	if len(args) < 1 {
		return fmt.Errorf("specify the host as an argument")
	}
	host := strings.TrimSpace(args[0])

pat, err := getPat(cmd)
	if err != nil {
		return err
	}

staff, err := cmd.Flags().GetBool("staff")
	if err != nil {
		return err
	}

owner, err := cmd.Flags().GetString("owner")
	if err != nil {
		return err
	}

if len(owner) == 0 {
		return fmt.Errorf("owner is required")
	}

if len(pat) == 0 {
		return fmt.Errorf("pat is required")
	}

c := pkg.NewClient(http.DefaultClient, os.Getenv("ACTUATED_URL"))

res, status, err := c.DisableAgent(pat, owner, host, staff)
	if err != nil {
		return err
	}

if status != http.StatusOK && status != http.StatusAccepted &&
		status != http.StatusNoContent && status != http.StatusCreated {
		return fmt.Errorf("unexpected status code: %d, error: %s", status, res)
	}

fmt.Printf("Disable requested for %s, status: %d\n", owner, status)
	if strings.TrimSpace(res) != "" {
		fmt.Printf("Response: %s\n", res)
	}

return nil
}
0707010000000F000081A400000000000000000000000166C357AD000006B5000000000000000000000000000000000000002400000000actuated-cli-0.2.6/cmd/increases.gopackage cmd

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"strings"
	"time"

"github.com/self-actuated/actuated-cli/pkg"
	"github.com/spf13/cobra"
)

func makeIncreases() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "increases",
		Short: "Get job increases for an organisation",
	}

cmd.RunE = runIncreasesE

cmd.Flags().Int("days", 30, "The number of days to look back for increases")
	cmd.Flags().BoolP("json", "j", false, "Request output in JSON format")

return cmd
}

func runIncreasesE(cmd *cobra.Command, args []string) error {

var owner string
	if len(args) == 1 {
		owner = strings.TrimSpace(args[0])
	}

pat, err := getPat(cmd)
	if err != nil {
		return err
	}

staff, err := cmd.Flags().GetBool("staff")
	if err != nil {
		return err
	}

requestJson, err := cmd.Flags().GetBool("json")
	if err != nil {
		return err
	}

if len(pat) == 0 {
		return fmt.Errorf("pat is required")
	}

c := pkg.NewClient(http.DefaultClient, os.Getenv("ACTUATED_URL"))
	days, err := cmd.Flags().GetInt("days")
	if err != nil {
		return err
	}

startDate := time.Now().Add(-1 * time.Duration(days) * 24 * time.Hour)

res, status, err := c.GetBuildIncreases(pat, owner, startDate, staff, requestJson)
	if err != nil {
		return err
	}

if status != http.StatusOK {
		return fmt.Errorf("unexpected status code: %d, message: %s", status, string(res))
	}

if requestJson {

var prettyJSON bytes.Buffer
		err := json.Indent(&prettyJSON, []byte(res), "", "  ")
		if err != nil {
			return err
		}
		res = prettyJSON.String()
	}

yr, isoWeek := startDate.ISOWeek()
	fmt.Printf("Start date: %s\tWeek: %d (%d)\n",
		startDate.Format("2006-01-02"),
		isoWeek,
		yr)
	fmt.Println(res)

return nil

}
07070100000010000081A400000000000000000000000166C357AD0000107B000000000000000000000000000000000000001F00000000actuated-cli-0.2.6/cmd/jobs.gopackage cmd

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
	"text/tabwriter"
	"time"

"github.com/docker/go-units"

"github.com/self-actuated/actuated-cli/pkg"
	"github.com/spf13/cobra"
)

func makeJobs() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "jobs",
		Short: "List jobs in the build queue",
		Example: `  # Check queued and in_progress jobs for an organisation
  actuated-cli jobs ORG
  
  # Get the same result, but in JSON format
  actuated-cli jobs ORG --json
  
  # Check queued and in_progress jobs for a customer
  actuated-cli jobs --staff CUSTOMER
`,
	}

cmd.RunE = runJobsE

cmd.Flags().BoolP("verbose", "v", false, "Show additional columns in the output")

cmd.Flags().BoolP("json", "j", false, "Request output in JSON format")

return cmd
}

func runJobsE(cmd *cobra.Command, args []string) error {

var owner string
	if len(args) == 1 {
		owner = strings.TrimSpace(args[0])
	}

pat, err := getPat(cmd)
	if err != nil {
		return err
	}

staff, err := cmd.Flags().GetBool("staff")
	if err != nil {
		return err
	}

requestJson, err := cmd.Flags().GetBool("json")
	if err != nil {
		return err
	}

verbose, err := cmd.Flags().GetBool("verbose")
	if err != nil {
		return err
	}

if len(pat) == 0 {
		return fmt.Errorf("pat is required")
	}

c := pkg.NewClient(http.DefaultClient, os.Getenv("ACTUATED_URL"))

acceptJSON := true

res, status, err := c.ListJobs(pat, owner, staff, acceptJSON)

if err != nil {
		return err
	}

if status != http.StatusOK {
		return fmt.Errorf("unexpected status code: %d, message: %s", status, string(res))
	}

if requestJson {

var prettyJSON bytes.Buffer
		err := json.Indent(&prettyJSON, []byte(res), "", "  ")
		if err != nil {
			return err
		}
		res = prettyJSON.String()
		fmt.Println(res)
	} else {

var statuses []JobStatus

if err := json.Unmarshal([]byte(res), &statuses); err != nil {
			return err
		}
		printEvents(os.Stdout, statuses, verbose)
	}

return nil

}

func printEvents(w io.Writer, statuses []JobStatus, verbose bool) {
	tabwriter := tabwriter.NewWriter(w, 0, 0, 1, ' ', tabwriter.TabIndent)
	if verbose {
		fmt.Fprintf(tabwriter, "JOB ID\tOWNER\tREPO\tJOB\tRUNNER\tSERVER\tSTATUS\tSTARTED\tAGE\tLABELS\tURL\n")
	} else {
		fmt.Fprintf(tabwriter, "OWNER\tREPO\tJOB\tSTATUS\tAGE\tURL\n")
	}

for _, status := range statuses {
		duration := ""

if status.StartedAt != nil && !status.StartedAt.IsZero() {
			duration = humanDuration(time.Since(*status.StartedAt))
		}

if verbose {
			fmt.Fprintf(tabwriter, "%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
				status.JobID,
				status.Owner,
				status.Repo,
				status.JobName,
				status.RunnerName,
				status.AgentName,
				status.Status,
				status.StartedAt.Format(time.RFC3339),
				duration,
				strings.Join(status.Labels, ","),
				fmt.Sprintf("https://github.com/%s/%s/runs/%d", status.Owner, status.Repo, status.JobID),
			)
		} else {
			fmt.Fprintf(tabwriter, "%s\t%s\t%s\t%s\t%s\t%s\n",
				status.Owner,
				status.Repo,
				status.JobName,
				status.Status,
				duration,
				fmt.Sprintf("https://github.com/%s/%s/runs/%d", status.Owner, status.Repo, status.JobID))

}

}
	tabwriter.Flush()
}

type JobStatus struct {
	JobID        int64  `json:"job_id"`
	Owner        string `json:"owner"`
	Repo         string `json:"repo"`
	WorkflowName string `json:"workflow_name"`
	JobName      string `json:"job_name"`
	Actor        string `json:"actor,omitempty"`

RunnerName string   `json:"runner_name,omitempty"`
	Status     string   `json:"status"`
	Conclusion string   `json:"conclusion,omitempty"`
	Labels     []string `json:"labels,omitempty"`

UpdatedAt   *time.Time `json:"updated_at"`
	StartedAt   *time.Time `json:"startedAt,omitempty"`
	CompletedAt *time.Time `json:"completedAt,omitempty"`

AgentName string `json:"agent_name,omitempty"`
}

// types.HumanDuration fixes a long string for a value < 1s
func humanDuration(duration time.Duration) string {
	v := strings.ToLower(units.HumanDuration(duration))

if v == "less than a second" {
		return fmt.Sprintf("%d ms", duration.Milliseconds())
	} else if v == "about a minute" {
		return fmt.Sprintf("%d seconds", int(duration.Seconds()))
	}

return v
}
07070100000011000081A400000000000000000000000166C357AD00000741000000000000000000000000000000000000001F00000000actuated-cli-0.2.6/cmd/logs.gopackage cmd

import (
	"fmt"
	"net/http"
	"os"
	"strings"
	"time"

"github.com/self-actuated/actuated-cli/pkg"
	"github.com/spf13/cobra"
)

func makeLogs() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "logs",
		Short: "Fetch logs from VMs",
		Long: `Fetch logs from a specific VM or a all VMs over a 
range of time.`,

Example: `# Logs from all VMs over the past 15 minutes
actuated-cli logs --owner=OWNER --age=15m HOST

# All logs from a specific VM using its hostname as the --id
actuated-cli logs --owner=OWNER --id=ID HOST
`,
	}

cmd.RunE = runLogsE

cmd.Flags().StringP("owner", "o", "", "List logs owned by this user")
	cmd.Flags().String("id", "", "ID variable for a specific runner VM hostname")
	cmd.Flags().DurationP("age", "a", time.Minute*15, "Age of logs to fetch")

return cmd
}

func runLogsE(cmd *cobra.Command, args []string) error {
	if len(args) < 1 {
		return fmt.Errorf("specify the host as an argument")
	}
	host := strings.TrimSpace(args[0])

pat, err := getPat(cmd)
	if err != nil {
		return err
	}

staff, err := cmd.Flags().GetBool("staff")
	if err != nil {
		return err
	}

owner, err := cmd.Flags().GetString("owner")
	if err != nil {
		return err
	}

age, err := cmd.Flags().GetDuration("age")
	if err != nil {
		return err
	}

id, err := cmd.Flags().GetString("id")
	if err != nil {
		return err
	}

if len(host) == 0 {
		return fmt.Errorf("host is required")
	}

if len(owner) == 0 {
		return fmt.Errorf("owner is required")
	}

if len(pat) == 0 {
		return fmt.Errorf("pat is required")
	}

c := pkg.NewClient(http.DefaultClient, os.Getenv("ACTUATED_URL"))

res, status, err := c.GetLogs(pat, owner, host, id, age, staff)

if err != nil {
		return err
	}

if status != http.StatusAccepted {
		return fmt.Errorf("unexpected status code: %d, body: %s", status, res)
	}

fmt.Println(res)

return nil

}
07070100000012000081A400000000000000000000000166C357AD00000760000000000000000000000000000000000000002100000000actuated-cli-0.2.6/cmd/repair.gopackage cmd

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"strings"

"github.com/self-actuated/actuated-cli/pkg"
	"github.com/spf13/cobra"
)

func makeRepair() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "repair",
		Short: "Schedule additional VMs to repair the build queue",
		Long: `Schedule additional VMs to repair the build queue.
Use sparingly, check the build queue to see if there is a need for 
more VMs to be launched. Then, allow ample time for the new VMs to 
pick up a job by checking the build queue again for an in_progress
status.`,
		Example: `  ## Launch VMs for queued jobs in a given organisation
  actuated repair OWNER

## Launch VMs for queued jobs in a given organisation for a customer
  actuated repair --staff OWNER
`,
	}

cmd.RunE = runRepairE

return cmd
}

func runRepairE(cmd *cobra.Command, args []string) error {

var owner string
	if len(args) == 1 {
		owner = strings.TrimSpace(args[0])
	}

pat, err := getPat(cmd)
	if err != nil {
		return err
	}

staff, err := cmd.Flags().GetBool("staff")
	if err != nil {
		return err
	}

if len(owner) == 0 {
		return fmt.Errorf("owner is required")
	}

if len(pat) == 0 {
		return fmt.Errorf("pat is required")
	}

c := pkg.NewClient(http.DefaultClient, os.Getenv("ACTUATED_URL"))

res, status, err := c.Repair(pat, owner, staff)
	if err != nil {
		return err
	}

if status != http.StatusOK && status != http.StatusAccepted &&
		status != http.StatusNoContent && status != http.StatusCreated {
		return fmt.Errorf("unexpected status code: %d", status)
	}

fmt.Printf("Repair requested for %s, status: %d\n", owner, status)
	if strings.TrimSpace(res) != "" {
		repairRes := RepairRes{}
		if err := json.Unmarshal([]byte(res), &repairRes); err != nil {
			return err
		}

fmt.Printf("Requeued VMs: %d\n", repairRes.VMs)
	}

return nil
}

type RepairRes struct {
	VMs int `json:"vms"`
}
07070100000013000081A400000000000000000000000166C357AD000007A7000000000000000000000000000000000000002200000000actuated-cli-0.2.6/cmd/restart.gopackage cmd

import (
	"fmt"
	"net/http"
	"os"
	"strings"

"github.com/self-actuated/actuated-cli/pkg"
	"github.com/spf13/cobra"
)

func makeRestart() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "restart",
		Short: "Forcibly restart the agent by killing it or reboot the machine.",
		Example: `  # Request the agent to restart
  # This will drain any running jobs - do a forced upgrade if you want to 
  # restart gracefully.
  actuated-cli restart --owner ORG HOST

# Reboot the machine, if the agent is not responding.
  # This will not drain any running jobs.
  actuated-cli restart --owner ORG --reboot HOST
`,
	}

cmd.RunE = runRestartE

cmd.Flags().StringP("owner", "o", "", "Owner")
	cmd.Flags().BoolP("reboot", "r", false, "Reboot the machine instead of just restarting the service")

return cmd
}

func runRestartE(cmd *cobra.Command, args []string) error {
	if len(args) < 1 {
		return fmt.Errorf("specify the host as an argument")
	}
	host := strings.TrimSpace(args[0])

pat, err := getPat(cmd)
	if err != nil {
		return err
	}

staff, err := cmd.Flags().GetBool("staff")
	if err != nil {
		return err
	}

owner, err := cmd.Flags().GetString("owner")
	if err != nil {
		return err
	}

reboot, err := cmd.Flags().GetBool("reboot")
	if err != nil {
		return err
	}

if len(owner) == 0 {
		return fmt.Errorf("owner is required")
	}

if len(pat) == 0 {
		return fmt.Errorf("pat is required")
	}

c := pkg.NewClient(http.DefaultClient, os.Getenv("ACTUATED_URL"))

res, status, err := c.RestartAgent(pat, owner, host, reboot, staff)
	if err != nil {
		return err
	}

fmt.Printf("Restart requested for %s, status: %d\n", owner, status)
	if strings.TrimSpace(res) != "" {
		fmt.Printf("Response: %s\n", res)
	}

return nil
}
07070100000014000081A400000000000000000000000166C357AD000008F4000000000000000000000000000000000000001F00000000actuated-cli-0.2.6/cmd/root.gopackage cmd

import (
	"fmt"
	"os"
	"strings"

"github.com/spf13/cobra"
)

var root *cobra.Command

func init() {

root = &cobra.Command{
		Use:   "actuated-cli",
		Short: "The official CLI for actuated",
		Long: `The actuated-cli is for customers and operators to query 
the status of jobs and servers.

Run "actuated-cli auth" to get a Personal Access Token from GitHub

See the project README on GitHub for more:

https://github.com/self-actuated/actuated-cli
`,
		SilenceErrors: true,
		SilenceUsage:  true,
	}

root.PersistentFlags().String("token-value", "", "Personal Access Token")
	root.PersistentFlags().StringP("token", "t", "$HOME/.actuated/PAT", "File to read for Personal Access Token")
	root.PersistentFlags().BoolP("staff", "s", false, "Execute the command as an actuated staff member")

root.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
		if _, ok := os.LookupEnv("ACTUATED_URL"); !ok {
			return fmt.Errorf(`ACTUATED_URL environment variable is not set, see the CLI tab in the dashboard for instructions`)
		}
		return nil
	}

root.AddCommand(makeRunners())
	root.AddCommand(makeJobs())
	root.AddCommand(makeRepair())
	root.AddCommand(makeRestart())

root.AddCommand(makeAgentLogs())
	root.AddCommand(makeLogs())
	root.AddCommand(makeUpgrade())
	root.AddCommand(makeIncreases())

root.AddCommand(makeSSH())
	root.AddCommand(makeDisable())

root.AddCommand(makeAuth())
	root.AddCommand(MakeVersion())

root.AddCommand(makeController())
}

func Execute() error {
	return root.Execute()
}

func getPat(cmd *cobra.Command) (string, error) {
	var (
		pat,
		patFile string
	)

if cmd.Flags().Changed("token-value") {
		v, err := cmd.Flags().GetString("token-value")
		if err != nil {
			return "", err
		}
		pat = v
	} else {
		v, err := cmd.Flags().GetString("token")
		if err != nil {
			return "", err
		}

if len(v) == 0 {
			return "", fmt.Errorf("give --token or --token-value")
		}
		patFile = os.ExpandEnv(v)
	}

if len(patFile) > 0 {
		v, err := readPatFile(patFile)
		if err != nil {
			return "", err
		}
		pat = v
	}

return pat, nil
}

func readPatFile(filePath string) (string, error) {
	patData, err := os.ReadFile(os.ExpandEnv(filePath))
	if err != nil {
		return "", err
	}

return strings.TrimSpace(string(patData)), nil
}
07070100000015000081A400000000000000000000000166C357AD000006A5000000000000000000000000000000000000002200000000actuated-cli-0.2.6/cmd/runners.gopackage cmd

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"strings"

"github.com/self-actuated/actuated-cli/pkg"
	"github.com/spf13/cobra"
)

func makeRunners() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "runners",
		Short: "List runners for an organisation",
		Example: ` # List runners for a given organisation
  actuated-cli runners OWNER
  
  # List runners for all customers
  actuated-cli runners --staff OWNER

# List runners in JSON format
  actuated-cli runners --json OWNER
`,
	}

cmd.RunE = runRunnersE

cmd.Flags().Bool("images", false, "Show the image being used for the rootfs and Kernel")
	cmd.Flags().BoolP("json", "j", false, "Request output in JSON format")

return cmd
}

func runRunnersE(cmd *cobra.Command, args []string) error {

images, err := cmd.Flags().GetBool("images")
	if err != nil {
		return err
	}

var owner string
	if len(args) == 1 {
		owner = strings.TrimSpace(args[0])
	}

pat, err := getPat(cmd)
	if err != nil {
		return err
	}

staff, err := cmd.Flags().GetBool("staff")
	if err != nil {
		return err
	}

requestJson, err := cmd.Flags().GetBool("json")
	if err != nil {
		return err
	}

if len(pat) == 0 {
		return fmt.Errorf("pat is required")
	}

c := pkg.NewClient(http.DefaultClient, os.Getenv("ACTUATED_URL"))

res, status, err := c.ListRunners(pat, owner, staff, images, requestJson)

if err != nil {
		return err
	}

if status != http.StatusOK {
		return fmt.Errorf("unexpected status code: %d", status)
	}

if requestJson {

var prettyJSON bytes.Buffer
		err := json.Indent(&prettyJSON, []byte(res), "", "  ")
		if err != nil {
			return err
		}
		res = prettyJSON.String()
	}
	fmt.Println(res)

return nil

}
07070100000016000081A400000000000000000000000166C357AD000001B3000000000000000000000000000000000000001E00000000actuated-cli-0.2.6/cmd/ssh.gopackage cmd

import (
	"github.com/spf13/cobra"
)

func makeSSH() *cobra.Command {

ssh := &cobra.Command{
		Use:   "ssh",
		Short: "List and connect to SSH sessions",
		Long: `List and connect to SSH sessions to explore the environment
or debug a problem with a build.`,
		Aliases:       []string{"s"},
		SilenceErrors: true,
		SilenceUsage:  true,
	}

ssh.AddCommand(makeSshList())
	ssh.AddCommand(makeSshConnect())

return ssh
}
07070100000017000081A400000000000000000000000166C357AD00000B98000000000000000000000000000000000000002600000000actuated-cli-0.2.6/cmd/ssh_connect.gopackage cmd

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"os"
	"os/exec"
	"sort"
	"strconv"
	"strings"

"github.com/google/go-github/v52/github"
	"github.com/spf13/cobra"
	"golang.org/x/oauth2"
)

func makeSshConnect() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "connect",
		Short: "Connected to an SSH session",
		Example: `  # Connect to the first session
  actuated-cli ssh connect

# Connect to a specific session
  actuated-cli ssh connect HOST
`,
		Aliases: []string{"c"},
	}

cmd.RunE = runSshConnectE

cmd.Flags().Bool("print", false, "Print the SSH command instead of running it")

return cmd
}

func runSshConnectE(cmd *cobra.Command, args []string) error {
	pat, err := getPat(cmd)
	if err != nil {
		return err
	}

printOnly, err := cmd.Flags().GetBool("print")
	if err != nil {
		return err
	}

host := ""
	hostIndex := 0
	useIndex := false

if len(args) > 0 {
		host = args[0]
		if i, err := strconv.Atoi(host); err == nil {
			useIndex = true
			hostIndex = i
		}
	}

ctx := context.Background()
	ts := oauth2.StaticTokenSource(
		&oauth2.Token{AccessToken: pat},
	)
	tc := oauth2.NewClient(ctx, ts)

client := github.NewClient(tc)

user, _, err := client.Users.Get(ctx, "")
	if err != nil {
		return err
	}

u, _ := url.Parse(SshGw)
	u.Path = "/list"
	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	if err != nil {
		return err
	}
	req.Header.Set("Accept", "application/json")

res, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()

sessions := []sshSession{}
	if err = json.NewDecoder(res.Body).Decode(&sessions); err != nil {
		return err
	}

onlyActor := []sshSession{}
	for _, session := range sessions {
		if session.Actor == login {
			onlyActor = append(onlyActor, session)
		}
	}

sort.Slice(onlyActor, func(i, j int) bool {
		return onlyActor[i].ConnectedAt > onlyActor[j].ConnectedAt
	})

if len(onlyActor) == 0 {
		return fmt.Errorf("no sessions found")
	}

var found *sshSession
	for i, session := range onlyActor {
		if host == "" {
			found = &session
			break
		} else if session.Hostname == host {
			found = &session
			break
		} else if useIndex && hostIndex == i+1 {
			found = &session
			break
		}
	}

// Try a fuzzy match
	if found == nil {
		for _, session := range onlyActor {
			if strings.HasPrefix(session.Hostname, host) {
				found = &session
				break
			}
		}
	}

if found == nil {
		return fmt.Errorf("no session found for hostname %s", host)
	}

us, _ := url.Parse(SshGw)
	sshArgs := []string{"-p", strconv.Itoa(found.Port), "runner@" + us.Host, "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null"}

if printOnly {
		fmt.Printf("ssh %s\n", strings.Join(sshArgs, " "))
		return nil
	}

sshCmd := exec.CommandContext(ctx, "ssh", sshArgs...)

sshCmd.Stdin = os.Stdin
	sshCmd.Stdout = os.Stdout

if err = sshCmd.Run(); err != nil {
		return err
	}

return nil
}
07070100000018000081A400000000000000000000000166C357AD00000B18000000000000000000000000000000000000002100000000actuated-cli-0.2.6/cmd/ssh_ls.gopackage cmd

import (
	"bytes"
	"context"
	"encoding/json"
	"net/http"
	"net/url"
	"os"
	"sort"
	"strconv"
	"time"

"github.com/google/go-github/v52/github"
	"github.com/olekukonko/tablewriter"
	"github.com/spf13/cobra"
	"golang.org/x/oauth2"
)

const SshGw = "https://sshgw.actuated.dev"

func makeSshList() *cobra.Command {
	cmd := &cobra.Command{
		Use:     "list",
		Aliases: []string{"ls", "l"},
		Short:   "List SSH sessions",
	}

cmd.Flags().BoolP("json", "j", false, "Request output in JSON format")

cmd.RunE = runSshListE

return cmd
}

func runSshListE(cmd *cobra.Command, args []string) error {

pat, err := getPat(cmd)
	if err != nil {
		return err
	}

ctx := context.Background()
	ts := oauth2.StaticTokenSource(
		&oauth2.Token{AccessToken: pat},
	)
	tc := oauth2.NewClient(ctx, ts)

client := github.NewClient(tc)

user, _, err := client.Users.Get(ctx, "")
	if err != nil {
		return err
	}

u, _ := url.Parse(SshGw)
	u.Path = "/list"
	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	if err != nil {
		return err
	}
	req.Header.Set("Accept", "application/json")

res, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()

jsonFormat, err := cmd.Flags().GetBool("json")
	if err != nil {
		return err
	}

buf := bytes.NewBuffer(nil)
	table := tablewriter.NewWriter(buf)

table.SetHeader([]string{"No.", "Actor", "Hostname", "RX", "TX", "Connected"})

table.SetBorders(tablewriter.Border{Left: true, Top: false, Right: true, Bottom: false})
	table.SetCenterSeparator("|")
	table.SetAutoWrapText(false)

var sessions []sshSession
	if err := json.NewDecoder(res.Body).Decode(&sessions); err != nil {
		return err
	}

onlyActor := []sshSession{}
	for _, session := range sessions {
		if session.Actor == login {
			onlyActor = append(onlyActor, session)
		}
	}

sort.Slice(onlyActor, func(i, j int) bool {
		return onlyActor[i].ConnectedAt > onlyActor[j].ConnectedAt
	})

for i, session := range onlyActor {
		connectedAt, _ := time.Parse(time.RFC3339, session.ConnectedAt)
		since := time.Since(connectedAt).Round(time.Second)
		table.Append([]string{
			strconv.Itoa(i + 1),
			session.Actor,
			session.Hostname,
			strconv.Itoa(session.Rx),
			strconv.Itoa(session.Tx),
			since.String(),
		})
	}

if jsonFormat {
		e := json.NewEncoder(os.Stdout)
		e.SetIndent("", "  ")
		if err := e.Encode(onlyActor); err != nil {
			return err
		}
		return nil
	}

table.Render()

cmd.Print(buf.String())

return nil

}

type sshSession struct {
	ConnectedAt string `json:"ConnectedAt"`
	Command     string `json:"Command"`
	Hostname    string `json:"Hostname"`
	Port        int    `json:"Port"`
	Actor       string `json:"Actor"`
	Rx          int    `json:"Rx"`
	Tx          int    `json:"Tx"`
	Connections int    `json:"Connections"`
}
07070100000019000081A400000000000000000000000166C357AD00000D69000000000000000000000000000000000000002200000000actuated-cli-0.2.6/cmd/upgrade.gopackage cmd

import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"strings"
	"time"

"github.com/self-actuated/actuated-cli/pkg"
	"github.com/spf13/cobra"
)

func makeUpgrade() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "upgrade",
		Short: "Upgrade an agent's kernel and root filesystem",
		Example: `  # Upgrade the agent if a newer one is available
  actuated-cli upgrade --owner ORG HOST
  
  # Force an upgrade, even if on the latest version of the agent
  actuated-cli upgrade --owner ORG --force HOST
`,
	}

cmd.RunE = runUpgradeE

cmd.Flags().StringP("owner", "o", "", "Owner")
	cmd.Flags().BoolP("force", "f", false, "Force upgrade")
	cmd.Flags().BoolP("all", "a", false, "Upgrade all hosts instead of giving --host")

return cmd
}

func runUpgradeE(cmd *cobra.Command, args []string) error {

allHosts, err := cmd.Flags().GetBool("all")
	if err != nil {
		return err
	}

if len(args) < 1 && !allHosts {
		return fmt.Errorf("specify the host as an argument")
	}

var host string
	if !allHosts {
		host = strings.TrimSpace(args[0])
	}

pat, err := getPat(cmd)
	if err != nil {
		return err
	}

staff, err := cmd.Flags().GetBool("staff")
	if err != nil {
		return err
	}

owner, err := cmd.Flags().GetString("owner")
	if err != nil {
		return err
	}

force, err := cmd.Flags().GetBool("force")
	if err != nil {
		return err
	}

if !allHosts && len(host) == 0 {
		return fmt.Errorf("--all or --host is required")
	}

if !allHosts && len(owner) == 0 {
		return fmt.Errorf("owner is required")
	}

if len(pat) == 0 {
		return fmt.Errorf("pat is required")
	}

c := pkg.NewClient(http.DefaultClient, os.Getenv("ACTUATED_URL"))

var upgradeHosts []Host
	if allHosts {
		includeImages := false
		hosts, httpStatus, err := c.ListRunners(pat, owner, staff, includeImages, true)
		if err != nil {
			return err
		}
		if httpStatus != http.StatusOK {
			return fmt.Errorf("unexpected status code: %d", httpStatus)
		}

var hostsList []Host

if err := json.Unmarshal([]byte(hosts), &hostsList); err != nil {
			return err
		}

if len(hostsList) == 0 {
			return fmt.Errorf("no hosts found")
		}
		upgradeHosts = hostsList
	} else {

// AE: TODO call ListRunners to determine the values for: Reachable and Status.
		upgradeHosts = []Host{
			{
				Name:      host,
				Customer:  owner,
				Reachable: true,
				Status:    "running",
			},
		}
	}

for _, h := range upgradeHosts {
		st := time.Now()
		fmt.Printf("Upgrading: %s (%s)\n", h.Name, h.Customer)

if !h.Reachable {
			fmt.Printf("Can't upgrade: %s (%s), not reachable\n", h.Name, h.Customer)
		} else if h.Status != "running" {
			fmt.Printf("Can't upgrade: %s (%s), status: %s\n", h.Name, h.Customer, h.Status)
		} else {
			res, status, err := c.UpgradeAgent(pat, h.Customer, h.Name, force, staff)
			if err != nil {
				return err
			}

if status != http.StatusOK && status != http.StatusAccepted &&
				status != http.StatusNoContent && status != http.StatusCreated {
				return fmt.Errorf("unexpected status code: %d, error: %s", status, res)
			}

fmt.Printf("Upgrade: %s (%s): %d (%dms)\n", h.Name, h.Customer, status, time.Since(st).Milliseconds())

if strings.TrimSpace(res) != "" {
				fmt.Printf("Response: %s\n", res)
			}
		}
		fmt.Println("")
	}

return nil
}

type Host struct {
	Name      string `json:"name"`
	Customer  string `json:"customer"`
	Reachable bool   `json:"reachable"`
	Status    string `json:"status"`
}
0707010000001A000081A400000000000000000000000166C357AD00000508000000000000000000000000000000000000002200000000actuated-cli-0.2.6/cmd/version.go// Copyright (c) arkade author(s) 2022. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.

package cmd

import (
	"fmt"

"github.com/morikuni/aec"
	"github.com/self-actuated/actuated-cli/pkg"
	"github.com/spf13/cobra"
)

func PrintASCIIArt() {
	arkadeLogo := aec.BlueF.Apply(actuatedCLIStr)
	fmt.Print(arkadeLogo)
}

func MakeVersion() *cobra.Command {
	var command = &cobra.Command{
		Use:          "version",
		Short:        "Print the version",
		Example:      `  arkade version`,
		Aliases:      []string{"v"},
		SilenceUsage: false,
	}
	command.Run = func(cmd *cobra.Command, args []string) {
		PrintASCIIArt()
		if len(pkg.Version) == 0 {
			fmt.Println("Version: dev")
		} else {
			fmt.Println("Version:", pkg.Version)
		}
		fmt.Println("Git Commit:", pkg.GitCommit)
		fmt.Println()

}
	return command
}

const actuatedCLIStr = `
░█▀█░█▀▀░▀█▀░█░█░█▀█░▀█▀░█▀▀░█▀▄
░█▀█░█░░░░█░░█░█░█▀█░░█░░█▀▀░█░█
░▀░▀░▀▀▀░░▀░░▀▀▀░▀░▀░░▀░░▀▀▀░▀▀░

Command Line Interface (CLI)

`
0707010000001B000081A400000000000000000000000166C357AD00000316000000000000000000000000000000000000001A00000000actuated-cli-0.2.6/go.modmodule github.com/self-actuated/actuated-cli

go 1.22

require (
	github.com/docker/go-units v0.5.0
	github.com/google/go-github/v52 v52.0.0
	github.com/morikuni/aec v1.0.0
	github.com/olekukonko/tablewriter v0.0.5
	github.com/openfaasltd/actuated/types v0.0.0-20240729175505-d862db002103
	github.com/spf13/cobra v1.8.0
	golang.org/x/oauth2 v0.21.0
)

require (
	github.com/ProtonMail/go-crypto v1.0.0 // indirect
	github.com/cloudflare/circl v1.3.8 // indirect
	github.com/google/go-querystring v1.1.0 // indirect
	github.com/inconshreveable/mousetrap v1.1.0 // indirect
	github.com/mattn/go-runewidth v0.0.15 // indirect
	github.com/rivo/uniseg v0.4.7 // indirect
	github.com/spf13/pflag v1.0.5 // indirect
	golang.org/x/crypto v0.24.0 // indirect
	golang.org/x/sys v0.21.0 // indirect
)
0707010000001C000081A400000000000000000000000166C357AD00001E49000000000000000000000000000000000000001A00000000actuated-cli-0.2.6/go.sumgithub.com/ProtonMail/go-crypto v1.0.0 h1:LRuvITjQWX+WIfr930YHG2HNfjR1uOfyf5vE0kC2U78=
github.com/ProtonMail/go-crypto v1.0.0/go.mod h1:EjAoLdwvbIOoOQr3ihjnSoLZRtE8azugULFRteWMNc0=
github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0=
github.com/cloudflare/circl v1.3.3/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA=
github.com/cloudflare/circl v1.3.8 h1:j+V8jJt09PoeMFIu2uh5JUyEaIHTXVOHslFoLNAKqwI=
github.com/cloudflare/circl v1.3.8/go.mod h1:PDRU+oXvdD7KCtgKxW95M5Z8BpSCJXQORiZFnBQS5QU=
github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-github/v52 v52.0.0 h1:uyGWOY+jMQ8GVGSX8dkSwCzlehU3WfdxQ7GweO/JP7M=
github.com/google/go-github/v52 v52.0.0/go.mod h1:WJV6VEEUPuMo5pXqqa2ZCZEdbQqua4zAk2MZTIo+m+4=
github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
github.com/openfaasltd/actuated/types v0.0.0-20240729175505-d862db002103 h1:/Yut1iB0gjNwSrzWnwR/EUiirResccGwEoKVPYPZ4Gc=
github.com/openfaasltd/actuated/types v0.0.0-20240729175505-d862db002103/go.mod h1:B2zlss5C6piwLY00cfk7UZBgxbEE3K6Gv0NK3ktxsjU=
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
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/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.3.1-0.20221117191849-2c476679df9a/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
golang.org/x/oauth2 v0.21.0 h1:tsimM75w1tF/uws5rbeHzIWxEqElMehnc+iW793zsZs=
golang.org/x/oauth2 v0.21.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
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/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
0707010000001D000081A400000000000000000000000166C357AD000000C9000000000000000000000000000000000000001B00000000actuated-cli-0.2.6/main.gopackage main

import (
	"fmt"
	"os"

"github.com/self-actuated/actuated-cli/cmd"
)

func main() {
	if err := cmd.Execute(); err != nil {
		fmt.Fprintf(os.Stderr, "Error: %s\n", err)
		os.Exit(1)
	}
}
0707010000001E000041ED00000000000000000000000266C357AD00000000000000000000000000000000000000000000001700000000actuated-cli-0.2.6/pkg0707010000001F000081A400000000000000000000000166C357AD00002900000000000000000000000000000000000000002100000000actuated-cli-0.2.6/pkg/client.gopackage pkg

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"os"
	"time"
)

type Client struct {
	httpClient *http.Client
	baseURL    string
}

func NewClient(httpClient *http.Client, baseURL string) *Client {
	return &Client{
		httpClient: httpClient,
		baseURL:    baseURL,
	}
}

func (c *Client) ListJobs(patStr string, owner string, staff bool, json bool) (string, int, error) {

u, _ := url.Parse(c.baseURL)
	u.Path = "/api/v1/job-queue"
	q := u.Query()

if staff {
		q.Set("staff", "1")
	}

if len(owner) > 0 {
		q.Set("owners", owner)
	}

u.RawQuery = q.Encode()

req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

if json {
		req.Header.Set("Accept", "application/json")
	}

req.Header.Set("Authorization", "Bearer "+patStr)

if os.Getenv("DEBUG") == "1" {
		sanitised := http.Header{}
		for k, v := range req.Header {

if k == "Authorization" {
				v = []string{"redacted"}
			}
			sanitised[k] = v
		}

fmt.Printf("URL %s\nHeaders: %v\n", u.String(), sanitised)
	}

res, err := c.httpClient.Do(req)
	if err != nil {
		return "", http.StatusServiceUnavailable, err
	}

var body []byte
	if res.Body != nil {
		defer res.Body.Close()
		body, _ = io.ReadAll(res.Body)
	}

return string(body), res.StatusCode, nil
}

func (c *Client) GetBuildIncreases(patStr string, owner string, startDate time.Time, staff bool, json bool) (string, int, error) {

u, _ := url.Parse(c.baseURL)
	u.Path = "/api/v1/job-increases"
	q := u.Query()

if staff {
		q.Set("staff", "1")
	}

if len(owner) > 0 {
		q.Set("owner", owner)
	}
	q.Add("startDate", startDate.Format("2006-01-02"))

u.RawQuery = q.Encode()

req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

if json {
		req.Header.Set("Accept", "application/json")
	}

req.Header.Set("Authorization", "Bearer "+patStr)

if os.Getenv("DEBUG") == "1" {
		sanitised := http.Header{}
		for k, v := range req.Header {

if k == "Authorization" {
				v = []string{"redacted"}
			}
			sanitised[k] = v
		}

fmt.Printf("URL %s\nHeaders: %v\n", u.String(), sanitised)
	}

res, err := c.httpClient.Do(req)
	if err != nil {
		return "", http.StatusServiceUnavailable, err
	}

var body []byte
	if res.Body != nil {
		defer res.Body.Close()
		body, _ = io.ReadAll(res.Body)
	}

return string(body), res.StatusCode, nil
}

func (c *Client) ListRunners(patStr string, owner string, staff, images, json bool) (string, int, error) {

u, _ := url.Parse(c.baseURL)
	u.Path = "/api/v1/runners"
	q := u.Query()

if staff {
		q.Set("staff", "1")
	}

if images {
		q.Set("images", "1")
	}

if len(owner) > 0 {
		q.Set("owner", owner)
		log.Printf("Requesting runners for owner %s", owner)
	}

u.RawQuery = q.Encode()

req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

if json {
		req.Header.Set("Accept", "application/json")
	}

req.Header.Set("Authorization", "Bearer "+patStr)

if os.Getenv("DEBUG") == "1" {
		sanitised := http.Header{}
		for k, v := range req.Header {

if k == "Authorization" {
				v = []string{"redacted"}
			}
			sanitised[k] = v
		}

fmt.Printf("URL %s\nHeaders: %v\n", u.String(), sanitised)
	}

res, err := c.httpClient.Do(req)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

var body []byte
	if res.Body != nil {
		defer res.Body.Close()
		body, _ = io.ReadAll(res.Body)
	}

return string(body), res.StatusCode, nil
}

func (c *Client) Repair(patStr string, owner string, staff bool) (string, int, error) {

u, _ := url.Parse(c.baseURL)
	u.Path = "/api/v1/repair"
	q := u.Query()

if staff {
		q.Set("staff", "1")
	}

q.Set("owner", owner)
	u.RawQuery = q.Encode()

req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

req.Header.Set("Authorization", "Bearer "+patStr)

if os.Getenv("DEBUG") == "1" {
		sanitised := http.Header{}
		for k, v := range req.Header {

if k == "Authorization" {
				v = []string{"redacted"}
			}
			sanitised[k] = v
		}

fmt.Printf("URL %s\nHeaders: %v\n", u.String(), sanitised)
	}

res, err := c.httpClient.Do(req)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

var body []byte
	if res.Body != nil {
		defer res.Body.Close()
		body, _ = io.ReadAll(res.Body)
	}

return string(body), res.StatusCode, nil
}

func (c *Client) GetLogs(patStr, owner, host, id string, age time.Duration, staff bool) (string, int, error) {

mins := int(age.Minutes())

u, _ := url.Parse(c.baseURL)
	u.Path = "/api/v1/logs"

q := u.Query()
	q.Set("owner", owner)
	q.Set("host", host)
	q.Set("age", fmt.Sprintf("%dm", mins))
	if len(id) > 0 {
		q.Set("id", id)
	}

if staff {
		q.Set("staff", "1")
	}

u.RawQuery = q.Encode()

req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

req.Header.Set("Authorization", "Bearer "+patStr)

if os.Getenv("DEBUG") == "1" {
		sanitised := http.Header{}
		for k, v := range req.Header {

if k == "Authorization" {
				v = []string{"redacted"}
			}
			sanitised[k] = v
		}

fmt.Printf("URL %s\nHeaders: %v\n", u.String(), sanitised)
	}

res, err := c.httpClient.Do(req)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

var body []byte
	if res.Body != nil {
		defer res.Body.Close()
		body, _ = io.ReadAll(res.Body)
	}

return string(body), res.StatusCode, nil
}

func (c *Client) GetAgentLogs(patStr, owner, host string, age time.Duration, staff bool) (string, int, error) {

mins := int(age.Minutes())

u, _ := url.Parse(c.baseURL)
	u.Path = "/api/v1/service"

q := u.Query()
	q.Set("owner", owner)
	q.Set("host", host)
	q.Set("age", fmt.Sprintf("%dm", mins))

if staff {
		q.Set("staff", "1")
	}

u.RawQuery = q.Encode()

req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

req.Header.Set("Authorization", "Bearer "+patStr)

if os.Getenv("DEBUG") == "1" {
		sanitised := http.Header{}
		for k, v := range req.Header {

if k == "Authorization" {
				v = []string{"redacted"}
			}
			sanitised[k] = v
		}

fmt.Printf("URL %s\nHeaders: %v\n", u.String(), sanitised)
	}

res, err := c.httpClient.Do(req)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

var body []byte
	if res.Body != nil {
		defer res.Body.Close()
		body, _ = io.ReadAll(res.Body)
	}

return string(body), res.StatusCode, nil
}

func (c *Client) GetControllerLogs(patStr, outputFormat string, age time.Duration) (string, int, error) {

mins := int(age.Minutes())

u, _ := url.Parse(c.baseURL)
	u.Path = "/api/v1/controller/logs"

q := u.Query()

q.Set("age", fmt.Sprintf("%dm", mins))

if len(outputFormat) > 0 {
		q.Set("output", outputFormat)
	}

u.RawQuery = q.Encode()

req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

req.Header.Set("Authorization", "Bearer "+patStr)

if os.Getenv("DEBUG") == "1" {
		sanitised := http.Header{}
		for k, v := range req.Header {

if k == "Authorization" {
				v = []string{"redacted"}
			}
			sanitised[k] = v
		}

fmt.Printf("URL %s\nHeaders: %v\n", u.String(), sanitised)
	}

res, err := c.httpClient.Do(req)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

var body []byte
	if res.Body != nil {
		defer res.Body.Close()
		body, _ = io.ReadAll(res.Body)
	}

return string(body), res.StatusCode, nil
}

func (c *Client) UpgradeAgent(patStr, owner, host string, force bool, staff bool) (string, int, error) {

u, _ := url.Parse(c.baseURL)
	u.Path = "/api/v1/upgrade"

q := u.Query()
	q.Set("owner", owner)
	q.Set("host", host)

if staff {
		q.Set("staff", "1")
	}
	if force {
		q.Set("force", "1")

}

u.RawQuery = q.Encode()

req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

req.Header.Set("Authorization", "Bearer "+patStr)

if os.Getenv("DEBUG") == "1" {
		sanitised := http.Header{}
		for k, v := range req.Header {

if k == "Authorization" {
				v = []string{"redacted"}
			}
			sanitised[k] = v
		}

fmt.Printf("URL %s\nHeaders: %v\n", u.String(), sanitised)
	}

res, err := c.httpClient.Do(req)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

var body []byte
	if res.Body != nil {
		defer res.Body.Close()
		body, _ = io.ReadAll(res.Body)
	}

return string(body), res.StatusCode, nil
}

func (c *Client) RestartAgent(patStr, owner, host string, reboot bool, staff bool) (string, int, error) {

u, _ := url.Parse(c.baseURL)
	u.Path = "/api/v1/restart"

q := u.Query()
	q.Set("owner", owner)
	q.Set("host", host)

if staff {
		q.Set("staff", "1")
	}
	if reboot {
		q.Set("reboot", "1")

}

u.RawQuery = q.Encode()

req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

req.Header.Set("Authorization", "Bearer "+patStr)

if os.Getenv("DEBUG") == "1" {
		sanitised := http.Header{}
		for k, v := range req.Header {

if k == "Authorization" {
				v = []string{"redacted"}
			}
			sanitised[k] = v
		}

fmt.Printf("URL %s\nHeaders: %v\n", u.String(), sanitised)
	}

res, err := c.httpClient.Do(req)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

var body []byte
	if res.Body != nil {
		defer res.Body.Close()
		body, _ = io.ReadAll(res.Body)
	}

return string(body), res.StatusCode, nil
}

func (c *Client) DisableAgent(patStr, owner, host string, staff bool) (string, int, error) {

u, _ := url.Parse(c.baseURL)
	u.Path = "/api/v1/disable"

q := u.Query()
	q.Set("owner", owner)
	q.Set("host", host)

if staff {
		q.Set("staff", "1")
	}

u.RawQuery = q.Encode()

req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

req.Header.Set("Authorization", "Bearer "+patStr)

if os.Getenv("DEBUG") == "1" {
		sanitised := http.Header{}
		for k, v := range req.Header {

if k == "Authorization" {
				v = []string{"redacted"}
			}
			sanitised[k] = v
		}

fmt.Printf("URL %s\nHeaders: %v\n", u.String(), sanitised)
	}

res, err := c.httpClient.Do(req)
	if err != nil {
		return "", http.StatusBadRequest, err
	}

var body []byte
	if res.Body != nil {
		defer res.Body.Close()
		body, _ = io.ReadAll(res.Body)
	}

return string(body), res.StatusCode, nil
}
07070100000020000081A400000000000000000000000166C357AD00000031000000000000000000000000000000000000002200000000actuated-cli-0.2.6/pkg/version.gopackage pkg

var (
	Version,
	GitCommit string
)
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!129 blocks

Places

File actuated-cli-0.2.6.obscpio of Package actuated-cli (Revision 220dba8fe3716023744439e1ff1f6e69)

Places