Skip to content

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

fix: daemon start/restart leak raw launchctl errors when the daemon is not installed PIN-013

Luigi Agosti6427194824ed
diff --git a/cmd/pinchtab/cmd_daemon.go b/cmd/pinchtab/cmd_daemon.go
index b1ba0362..a08c6599 100644
--- a/cmd/pinchtab/cmd_daemon.go
+++ b/cmd/pinchtab/cmd_daemon.go
@@ -32,20 +32,33 @@ func init() {
rootCmd.AddCommand(daemonCmd)
}
+var daemonCurrentManager = daemon.CurrentManager
+
func handleDaemonCommand(subcommand string, jsonOut bool) {
- if subcommand == "" || subcommand == "help" || subcommand == "--help" || subcommand == "-h" {
+ if code := dispatchDaemonCommand(subcommand, jsonOut); code != 0 {
+ os.Exit(code)
+ }
+}
+
+func dispatchDaemonCommand(subcommand string, jsonOut bool) int {
+ if isDaemonStatusSubcommand(subcommand) {
if jsonOut {
printDaemonStatusJSON()
- return
+ return 0
}
printDaemonOverview()
- return
+ return 0
}
- manager, err := daemon.CurrentManager()
+ if err := requireDaemonInstalled(subcommand); err != nil {
+ fmt.Fprintln(os.Stderr, cli.StyleStderr(cli.ErrorStyle, err.Error()))
+ return 1
+ }
+
+ manager, err := daemonCurrentManager()
if err != nil {
fmt.Fprintln(os.Stderr, cli.StyleStderr(cli.ErrorStyle, err.Error()))
- os.Exit(1)
+ return 1
}
switch subcommand {
@@ -61,9 +74,32 @@ func handleDaemonCommand(subcommand string, jsonOut bool) {
handleDaemonUninstall(manager)
default:
fmt.Fprintln(os.Stderr, cli.StyleStderr(cli.ErrorStyle, fmt.Sprintf("unknown daemon command: %s", subcommand)))
- fmt.Fprintln(os.Stderr, cli.StyleStderr(cli.MutedStyle, "Usage: pinchtab daemon <install|start|restart|stop|uninstall>"))
- os.Exit(2)
+ fmt.Fprintln(os.Stderr, cli.StyleStderr(cli.MutedStyle, "Usage: pinchtab daemon <status|install|start|restart|stop|uninstall>"))
+ return 2
+ }
+ return 0
+}
+
+func isDaemonStatusSubcommand(subcommand string) bool {
+ switch subcommand {
+ case "", "status", "help", "--help", "-h":
+ return true
+ }
+ return false
+}
+
+func requireDaemonInstalled(subcommand string) error {
+ if subcommand != "start" && subcommand != "restart" {
+ return nil
+ }
+ installed, err := daemonInstallationStatus()
+ if err != nil {
+ return fmt.Errorf("cannot determine whether the background service is installed; refusing to %s: %w", subcommand, err)
+ }
+ if installed {
+ return nil
}
+ return fmt.Errorf("background service is not installed; install it first with: pinchtab daemon install")
}
func handleDaemonInstall(manager daemon.Manager) {
diff --git a/cmd/pinchtab/cmd_daemon_test.go b/cmd/pinchtab/cmd_daemon_test.go
index bc75ce15..5a1e9387 100644
--- a/cmd/pinchtab/cmd_daemon_test.go
+++ b/cmd/pinchtab/cmd_daemon_test.go
@@ -2,10 +2,190 @@ package main
import (
"encoding/json"
+ "errors"
"strings"
"testing"
+
+ "github.com/pinchtab/pinchtab/internal/daemon"
)
+type recordingDaemonManager struct {
+ calls []string
+}
+
+func (m *recordingDaemonManager) record(name string) { m.calls = append(m.calls, name) }
+
+func (m *recordingDaemonManager) Preflight() error { m.record("Preflight"); return nil }
+
+func (m *recordingDaemonManager) Install(configPath string) (string, error) {
+ m.record("Install " + configPath)
+ return "Installed service", nil
+}
+
+func (m *recordingDaemonManager) ServicePath() string { m.record("ServicePath"); return "/tmp/service" }
+
+func (m *recordingDaemonManager) Start() (string, error) {
+ m.record("Start")
+ return "Pinchtab daemon started.", nil
+}
+
+func (m *recordingDaemonManager) Restart() (string, error) {
+ m.record("Restart")
+ return "Pinchtab daemon restarted.", nil
+}
+
+func (m *recordingDaemonManager) Status() (string, error) { m.record("Status"); return "", nil }
+
+func (m *recordingDaemonManager) Stop() (string, error) {
+ m.record("Stop")
+ return "Pinchtab daemon stopped.", nil
+}
+
+func (m *recordingDaemonManager) Uninstall() (string, error) {
+ m.record("Uninstall")
+ return "Removed service", nil
+}
+
+func (m *recordingDaemonManager) ManualInstructions() string {
+ m.record("ManualInstructions")
+ return ""
+}
+
+func (m *recordingDaemonManager) Pid() (string, error) { m.record("Pid"); return "", nil }
+
+func (m *recordingDaemonManager) Logs(n int) (string, error) { m.record("Logs"); return "", nil }
+
+func stubDaemonSeams(t *testing.T, installed bool, statusErr error) (*recordingDaemonManager, *int) {
+ t.Helper()
+
+ manager := &recordingDaemonManager{}
+ constructed := 0
+
+ origStatus := daemonInstallationStatus
+ origManager := daemonCurrentManager
+ daemonInstallationStatus = func() (bool, error) { return installed, statusErr }
+ daemonCurrentManager = func() (daemon.Manager, error) {
+ constructed++
+ return manager, nil
+ }
+ t.Cleanup(func() {
+ daemonInstallationStatus = origStatus
+ daemonCurrentManager = origManager
+ })
+ return manager, &constructed
+}
+
+func TestDaemonStartAndRestartRefuseWhenNotInstalled(t *testing.T) {
+ for _, sub := range []string{"start", "restart"} {
+ t.Run(sub, func(t *testing.T) {
+ manager, constructed := stubDaemonSeams(t, false, nil)
+
+ var code int
+ output := captureStderr(t, func() {
+ code = dispatchDaemonCommand(sub, false)
+ })
+
+ if code != 1 {
+ t.Fatalf("exit code = %d, want 1", code)
+ }
+ if !strings.Contains(output, "pinchtab daemon install") {
+ t.Fatalf("expected remedy in output, got %q", output)
+ }
+ if !strings.Contains(output, "not installed") {
+ t.Fatalf("expected not-installed wording, got %q", output)
+ }
+ for _, forbidden := range []string{"launchctl", "systemctl", "as root"} {
+ if strings.Contains(output, forbidden) {
+ t.Fatalf("output leaks %q: %q", forbidden, output)
+ }
+ }
+ if len(manager.calls) != 0 {
+ t.Fatalf("manager was asked to act: %v", manager.calls)
+ }
+ if *constructed != 0 {
+ t.Fatalf("manager constructed %d times, want 0", *constructed)
+ }
+ })
+ }
+}
+
+func TestDaemonStartRefusesWhenInstallationStateUnknown(t *testing.T) {
+ manager, _ := stubDaemonSeams(t, false, errors.New("permission denied"))
+
+ var code int
+ output := captureStderr(t, func() {
+ code = dispatchDaemonCommand("start", false)
+ })
+
+ if code != 1 {
+ t.Fatalf("exit code = %d, want 1", code)
+ }
+ if !strings.Contains(output, "cannot determine") || !strings.Contains(output, "permission denied") {
+ t.Fatalf("expected cannot-determine wording, got %q", output)
+ }
+ if strings.Contains(output, "not installed") {
+ t.Fatalf("output must not claim not installed: %q", output)
+ }
+ if len(manager.calls) != 0 {
+ t.Fatalf("manager was asked to act: %v", manager.calls)
+ }
+}
+
+func TestDaemonActionsReachManager(t *testing.T) {
+ cases := []struct {
+ sub string
+ installed bool
+ want []string
+ }{
+ {sub: "start", installed: true, want: []string{"Start"}},
+ {sub: "restart", installed: true, want: []string{"Restart"}},
+ {sub: "stop", installed: false, want: []string{"Stop"}},
+ }
+ for _, tc := range cases {
+ t.Run(tc.sub, func(t *testing.T) {
+ manager, _ := stubDaemonSeams(t, tc.installed, nil)
+
+ var code int
+ captureStdout(t, func() {
+ code = dispatchDaemonCommand(tc.sub, false)
+ })
+
+ if code != 0 {
+ t.Fatalf("exit code = %d, want 0", code)
+ }
+ if strings.Join(manager.calls, ",") != strings.Join(tc.want, ",") {
+ t.Fatalf("manager calls = %v, want %v", manager.calls, tc.want)
+ }
+ })
+ }
+}
+
+func TestDaemonStatusMatchesBareForm(t *testing.T) {
+ for _, jsonOut := range []bool{false, true} {
+ bare := captureStdout(t, func() { dispatchDaemonCommand("", jsonOut) })
+ status := captureStdout(t, func() { dispatchDaemonCommand("status", jsonOut) })
+ if bare != status {
+ t.Fatalf("json=%v: status output differs from bare form\nbare: %q\nstatus: %q", jsonOut, bare, status)
+ }
+ }
+}
+
+func TestDaemonUsageListsStatusForm(t *testing.T) {
+ stubDaemonSeams(t, true, nil)
+
+ var code int
+ output := captureStderr(t, func() {
+ code = dispatchDaemonCommand("bogus", false)
+ })
+
+ if code != 2 {
+ t.Fatalf("exit code = %d, want 2", code)
+ }
+ if !strings.Contains(output, "pinchtab daemon <status|install|start|restart|stop|uninstall>") {
+ t.Fatalf("expected usage line listing status, got %q", output)
+ }
+}
+
func TestPrintDaemonStatusJSONShape(t *testing.T) {
output := captureStdout(t, func() {
printDaemonStatusJSON()