High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.
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
}