Skip to content

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

7.6 KB
Raw Blame
package daemon

import (
	"encoding/xml"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"strings"
)

type launchdManager struct {
	env    environment
	runner commandRunner
}

func (m *launchdManager) ServicePath() string {
	return filepath.Join(m.env.homeDir, "Library", "LaunchAgents", pinchtabLaunchdLabel+".plist")
}

func (m *launchdManager) Preflight() error {
	if strings.TrimSpace(m.env.userID) == "" {
		return fmt.Errorf("macOS daemon install requires a logged-in user session with a launchd GUI domain")
	}
	if _, err := runCommand(m.runner, "launchctl", "print", launchdDomainTarget(m.env)); err != nil {
		return fmt.Errorf("macOS daemon install requires an active launchd GUI session: %w", err)
	}
	return nil
}

func (m *launchdManager) Install(configPath string) (string, error) {
	if err := os.MkdirAll(filepath.Dir(m.ServicePath()), 0755); err != nil {
		return "", fmt.Errorf("create LaunchAgents directory: %w", err)
	}
	if err := ensureDaemonLogDir(m.env); err != nil {
		return "", err
	}
	if err := os.WriteFile(m.ServicePath(), []byte(renderLaunchdPlist(m.env.execPath, configPath, m.env.homeDir, daemonStdoutLogPath(m.env), daemonStderrLogPath(m.env))), 0644); err != nil {
		return "", fmt.Errorf("write launchd plist: %w", err)
	}
	_, _ = runCommand(m.runner, "launchctl", "bootout", launchdDomainTarget(m.env), m.ServicePath())
	if _, err := runCommand(m.runner, "launchctl", "bootstrap", launchdDomainTarget(m.env), m.ServicePath()); err != nil {
		return "", err
	}
	if _, err := runCommand(m.runner, "launchctl", "kickstart", "-k", launchdDomainTarget(m.env)+"/"+pinchtabLaunchdLabel); err != nil {
		return "", err
	}
	return fmt.Sprintf("Installed launchd agent at %s", m.ServicePath()), nil
}

func (m *launchdManager) Start() (string, error) {
	if err := ensureDaemonLogDir(m.env); err != nil {
		return "", err
	}
	if _, err := runCommand(m.runner, "launchctl", "bootstrap", launchdDomainTarget(m.env), m.ServicePath()); err != nil && !isLaunchdAlreadyBootstrapped(err) {
		return "", err
	}
	if _, err := runCommand(m.runner, "launchctl", "kickstart", launchdDomainTarget(m.env)+"/"+pinchtabLaunchdLabel); err != nil {
		return "", err
	}
	return "Pinchtab daemon started.", nil
}

func (m *launchdManager) Restart() (string, error) {
	if err := ensureDaemonLogDir(m.env); err != nil {
		return "", err
	}
	if _, err := runCommand(m.runner, "launchctl", "kickstart", "-k", launchdDomainTarget(m.env)+"/"+pinchtabLaunchdLabel); err != nil {
		return "", err
	}
	return "Pinchtab daemon restarted.", nil
}

func (m *launchdManager) Stop() (string, error) {
	_, err := runCommand(m.runner, "launchctl", "bootout", launchdDomainTarget(m.env), m.ServicePath())
	if err != nil && !isLaunchdIgnorableError(err) {
		return "", err
	}
	return "Pinchtab daemon stopped.", nil
}

func (m *launchdManager) Status() (string, error) {
	output, err := runCommand(m.runner, "launchctl", "print", launchdDomainTarget(m.env)+"/"+pinchtabLaunchdLabel)
	if err != nil {
		return "", err
	}
	if strings.TrimSpace(output) == "" {
		return "Pinchtab daemon status returned no output.", nil
	}
	return output, nil
}

func (m *launchdManager) Uninstall() (string, error) {
	var errs []error
	_, err := runCommand(m.runner, "launchctl", "bootout", launchdDomainTarget(m.env), m.ServicePath())
	if err != nil && !isLaunchdIgnorableError(err) {
		errs = append(errs, err)
	}
	if err := os.Remove(m.ServicePath()); err != nil && !errors.Is(err, os.ErrNotExist) {
		errs = append(errs, fmt.Errorf("remove launchd plist: %w", err))
	}
	if len(errs) > 0 {
		return "", errors.Join(errs...)
	}
	return "Pinchtab daemon uninstalled.", nil
}

func (m *launchdManager) Pid() (string, error) {
	output, err := runCommand(m.runner, "launchctl", "print", launchdDomainTarget(m.env)+"/"+pinchtabLaunchdLabel)
	if err != nil {
		return "", err
	}
	lines := strings.Split(output, "\n")
	for _, line := range lines {
		trimmed := strings.TrimSpace(line)
		if strings.HasPrefix(trimmed, "pid = ") {
			return strings.TrimPrefix(trimmed, "pid = "), nil
		}
	}
	return "", nil
}

func (m *launchdManager) Logs(n int) (string, error) {
	logPath := daemonStderrLogPath(m.env)
	if info, err := os.Stat(logPath); err == nil && info.Size() > 0 {
		return runCommand(m.runner, "tail", "-n", fmt.Sprintf("%d", n), logPath)
	}

	legacyLogPath := "/tmp/pinchtab.err.log"
	if _, err := os.Stat(legacyLogPath); err == nil {
		return runCommand(m.runner, "tail", "-n", fmt.Sprintf("%d", n), legacyLogPath)
	}

	return "No logs found at " + logPath, nil
}

func (m *launchdManager) ManualInstructions() string {
	path := m.ServicePath()
	target := launchdDomainTarget(m.env)
	var b strings.Builder
	fmt.Fprintln(&b, "Manual instructions (macOS/launchd):")
	fmt.Fprintln(&b, "To install manually:")
	fmt.Fprintf(&b, "  1. Create %s\n", path)
	fmt.Fprintf(&b, "  2. Run: launchctl bootstrap %s %s\n", target, path)
	fmt.Fprintln(&b)
	fmt.Fprintln(&b, "To uninstall manually:")
	fmt.Fprintf(&b, "  1. Run: launchctl bootout %s %s\n", target, path)
	fmt.Fprintf(&b, "  2. Remove: %s\n", path)
	return b.String()
}

// launchctl error-message substrings treated as benign. "already bootstrapped"
// is shared with isLaunchdAlreadyBootstrapped so the literal lives in one place.
const (
	launchdAlreadyBootstrapped = "already bootstrapped"
	launchdExitStatus5         = "exit status 5"
	launchdNoSuchProcess       = "No such process"
	launchdNotFound            = "not found"
)

// isLaunchdAlreadyBootstrapped reports whether a launchctl error means the
// service is already bootstrapped — for Start, that makes bootstrap an
// effective no-op success. It is deliberately narrower than
// isLaunchdIgnorableError (which also tolerates the teardown "service absent"
// cases that a failed Start must NOT swallow).
func isLaunchdAlreadyBootstrapped(err error) bool {
	return err != nil && strings.Contains(err.Error(), launchdAlreadyBootstrapped)
}

func isLaunchdIgnorableError(err error) bool {
	if err == nil {
		return true
	}
	msg := err.Error()
	return strings.Contains(msg, launchdExitStatus5) ||
		strings.Contains(msg, launchdNoSuchProcess) ||
		strings.Contains(msg, launchdNotFound) ||
		strings.Contains(msg, launchdAlreadyBootstrapped)
}

// plistString escapes a value for inclusion in a plist <string> element. The
// paths reaching here are user-influenced (--config / PINCHTAB_CONFIG, and the
// home directory), and a bare "&" — ordinary in a macOS directory name like
// "R&D" — otherwise makes launchctl reject the file as malformed XML.
func plistString(value string) string {
	var b strings.Builder
	if err := xml.EscapeText(&b, []byte(value)); err != nil {
		return ""
	}
	return b.String()
}

func renderLaunchdPlist(execPath, configPath, homeDir, stdoutPath, stderrPath string) string {
	execPath = plistString(execPath)
	configPath = plistString(configPath)
	homeDir = plistString(homeDir)
	stdoutPath = plistString(stdoutPath)
	stderrPath = plistString(stderrPath)
	return fmt.Sprintf(`<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key>
  <string>%s</string>
  <key>ProgramArguments</key>
  <array>
    <string>%s</string>
    <string>server</string>
  </array>
  <key>WorkingDirectory</key>
  <string>%s</string>
  <key>RunAtLoad</key>
  <true/>
  <key>KeepAlive</key>
  <true/>
  <key>ExitTimeOut</key>
  <integer>10</integer>
  <key>EnvironmentVariables</key>
  <dict>
    <key>HOME</key>
    <string>%s</string>
    <key>PINCHTAB_CONFIG</key>
    <string>%s</string>
  </dict>
  <key>StandardOutPath</key>
  <string>%s</string>
  <key>StandardErrorPath</key>
  <string>%s</string>
</dict>
</plist>
	`, pinchtabLaunchdLabel, execPath, homeDir, homeDir, configPath, stdoutPath, stderrPath)
}