Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

4.7 KB
Raw Blame
package daemon

import (
	"errors"
	"fmt"
	"os"
	"os/exec"
	"os/user"
	"path/filepath"
	"runtime"
	"strings"
)

const (
	pinchtabDaemonUnitName = "pinchtab.service"
	pinchtabLaunchdLabel   = "com.pinchtab.pinchtab"
)

var ErrUnsupportedOS = errors.New("pinchtab daemon is supported on macOS and Linux only")

var runtimeGOOS = runtime.GOOS

type Manager interface {
	Preflight() error
	Install(configPath string) (string, error)
	ServicePath() string
	Start() (string, error)
	Restart() (string, error)
	Status() (string, error)
	Stop() (string, error)
	Uninstall() (string, error)
	ManualInstructions() string
	Pid() (string, error)
	Logs(n int) (string, error)
}

type commandRunner interface {
	CombinedOutput(name string, arg ...string) ([]byte, error)
}

type osCommandRunner struct{}

func (r osCommandRunner) CombinedOutput(name string, arg ...string) ([]byte, error) {
	return exec.Command(name, arg...).CombinedOutput() // #nosec G204 -- args are daemon manager controlled, not user input
}

type environment struct {
	execPath      string
	homeDir       string
	osName        string
	userID        string
	xdgConfigHome string
}

func CurrentManager() (Manager, error) {
	env, err := currentEnvironment()
	if err != nil {
		return nil, err
	}
	return newManager(env, osCommandRunner{})
}

func IsInstalled() bool {
	installed, err := InstallationStatus()
	return err == nil && installed
}

// InstallationStatus distinguishes an absent service from an unreadable service
// location so lifecycle callers can fail closed instead of starting a second owner.
func InstallationStatus() (bool, error) {
	manager, err := CurrentManager()
	if err != nil {
		return false, err
	}
	_, err = os.Stat(manager.ServicePath())
	if err == nil {
		return true, nil
	}
	if os.IsNotExist(err) {
		return false, nil
	}
	return false, err
}

func IsRunning() bool {
	manager, err := CurrentManager()
	if err != nil {
		return false
	}
	status, err := manager.Status()
	if err != nil {
		return false
	}
	return StatusLooksRunning(status)
}

func StatusLooksRunning(status string) bool {
	return strings.Contains(status, "state = running") ||
		strings.Contains(status, "Active: active (running)")
}

func currentEnvironment() (environment, error) {
	execPath, err := os.Executable()
	if err != nil {
		return environment{}, fmt.Errorf("resolve executable path: %w", err)
	}
	homeDir, err := os.UserHomeDir()
	if err != nil {
		return environment{}, fmt.Errorf("resolve home directory: %w", err)
	}
	currentUser, err := user.Current()
	if err != nil {
		return environment{}, fmt.Errorf("resolve current user: %w", err)
	}

	return environment{
		execPath:      execPath,
		homeDir:       homeDir,
		osName:        runtimeGOOS,
		userID:        currentUser.Uid,
		xdgConfigHome: os.Getenv("XDG_CONFIG_HOME"),
	}, nil
}

func newManager(env environment, runner commandRunner) (Manager, error) {
	switch env.osName {
	case "linux":
		return &systemdUserManager{env: env, runner: runner}, nil
	case "darwin":
		return &launchdManager{env: env, runner: runner}, nil
	default:
		return nil, fmt.Errorf("%w; current OS is %s", ErrUnsupportedOS, env.osName)
	}
}

func runCommand(runner commandRunner, name string, args ...string) (string, error) {
	output, err := runner.CombinedOutput(name, args...)
	trimmed := strings.TrimSpace(string(output))
	if err == nil {
		return trimmed, nil
	}
	if trimmed == "" {
		return "", fmt.Errorf("%s %s: %w", name, strings.Join(args, " "), err)
	}
	return "", fmt.Errorf("%s %s: %w: %s", name, strings.Join(args, " "), err, trimmed)
}

func launchdDomainTarget(env environment) string {
	return "gui/" + env.userID
}

func systemdUserConfigHome(env environment) string {
	if strings.TrimSpace(env.xdgConfigHome) != "" {
		return env.xdgConfigHome
	}
	return filepath.Join(env.homeDir, ".config")
}

func pinchtabStateHome(env environment) string {
	return filepath.Join(env.homeDir, ".pinchtab")
}

func daemonLogDir(env environment) string {
	return filepath.Join(pinchtabStateHome(env), "logs")
}

// StderrLogPath is where a service-managed server's diagnostics land. Exported so a
// surface that tells an operator where to look reads the same path the installer
// writes into the unit, rather than spelling it a second time.
func StderrLogPath() (string, error) {
	env, err := currentEnvironment()
	if err != nil {
		return "", err
	}
	return daemonStderrLogPath(env), nil
}

func daemonStdoutLogPath(env environment) string {
	return filepath.Join(daemonLogDir(env), "daemon.out.log")
}

func daemonStderrLogPath(env environment) string {
	return filepath.Join(daemonLogDir(env), "daemon.err.log")
}

func ensureDaemonLogDir(env environment) error {
	if err := os.MkdirAll(daemonLogDir(env), 0755); err != nil {
		return fmt.Errorf("create daemon log directory: %w", err)
	}
	return nil
}