main.go

package main

import (
	"context"
	"fmt"
	"os"
	"os/signal"
	"strconv"
	"strings"
	"syscall"

	"github.com/ActiveMemory/ctx-telephony/internal/agent"
	"github.com/ActiveMemory/ctx-telephony/internal/cli"
	"github.com/ActiveMemory/ctx-telephony/internal/config"
)

func main() {
	if len(os.Args) < 2 {
		usage()
		os.Exit(1)
	}

	cfg, err := config.Load()
	if err != nil {
		fmt.Fprintf(os.Stderr, "config error: %v\n", err)
		os.Exit(1)
	}

	switch os.Args[1] {
	case "agent":
		runAgent(cfg)

	case "send":
		// tel send <target> <command...>
		// tel send --script <file> <target>
		if len(os.Args) < 4 {
			fmt.Fprintln(os.Stderr, "usage: tel send <target> <command...>")
			fmt.Fprintln(os.Stderr, "       tel send --script <file> <target>")
			os.Exit(1)
		}

		var target, cmdStr, scriptFile string
		timeout := 300

		if os.Args[2] == "--script" {
			if len(os.Args) < 5 {
				fmt.Fprintln(os.Stderr, "usage: tel send --script <file> <target>")
				os.Exit(1)
			}
			scriptFile = os.Args[3]
			target = os.Args[4]
			cmdStr = "script:" + scriptFile
		} else {
			target = os.Args[2]
			cmdStr = strings.Join(os.Args[3:], " ")
		}

		// Check for --timeout flag anywhere in args
		for i, arg := range os.Args {
			if arg == "--timeout" && i+1 < len(os.Args) {
				timeout, _ = strconv.Atoi(os.Args[i+1])
			}
		}

		if err := cli.Send(cfg, target, cmdStr, scriptFile, timeout); err != nil {
			fmt.Fprintf(os.Stderr, "error: %v\n", err)
			os.Exit(1)
		}

	case "deploy":
		// tel deploy [flags] <target> <repo-path> <dest>
		executable := true
		noOverwrite := true
		args := os.Args[2:]

		// Parse flags
		var positional []string
		for _, arg := range args {
			switch arg {
			case "--no-exec":
				executable = false
			case "--overwrite":
				noOverwrite = false
			default:
				positional = append(positional, arg)
			}
		}

		if len(positional) < 3 {
			fmt.Fprintln(os.Stderr, "usage: tel deploy [--no-exec] [--overwrite] <target> <repo-path> <dest>")
			os.Exit(1)
		}
		target := positional[0]
		repoSrc := positional[1]
		dest := positional[2]
		if err := cli.DeployFile(cfg, target, repoSrc, dest, executable, noOverwrite); err != nil {
			fmt.Fprintf(os.Stderr, "error: %v\n", err)
			os.Exit(1)
		}

	case "watch":
		pollSecs := 30
		if len(os.Args) > 2 {
			pollSecs, _ = strconv.Atoi(os.Args[2])
		}
		cli.Watch(cfg, pollSecs)

	case "status":
		if err := cli.Status(cfg); err != nil {
			fmt.Fprintf(os.Stderr, "error: %v\n", err)
			os.Exit(1)
		}

	default:
		// Shorthand: tel <target> <command...>
		// e.g., tel hades df -h
		target := os.Args[1]
		if len(os.Args) < 3 {
			usage()
			os.Exit(1)
		}
		cmdStr := strings.Join(os.Args[2:], " ")
		if err := cli.Send(cfg, target, cmdStr, "", 300); err != nil {
			fmt.Fprintf(os.Stderr, "error: %v\n", err)
			os.Exit(1)
		}
	}
}

func runAgent(cfg *config.Config) {
	ctx, cancel := context.WithCancel(context.Background())

	sig := make(chan os.Signal, 1)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
	go func() {
		<-sig
		cancel()
	}()

	a := agent.New(cfg)
	if err := a.Run(ctx); err != nil {
		fmt.Fprintf(os.Stderr, "agent error: %v\n", err)
		os.Exit(1)
	}
}

func usage() {
	fmt.Fprintln(os.Stderr, `telephony — async command bus over git

usage:
  tel agent                          run as daemon (asgard/hades)
  tel send <target> <command...>     queue a command
  tel send --script <file> <target>  queue a script
  tel deploy [--no-exec] [--overwrite] <target> <repo-path> <dest>
  tel <target> <command...>          shorthand for send
  tel watch [poll_secs]              watch for results
  tel status                         show heartbeats`)
}