FilesExpand file tree

master

/

interactive-shell.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

123 lines (106 loc) · 3.02 KB

master

/

interactive-shell.go

Copy path

Top

File metadata and controls

• Code
• Blame

123 lines (106 loc) · 3.02 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

//go:build ignore

// interactive-shell.go — TUI Suspend example extension for Kit.

//

// Demonstrates ctx.SuspendTUI() which temporarily releases the terminal

// from the TUI so interactive subprocesses can run with full terminal

// control. The TUI is automatically restored when the callback returns.

//

// Commands:

// /edit <file> — opens $EDITOR (or vi) to edit a file

// /shell — drops into an interactive shell session

// /run <cmd> — runs a command with full terminal I/O (no TUI capture)

package main

import (

"fmt"

"os"

"os/exec"

"strings"

ext "kit/ext"

)

func Init(api ext.API) {

api.RegisterCommand(ext.CommandDef{

Name: "edit",

Description: "Open $EDITOR to edit a file (TUI suspends)",

Execute: func(args string, ctx ext.Context) (string, error) {

file := strings.TrimSpace(args)

if file == "" {

return "", fmt.Errorf("usage: /edit <file>")

}

editor := os.Getenv("EDITOR")

if editor == "" {

editor = "vi"

}

ctx.Print(fmt.Sprintf("Opening %s in %s...", file, editor))

err := ctx.SuspendTUI(func() {

cmd := exec.Command(editor, file)

cmd.Stdin = os.Stdin

cmd.Stdout = os.Stdout

cmd.Stderr = os.Stderr

cmd.Run()

})

if err != nil {

return "", fmt.Errorf("editor session failed: %w", err)

}

return fmt.Sprintf("Finished editing %s", file), nil

},

Complete: func(prefix string, ctx ext.Context) []string {

// Suggest files in the current directory.

entries, err := os.ReadDir(".")

if err != nil {

return nil

}

var results []string

for _, e := range entries {

name := e.Name()

if strings.HasPrefix(name, prefix) {

results = append(results, name)

}

}

return results

},

})

api.RegisterCommand(ext.CommandDef{

Name: "shell",

Description: "Drop into an interactive shell (TUI suspends)",

Execute: func(args string, ctx ext.Context) (string, error) {

shell := os.Getenv("SHELL")

if shell == "" {

shell = "/bin/sh"

}

ctx.Print(fmt.Sprintf("Starting %s... (type 'exit' to return to Kit)", shell))

err := ctx.SuspendTUI(func() {

cmd := exec.Command(shell)

cmd.Stdin = os.Stdin

cmd.Stdout = os.Stdout

cmd.Stderr = os.Stderr

cmd.Run()

})

if err != nil {

return "", fmt.Errorf("shell session failed: %w", err)

}

return "Shell session ended, TUI restored.", nil

},

})

api.RegisterCommand(ext.CommandDef{

Name: "run",

Description: "Run a command with full terminal I/O (TUI suspends)",

Execute: func(args string, ctx ext.Context) (string, error) {

cmdStr := strings.TrimSpace(args)

if cmdStr == "" {

return "", fmt.Errorf("usage: /run <command>")

}

ctx.Print(fmt.Sprintf("Running: %s", cmdStr))

err := ctx.SuspendTUI(func() {

cmd := exec.Command("sh", "-c", cmdStr)

cmd.Stdin = os.Stdin

cmd.Stdout = os.Stdout

cmd.Stderr = os.Stderr

cmd.Run()

})

if err != nil {

return "", fmt.Errorf("command failed: %w", err)

}

return "Command finished, TUI restored.", nil

},

})

}