shellspy progress

.gitignore

@@ -1,3 +1,4 @@
 .shellspy-*.txt
 shellspy-*.txt
+shellspy.txt
 dist/

README.md

@@ -24,4 +24,8 @@ OR
 ```
 > go run cmd/main.go --mode local
 shellspy is running locally
-```
+```
+
+TODO
+- per session readmefile
+- authentication

cmd/shellspy/main.go

@@ -8,6 +8,5 @@ import (
 
 func main() {
 
-	cliArgs := os.Args
-	shellspy.RunCLI(cliArgs, os.Stdout)
+	shellspy.RunCLI(os.Args[1:], os.Stdout)
 }

shellspy.go

@@ -2,7 +2,6 @@ package shellspy
 
 import (
 	"bufio"
-	"bytes"
 	"flag"
 	"fmt"
 	"io"
@@ -11,225 +10,144 @@ import (
 	"os/exec"
 	"os/signal"
 	"strings"
-	"time"
+	"syscall"
 )
 
-type session struct {
-	Input            io.Reader
-	Output           io.Writer
-	TranscriptOutput io.Writer
-	File             *os.File
-	Port             string
+type Session struct {
+	Input      io.Reader
+	Output     io.Writer
+	Terminal   io.Writer
+	Transcript io.Writer
 }
 
-type Option func(*session)
-
-func WithOutput(output io.Writer) Option {
-	return func(s *session) {
-		s.Output = output
-	}
+type Server struct {
+	Port int
+	C    net.Conn
 }
 
-func WithTranscriptOutput(TranscriptOutput io.Writer) Option {
-	return func(s *session) {
-		s.TranscriptOutput = TranscriptOutput
+func RunCLI(cliArgs []string, output io.Writer) {
+
+	if len(cliArgs) == 0 {
+		RunLocally(output)
 	}
-}
 
-func NewSession(opts ...Option) (*session, error) {
+	if len(cliArgs) == 2 {
+		fs := flag.NewFlagSet("cmd", flag.ExitOnError)
+		portFlag := fs.Int("port", 2000, "-port 3000")
 
-	session := &session{}
+		fs.Parse(cliArgs)
 
-	for _, o := range opts {
-		o(session)
-	}
-
-	file, err := CreateTranscriptFile()
-	if err != nil {
-		return session, err
+		if portFlag != nil {
+			RunRemotely(*portFlag)
+		}
 	}
-	session.File = file
-
-	return session, nil
 }
 
-func RunCLI(cliArgs []string, w io.Writer) {
+func NewSession(output io.Writer) (*Session, error) {
 
-	s, err := NewSession(
-		WithOutput(w),
-	)
+	s := &Session{}
 
+	file, err := CreateTranscriptFile()
 	if err != nil {
-		fmt.Printf("%v", err)
-		os.Exit(1)
-	}
-
-	fmt.Println(len(cliArgs))
-	fmt.Println(cliArgs)
-	if len(cliArgs) == 1 {
-		RunLocally(s, w)
-	}
-
-	fs := flag.NewFlagSet("cmd", flag.ContinueOnError)
-	fs.Parse(os.Args[1:])
-
-	switch os.Args[1] {
-	case "port":
-		args := fs.Args()
-		s.Port = args[1]
-		RunRemotely(s, w)
+		return nil, err
 	}
 
+	s.Transcript = file
+	s.Input = os.Stdin
+	s.Terminal = output
+	s.Output = io.MultiWriter(s.Terminal, s.Transcript)
+	return s, nil
 }
 
-func RunLocally(s *session, w io.Writer) {
+func CreateTranscriptFile() (*os.File, error) {
 
-	buf := &bytes.Buffer{}
-	buf.WriteString("shellspy is running locally\n")
-	fmt.Fprint(w, buf)
-	s.Output = w
-	input := io.Reader(os.Stdin)
-	Input(input, s)
+	file, err := os.OpenFile("shellspy.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return nil, err
+	}
+	return file, nil
 }
 
-func RunRemotely(s *session, w io.Writer) error {
+func RunRemotely(port int) error {
 
-	port := s.Port
-	buf := &bytes.Buffer{}
-	buf.WriteString("shellspy is running remotely " + port + "\n")
-	fmt.Fprint(w, buf)
-	s.TranscriptOutput = buf
-
-	address := "localhost:" + port
+	fmt.Printf("shellspy is running remotely on port %v and the output file is shellspy.txt\n", port)
+	address := fmt.Sprintf("localhost:%d", port)
 
 	listener, err := net.Listen("tcp", address)
 	if err != nil {
 		return err
 	}
-	killSignal := make(chan os.Signal, 1)
-	signal.Notify(killSignal, os.Interrupt)
+
 	for {
+
+		killSignal := make(chan os.Signal, 1)
+		signal.Notify(killSignal, syscall.SIGINT, syscall.SIGTERM)
+
+		go func() {
+			<-killSignal
+			os.Exit(0)
+		}()
+
 		conn, err := listener.Accept()
 		if err != nil {
 			return err
 		}
-		go handleConn(conn, s)
 
-		<-killSignal
-		fmt.Println("\nconnection terminated by server!")
-		listener.Close()
+		go handleConn(conn)
+
 	}
 }
 
-func handleConn(c net.Conn, s *session) {
-
-	fmt.Fprintf(c, "hello, welcome to shellspy"+"\n")
-	input := io.Reader(c)
-	exitStatus := Input(input, s)
-	if exitStatus == "0" {
+func handleConn(c net.Conn) {
+	s, err := NewSession(c)
+	if err != nil {
+		fmt.Fprint(c, err)
 		c.Close()
+		fmt.Printf("connection is closed due to: %v", err)
 	}
-	c.Close()
-}
-
-func Input(input io.Reader, s *session) string {
 
-	scanner := bufio.NewScanner(input)
-	for scanner.Scan() {
-		s.Input = strings.NewReader(scanner.Text())
-		exitStatus := s.Run()
-		if exitStatus == "0" {
-			return "0"
-		}
-	}
-	return ""
+	fmt.Printf("new connection established %s and the file is shellspy.txt ", c.RemoteAddr())
+	s.Input = c
+	s.Start()
 }
 
-func (s *session) Run() string {
-
-	writer := &bytes.Buffer{}
-	twriter := &bytes.Buffer{}
-	iReader := &bytes.Buffer{}
-	fmt.Fprint(iReader, s.Input)
-	file := s.File
-	input := iReader.String()
-	input = strings.TrimPrefix(input, "&{")
-	input = strings.TrimSuffix(input, " 0 -1}")
-	stdOut, exitStatus := RunServer(input, file)
-	if exitStatus == "0" {
-		return "0"
+func RunLocally(output io.Writer) {
+	s, err := NewSession(output)
+	if err != nil {
+		fmt.Println("cannot create transcript file")
+		os.Exit(1)
 	}
-	s.Output = writer
-	s.TranscriptOutput = twriter
-	fmt.Fprint(writer, stdOut)
-	fmt.Fprint(twriter, stdOut)
-	return ""
+	s.Start()
 }
 
-func RunServer(line string, file *os.File) (string, string) {
+func (s *Session) Start() {
 
-	cmd := CommandFromString(line)
+	fmt.Fprintln(s.Output, "welcome to shellspy")
+	fmt.Fprintf(s.Output, "$ ")
+	scanner := bufio.NewScanner(s.Input)
 
-	if strings.HasPrefix(line, "exit") {
-		return "", "0"
+	for scanner.Scan() {
+		cmd := CommandFromString(scanner.Text())
+		input := scanner.Text() + "\n"
+		cmd.Stdout = s.Output
+		cmd.Stderr = s.Output
+		fmt.Fprint(s.Transcript, input)
+		if scanner.Text() == "exit" {
+			os.Exit(0)
+		}
+		err := cmd.Run()
+		if err != nil {
+			fmt.Fprint(s.Output, err)
+		}
+		fmt.Fprintf(s.Output, "$ ")
 	}
-
-	stdOut, stdErr := RunFromCmd(cmd)
-	WriteTranscript(stdOut, stdErr, cmd, file)
-	return stdOut, ""
 }
 
 func CommandFromString(line string) *exec.Cmd {
+
 	trim := strings.TrimSuffix(line, "\n")
 	name := strings.Fields(trim)
 	args := name[1:]
-	join := strings.Join(args, " ")
-	cmd := exec.Command(name[0], join)
+	cmd := exec.Command(name[0], args...)
 	return cmd
 }
-
-func RunFromCmd(cmd *exec.Cmd) (string, string) {
-	var outb bytes.Buffer
-	var errb bytes.Buffer
-	cmd.Stdout = &outb
-	cmd.Stderr = &errb
-
-	cmd.Run()
-
-	stdOut := outb.String()
-	stdErr := errb.String()
-
-	return stdOut, stdErr
-}
-
-func CreateTranscriptFile() (*os.File, error) {
-	now := time.Now()
-	filename := ".shellspy-" + now.Format("2006-01-02-15:04:05") + ".txt"
-	file, err := os.OpenFile(filename,
-		os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	if err != nil {
-		return nil, err
-	}
-	return file, nil
-}
-
-func WriteTranscript(stdOut, stdErr string, cmd *exec.Cmd, file *os.File) os.File {
-
-	if _, err := file.WriteString(cmd.String()); err != nil {
-		err = fmt.Errorf("unable to write cmd to disk due to error; %w", err)
-		file.WriteString(err.Error())
-	}
-
-	file.WriteString("\n")
-
-	if stdErr != "" {
-		file.WriteString(stdErr)
-	}
-
-	if _, err := file.WriteString(stdOut); err != nil {
-		err = fmt.Errorf("unable to write stdOut to disk due to error; %w", err)
-		file.WriteString(err.Error())
-	}
-
-	return *file
-}