cmd

Documentation

Index

• Constants
• Variables
• func ProfileApp(script string, config map[string]string) (*pprof_profile.Profile, error)
• func SetAuth(cmd *cobra.Command, args []string) error
• type FetchFunc
  • func MakeFetchFunc(prof *pprof_profile.Profile) FetchFunc
  • func (f FetchFunc) Fetch(src string, duration, timeout time.Duration) (*pprof_profile.Profile, string, error)
• type TidbytInstallationJSON
• type TidbytInstallationListJSON
• type TidbytPushJSON

Constants

const (
	TidbytAPIPush = "https://api.tidbyt.com/v0/devices/%s/push"
	APITokenEnv   = "TIDBYT_API_TOKEN"
)

const MaxRenderTime = 1000000000 // 1000ms

const PublicKeysetJSON = `` /* 543-byte string literal not displayed */

const (
	TidbytAPIDelete = "https://api.tidbyt.com/v0/devices/%s/installations/%s"
)

const (
	TidbytAPIList = "https://api.tidbyt.com/v0/devices/%s/installations"
)

const (
	TidbytAPIListDevices = "https://api.tidbyt.com/v0/devices"
)

Variables

var CheckCmd = &cobra.Command{
	Use:     "check <pathspec>...",
	Example: `  pixlet check app.star`,
	Short:   "Checks if an app is ready to publish",
	Long: `The check command runs a series of checks to ensure your app is ready
to publish in the community repo. Every failed check will have a solution
provided. If your app fails a check, try the provided solution and reach out on
Discord if you get stuck.`,
	Args: cobra.MinimumNArgs(1),
	RunE: checkCmd,
}

var CreateCmd = &cobra.Command{
	Use:   "create",
	Short: "Creates a new app",
	Long:  `This command will prompt for all of the information we need to generate a new Tidbyt app.`,
	RunE: func(cmd *cobra.Command, args []string) error {

		cwd, err := os.Getwd()
		if err != nil {
			return fmt.Errorf("app creation failed, something went wrong with your local filesystem: %w", err)
		}

		// Determine what type of app this is an what the root should be.
		var root string
		var appType generator.AppType
		if repo.IsInRepo(cwd, "community") {
			appType = generator.Community
			root, err = repo.RepoRoot(cwd)
			if err != nil {
				return fmt.Errorf("app creation failed, something went wrong with your community repo: %w", err)
			}
		} else if repo.IsInRepo(cwd, "tidbyt") {
			appType = generator.Internal
			root, err = repo.RepoRoot(cwd)
			if err != nil {
				return fmt.Errorf("app creation failed, something went wrong with your tidbyt repo: %w", err)
			}
		} else {
			appType = generator.Local
			root = cwd
		}

		app, err := community.ManifestPrompt()
		if err != nil {
			return fmt.Errorf("app creation, couldn't get user input: %w", err)
		}

		g, err := generator.NewGenerator(appType, root)
		if err != nil {
			return fmt.Errorf("app creation failed %w", err)
		}
		absolutePath, err := g.GenerateApp(app)
		if err != nil {
			return fmt.Errorf("app creation failed: %w", err)
		}

		relativePath, err := filepath.Rel(cwd, absolutePath)
		if err != nil {
			return fmt.Errorf("app was created, but we don't know where: %w", err)
		}

		fmt.Println("")
		fmt.Println("App created at:")
		fmt.Printf("\t%s\n", absolutePath)
		fmt.Println("")
		fmt.Println("To start the app, run:")
		fmt.Printf("\tpixlet serve %s\n", relativePath)
		fmt.Println("")
		fmt.Println("For docs, head to:")
		fmt.Printf("\thttps://tidbyt.dev\n")
		return nil
	},
}

CreateCmd prompts the user for info and generates a new app.

var DeleteCmd = &cobra.Command{
	Use:   "delete [device ID] [installation ID]",
	Short: "Delete a pixlet script from a Tidbyt",
	Args:  cobra.MinimumNArgs(2),
	RunE:  delete,
}

var DevicesCmd = &cobra.Command{
	Use:   "devices",
	Short: "List devices in your Tidbyt account",
	Run:   devices,
}

var EncryptCmd = &cobra.Command{
	Use:     "encrypt [app ID] [secret value]...",
	Short:   "Encrypt a secret for use in the Tidbyt community repo",
	Example: "encrypt weather my-top-secretweather-api-key-123456",
	Args:    cobra.MinimumNArgs(2),
	Run:     encrypt,
}

var FormatCmd = &cobra.Command{
	Use:   "format <pathspec>...",
	Short: "Formats Tidbyt apps",
	Example: `  pixlet format app.star
  pixlet format app.star --dry-run
  pixlet format --recursive ./`,
	Long: `The format command provides a code formatter for Tidbyt apps. By default, it
will format your starlark source code in line. If you wish you see the output
before applying, add the --dry-run flag.`,
	Args: cobra.MinimumNArgs(1),
	RunE: formatCmd,
}

var LintCmd = &cobra.Command{
	Use: "lint <pathspec>...",
	Example: `  pixlet lint app.star
  pixlet lint --recursive --fix ./`,
	Short: "Lints Tidbyt apps",
	Long: `The lint command provides a linter for Tidbyt apps. It's capable of linting a
file, a list of files, or directory with the recursive option. Additionally, it
provides an option to automatically fix resolvable linter issues.`,
	Args: cobra.MinimumNArgs(1),
	RunE: lintCmd,
}

var ListCmd = &cobra.Command{
	Use:   "list [device ID]",
	Short: "Lists all apps installed on a Tidbyt",
	Args:  cobra.MinimumNArgs(1),
	RunE:  listInstallations,
}

var LoginCmd = &cobra.Command{
	Use:     "login",
	Short:   "Login to your Tidbyt account",
	Example: "login",
	Run:     login,
}

var ProfileCmd = &cobra.Command{
	Use:   "profile [script] [<key>=value>]...",
	Short: "Run a Pixlet script and print its execution-time profile",
	Args:  cobra.MinimumNArgs(1),
	RunE:  profile,
}

var PushCmd = &cobra.Command{
	Use:   "push [device ID] [webp image]",
	Short: "Render a Pixlet script and push the WebP output to a Tidbyt",
	Args:  cobra.MinimumNArgs(2),
	RunE:  push,
}

var RenderCmd = &cobra.Command{
	Use:   "render [script] [<key>=value>]...",
	Short: "Run a Pixlet script with provided config parameters",
	Args:  cobra.MinimumNArgs(1),
	RunE:  render,
}

var ServeCmd = &cobra.Command{
	Use:   "serve [script]",
	Short: "Serve a Pixlet app in a web server",
	Args:  cobra.ExactArgs(1),
	RunE:  serve,
}

var SetAuthCmd = &cobra.Command{
	Use:     "set-auth",
	Short:   "Sets a custom access token in the private pixlet config.",
	Example: `  pixlet set-auth <token_json>`,
	Long: `This command sets a custom access token for use in subsequent runs. Normal users
should not need this - use 'pixlet login' instead.`,
	Args: cobra.ExactArgs(1),
	RunE: SetAuth,
}

var Version string

var VersionCmd = &cobra.Command{
	Use:   "version",
	Short: "Show the version of Pixlet",
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Printf("Pixlet version: %s\n", Version)
	},
}

Functions

func ProfileApp

func ProfileApp(script string, config map[string]string) (*pprof_profile.Profile, error)

func SetAuth

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

Types

type FetchFunc

type FetchFunc func(src string, duration, timeout time.Duration) (*pprof_profile.Profile, string, error)

We save the profile into an in-memory buffer, which is simpler than the tool expects. Simple adapter to pipe it through.

func MakeFetchFunc

func MakeFetchFunc(prof *pprof_profile.Profile) FetchFunc

func (FetchFunc) Fetch

func (f FetchFunc) Fetch(src string, duration, timeout time.Duration) (*pprof_profile.Profile, string, error)

type TidbytInstallationJSON

type TidbytInstallationJSON struct {
	Id    string `json:"id"`
	AppId string `json:"appID"`
}

type TidbytInstallationListJSON

type TidbytInstallationListJSON struct {
	Installations []TidbytInstallationJSON `json:"installations"`
}

type TidbytPushJSON

type TidbytPushJSON struct {
	DeviceID       string `json:"deviceID"`
	Image          string `json:"image"`
	InstallationID string `json:"installationID"`
	Background     bool   `json:"background"`
}