feat: improve session terminals (#185)

This commit is contained in:
Carlos Florêncio
2026-02-05 04:09:04 +00:00
committed by GitHub
parent 1a69152f09
commit 06f7fe9795
31 changed files with 2327 additions and 504 deletions
+21 -2
View File
@@ -10,6 +10,7 @@ import (
"github.com/kandev/kandev/internal/agent/lifecycle"
"github.com/kandev/kandev/internal/agent/registry"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/common/scripts"
"github.com/kandev/kandev/internal/events"
"github.com/kandev/kandev/internal/events/bus"
gateways "github.com/kandev/kandev/internal/gateway/websocket"
@@ -23,6 +24,23 @@ import (
userservice "github.com/kandev/kandev/internal/user/service"
)
// scriptServiceAdapter adapts the task service to scripts.ScriptService.
type scriptServiceAdapter struct {
taskSvc *taskservice.Service
}
func (a *scriptServiceAdapter) GetRepositoryScript(ctx context.Context, id string) (*scripts.RepositoryScript, error) {
script, err := a.taskSvc.GetRepositoryScript(ctx, id)
if err != nil {
return nil, err
}
return &scripts.RepositoryScript{
ID: script.ID,
Name: script.Name,
Command: script.Command,
}, nil
}
func provideGateway(
ctx context.Context,
log *logger.Logger,
@@ -42,8 +60,9 @@ func provideGateway(
_ = cleanup
// Enable dedicated terminal WebSocket for passthrough mode
scriptSvc := &scriptServiceAdapter{taskSvc: taskSvc}
if lifecycleMgr != nil {
gateway.SetLifecycleManager(lifecycleMgr)
gateway.SetLifecycleManager(lifecycleMgr, userSvc, scriptSvc)
}
orchestratorHandlers := orchestratorhandlers.NewHandlers(orchestratorSvc, log)
@@ -57,7 +76,7 @@ func provideGateway(
workspaceFileHandlers := agenthandlers.NewWorkspaceFileHandlers(lifecycleMgr, log)
workspaceFileHandlers.RegisterHandlers(gateway.Dispatcher)
shellHandlers := agenthandlers.NewShellHandlers(lifecycleMgr, log)
shellHandlers := agenthandlers.NewShellHandlers(lifecycleMgr, scriptSvc, log)
shellHandlers.RegisterHandlers(gateway.Dispatcher)
gitHandlers := agenthandlers.NewGitHandlers(lifecycleMgr, log)
+2
View File
@@ -30,6 +30,7 @@ import (
// Agent Manager packages
"github.com/kandev/kandev/internal/agent/docker"
agenthandlers "github.com/kandev/kandev/internal/agent/handlers"
agentsettingshandlers "github.com/kandev/kandev/internal/agent/settings/handlers"
editorcontroller "github.com/kandev/kandev/internal/editors/controller"
@@ -533,6 +534,7 @@ func main() {
log,
)
taskhandlers.RegisterProcessRoutes(router, taskSvc, lifecycleMgr, log)
agenthandlers.RegisterShellRoutes(router, lifecycleMgr, log)
log.Debug("Registered Task Service handlers (HTTP + WebSocket)")
workflowhandlers.RegisterRoutes(router, gateway.Dispatcher, workflowCtrl, log)
@@ -4,10 +4,14 @@ package handlers
import (
"context"
"fmt"
"net/http"
"time"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
"github.com/kandev/kandev/internal/agent/lifecycle"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/common/scripts"
ws "github.com/kandev/kandev/pkg/websocket"
"go.uber.org/zap"
)
@@ -16,15 +20,17 @@ import (
// Shell output is streamed via the lifecycle manager and event bus.
// This handler provides shell.status, shell.subscribe (for buffer), and shell.input.
type ShellHandlers struct {
lifecycleMgr *lifecycle.Manager
logger *logger.Logger
lifecycleMgr *lifecycle.Manager
scriptService scripts.ScriptService
logger *logger.Logger
}
// NewShellHandlers creates a new ShellHandlers instance
func NewShellHandlers(lifecycleMgr *lifecycle.Manager, log *logger.Logger) *ShellHandlers {
func NewShellHandlers(lifecycleMgr *lifecycle.Manager, scriptService scripts.ScriptService, log *logger.Logger) *ShellHandlers {
return &ShellHandlers{
lifecycleMgr: lifecycleMgr,
logger: log.WithFields(zap.String("component", "shell_handlers")),
lifecycleMgr: lifecycleMgr,
scriptService: scriptService,
logger: log.WithFields(zap.String("component", "shell_handlers")),
}
}
@@ -33,6 +39,9 @@ func (h *ShellHandlers) RegisterHandlers(d *ws.Dispatcher) {
d.RegisterFunc(ws.ActionShellStatus, h.wsShellStatus)
d.RegisterFunc(ws.ActionShellSubscribe, h.wsShellSubscribe)
d.RegisterFunc(ws.ActionShellInput, h.wsShellInput)
d.RegisterFunc(ws.ActionUserShellList, h.wsUserShellList)
d.RegisterFunc(ws.ActionUserShellCreate, h.wsUserShellCreate)
d.RegisterFunc(ws.ActionUserShellStop, h.wsUserShellStop)
}
// ShellStatusRequest for shell.status action
@@ -178,3 +187,205 @@ func (h *ShellHandlers) wsShellInput(ctx context.Context, msg *ws.Message) (*ws.
"success": true,
})
}
// UserShellListRequest for user_shell.list action
type UserShellListRequest struct {
SessionID string `json:"session_id"`
}
// wsUserShellList returns all running user shells for a session
func (h *ShellHandlers) wsUserShellList(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
var req UserShellListRequest
if err := msg.ParsePayload(&req); err != nil {
return nil, fmt.Errorf("invalid payload: %w", err)
}
if req.SessionID == "" {
return nil, fmt.Errorf("session_id is required")
}
// Get the interactive runner
interactiveRunner := h.lifecycleMgr.GetInteractiveRunner()
if interactiveRunner == nil {
return ws.NewResponse(msg.ID, msg.Action, map[string]interface{}{
"shells": []interface{}{},
})
}
// Get list of user shells
shells := interactiveRunner.ListUserShells(req.SessionID)
h.logger.Debug("listing user shells",
zap.String("session_id", req.SessionID),
zap.Int("count", len(shells)))
return ws.NewResponse(msg.ID, msg.Action, map[string]interface{}{
"shells": shells,
})
}
// UserShellCreateRequest for user_shell.create action
type UserShellCreateRequest struct {
SessionID string `json:"session_id"`
ScriptID string `json:"script_id,omitempty"` // Optional: create a script terminal instead of plain shell
}
// wsUserShellCreate creates a new user shell terminal and returns the assigned ID and label
func (h *ShellHandlers) wsUserShellCreate(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
var req UserShellCreateRequest
if err := msg.ParsePayload(&req); err != nil {
return nil, fmt.Errorf("invalid payload: %w", err)
}
if req.SessionID == "" {
return nil, fmt.Errorf("session_id is required")
}
// Get the interactive runner
interactiveRunner := h.lifecycleMgr.GetInteractiveRunner()
if interactiveRunner == nil {
return nil, fmt.Errorf("interactive runner not available")
}
var terminalID, label, initialCommand string
var closable bool
if req.ScriptID != "" {
// Creating a script terminal - look up the script
if h.scriptService == nil {
return nil, fmt.Errorf("script service not available")
}
script, err := h.scriptService.GetRepositoryScript(ctx, req.ScriptID)
if err != nil {
h.logger.Error("failed to get repository script",
zap.String("script_id", req.ScriptID),
zap.Error(err))
return nil, fmt.Errorf("invalid script ID: %w", err)
}
terminalID = "script-" + uuid.New().String()
label = script.Name
initialCommand = script.Command
closable = true // Script terminals are always closable
// Register the script terminal with the interactive runner
interactiveRunner.RegisterScriptShell(req.SessionID, terminalID, label, initialCommand)
h.logger.Info("created script terminal",
zap.String("session_id", req.SessionID),
zap.String("terminal_id", terminalID),
zap.String("label", label),
zap.String("script_id", req.ScriptID),
zap.String("initial_command", initialCommand))
} else {
// Creating a plain shell terminal
result := interactiveRunner.CreateUserShell(req.SessionID)
terminalID = result.TerminalID
label = result.Label
closable = result.Closable
h.logger.Info("created user shell",
zap.String("session_id", req.SessionID),
zap.String("terminal_id", terminalID),
zap.String("label", label),
zap.Bool("closable", closable))
}
return ws.NewResponse(msg.ID, msg.Action, map[string]any{
"terminal_id": terminalID,
"label": label,
"closable": closable,
"initial_command": initialCommand,
})
}
// UserShellStopRequest for user_shell.stop action
type UserShellStopRequest struct {
SessionID string `json:"session_id"`
TerminalID string `json:"terminal_id"`
}
// wsUserShellStop stops a user shell terminal process
func (h *ShellHandlers) wsUserShellStop(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
var req UserShellStopRequest
if err := msg.ParsePayload(&req); err != nil {
return nil, fmt.Errorf("invalid payload: %w", err)
}
if req.SessionID == "" {
return nil, fmt.Errorf("session_id is required")
}
if req.TerminalID == "" {
return nil, fmt.Errorf("terminal_id is required")
}
// Get the interactive runner
interactiveRunner := h.lifecycleMgr.GetInteractiveRunner()
if interactiveRunner == nil {
return nil, fmt.Errorf("interactive runner not available")
}
// Stop the user shell
if err := interactiveRunner.StopUserShell(ctx, req.SessionID, req.TerminalID); err != nil {
h.logger.Warn("failed to stop user shell",
zap.String("session_id", req.SessionID),
zap.String("terminal_id", req.TerminalID),
zap.Error(err))
// Don't return error - shell may already be stopped
}
h.logger.Info("user shell stopped",
zap.String("session_id", req.SessionID),
zap.String("terminal_id", req.TerminalID))
return ws.NewResponse(msg.ID, msg.Action, map[string]interface{}{
"success": true,
})
}
// RegisterShellRoutes registers HTTP routes for shell operations.
// This is separate from RegisterHandlers which registers WebSocket handlers.
func RegisterShellRoutes(router *gin.Engine, lifecycleMgr *lifecycle.Manager, log *logger.Logger) {
handlers := NewShellHandlers(lifecycleMgr, nil, log)
api := router.Group("/api/v1")
api.GET("/sessions/:id/terminals", handlers.httpListTerminals)
}
// httpListTerminals returns all terminals for a session (for SSR).
func (h *ShellHandlers) httpListTerminals(c *gin.Context) {
sessionID := c.Param("id")
if sessionID == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "session_id is required"})
return
}
// Get the interactive runner
interactiveRunner := h.lifecycleMgr.GetInteractiveRunner()
if interactiveRunner == nil {
c.JSON(http.StatusOK, gin.H{"terminals": []interface{}{}})
return
}
// Get list of user shells
shells := interactiveRunner.ListUserShells(sessionID)
h.logger.Debug("listing terminals via HTTP",
zap.String("session_id", sessionID),
zap.Int("count", len(shells)))
// Transform to response format
terminals := make([]map[string]interface{}, len(shells))
for i, shell := range shells {
terminals[i] = map[string]interface{}{
"terminal_id": shell.TerminalID,
"process_id": shell.ProcessID,
"running": shell.Running,
"label": shell.Label,
"closable": shell.Closable,
"initial_command": shell.InitialCommand,
}
}
c.JSON(http.StatusOK, gin.H{"terminals": terminals})
}
@@ -80,7 +80,7 @@ func TestNewShellHandlers(t *testing.T) {
log := newTestLogger()
// NewShellHandlers accepts *lifecycle.Manager, but we can pass nil for basic construction test
handlers := NewShellHandlers(nil, log)
handlers := NewShellHandlers(nil, nil, log)
if handlers == nil {
t.Fatal("expected non-nil handlers")
@@ -95,7 +95,7 @@ func TestNewShellHandlers(t *testing.T) {
func TestRegisterHandlers(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, log)
handlers := NewShellHandlers(nil, nil, log)
dispatcher := ws.NewDispatcher()
handlers.RegisterHandlers(dispatcher)
@@ -113,7 +113,7 @@ func TestRegisterHandlers(t *testing.T) {
func TestWsShellStatus_InvalidPayload(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, log)
handlers := NewShellHandlers(nil, nil, log)
// Create a message with invalid payload
msg := &ws.Message{
@@ -130,7 +130,7 @@ func TestWsShellStatus_InvalidPayload(t *testing.T) {
func TestWsShellStatus_MissingTaskID(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, log)
handlers := NewShellHandlers(nil, nil, log)
// Create a message with empty session_id
msg, _ := ws.NewRequest("test-1", ws.ActionShellStatus, ShellStatusRequest{SessionID: ""})
@@ -146,7 +146,7 @@ func TestWsShellStatus_MissingTaskID(t *testing.T) {
func TestWsShellInput_InvalidPayload(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, log)
handlers := NewShellHandlers(nil, nil, log)
msg := &ws.Message{
ID: "test-1",
@@ -162,7 +162,7 @@ func TestWsShellInput_InvalidPayload(t *testing.T) {
func TestWsShellInput_MissingTaskID(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, log)
handlers := NewShellHandlers(nil, nil, log)
msg, _ := ws.NewRequest("test-1", ws.ActionShellInput, ShellInputRequest{SessionID: "", Data: "test"})
@@ -189,7 +189,7 @@ func newTestManager() *lifecycle.Manager {
func TestWsShellStatus_NoInstanceFound(t *testing.T) {
log := newTestLogger()
mgr := newTestManager()
handlers := NewShellHandlers(mgr, log)
handlers := NewShellHandlers(mgr, nil, log)
msg, _ := ws.NewRequest("test-1", ws.ActionShellStatus, ShellStatusRequest{SessionID: "session-1"})
@@ -215,7 +215,7 @@ func TestWsShellStatus_NoInstanceFound(t *testing.T) {
func TestWsShellStatus_NoClientAvailable(t *testing.T) {
log := newTestLogger()
mgr := newTestManager()
handlers := NewShellHandlers(mgr, log)
handlers := NewShellHandlers(mgr, nil, log)
// When no instance exists for the task, handler returns "no agent running"
// Note: Testing the "agent client not available" path requires injecting an
@@ -242,7 +242,7 @@ func TestWsShellStatus_NoClientAvailable(t *testing.T) {
func TestWsShellInput_NoInstanceFound(t *testing.T) {
log := newTestLogger()
mgr := newTestManager()
handlers := NewShellHandlers(mgr, log)
handlers := NewShellHandlers(mgr, nil, log)
msg, _ := ws.NewRequest("test-1", ws.ActionShellInput, ShellInputRequest{
SessionID: "session-1",
@@ -263,7 +263,7 @@ func TestNewShellHandlers_WithManager(t *testing.T) {
log := newTestLogger()
mgr := newTestManager()
handlers := NewShellHandlers(mgr, log)
handlers := NewShellHandlers(mgr, nil, log)
if handlers == nil {
t.Fatal("expected non-nil handlers")
@@ -275,7 +275,7 @@ func TestNewShellHandlers_WithManager(t *testing.T) {
func TestRegisterHandlers_DispatcherReceivesMessages(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, log)
handlers := NewShellHandlers(nil, nil, log)
dispatcher := ws.NewDispatcher()
handlers.RegisterHandlers(dispatcher)
@@ -289,3 +289,217 @@ func TestRegisterHandlers_DispatcherReceivesMessages(t *testing.T) {
t.Error("expected error from dispatcher")
}
}
// --- User Shell Handler Tests ---
func TestRegisterHandlers_UserShellActions(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, nil, log)
dispatcher := ws.NewDispatcher()
handlers.RegisterHandlers(dispatcher)
// Verify user shell actions are registered
if !dispatcher.HasHandler(ws.ActionUserShellList) {
t.Error("expected user_shell.list handler to be registered")
}
if !dispatcher.HasHandler(ws.ActionUserShellCreate) {
t.Error("expected user_shell.create handler to be registered")
}
if !dispatcher.HasHandler(ws.ActionUserShellStop) {
t.Error("expected user_shell.stop handler to be registered")
}
}
func TestWsUserShellList_InvalidPayload(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, nil, log)
msg := &ws.Message{
ID: "test-1",
Action: ws.ActionUserShellList,
Payload: json.RawMessage(`{invalid json`),
}
_, err := handlers.wsUserShellList(context.Background(), msg)
if err == nil {
t.Error("expected error for invalid payload")
}
}
func TestWsUserShellList_MissingSessionID(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, nil, log)
msg, _ := ws.NewRequest("test-1", ws.ActionUserShellList, UserShellListRequest{SessionID: ""})
_, err := handlers.wsUserShellList(context.Background(), msg)
if err == nil {
t.Error("expected error for missing session_id")
}
if err.Error() != "session_id is required" {
t.Errorf("expected 'session_id is required', got: %v", err)
}
}
func TestWsUserShellList_NoInteractiveRunner(t *testing.T) {
log := newTestLogger()
mgr := newTestManager()
handlers := NewShellHandlers(mgr, nil, log)
msg, _ := ws.NewRequest("test-1", ws.ActionUserShellList, UserShellListRequest{SessionID: "session-1"})
resp, err := handlers.wsUserShellList(context.Background(), msg)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
// Should return empty shells since interactive runner is not set up
var payload map[string]interface{}
if err := resp.ParsePayload(&payload); err != nil {
t.Fatalf("failed to parse payload: %v", err)
}
shells, ok := payload["shells"]
if !ok {
t.Error("expected 'shells' in response")
}
shellList, ok := shells.([]interface{})
if !ok {
t.Errorf("expected shells to be an array, got %T", shells)
}
if len(shellList) != 0 {
t.Errorf("expected empty shells array, got %d items", len(shellList))
}
}
func TestWsUserShellCreate_InvalidPayload(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, nil, log)
msg := &ws.Message{
ID: "test-1",
Action: ws.ActionUserShellCreate,
Payload: json.RawMessage(`{invalid json`),
}
_, err := handlers.wsUserShellCreate(context.Background(), msg)
if err == nil {
t.Error("expected error for invalid payload")
}
}
func TestWsUserShellCreate_MissingSessionID(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, nil, log)
msg, _ := ws.NewRequest("test-1", ws.ActionUserShellCreate, UserShellCreateRequest{SessionID: ""})
_, err := handlers.wsUserShellCreate(context.Background(), msg)
if err == nil {
t.Error("expected error for missing session_id")
}
if err.Error() != "session_id is required" {
t.Errorf("expected 'session_id is required', got: %v", err)
}
}
func TestWsUserShellCreate_NoInteractiveRunner(t *testing.T) {
log := newTestLogger()
mgr := newTestManager()
handlers := NewShellHandlers(mgr, nil, log)
msg, _ := ws.NewRequest("test-1", ws.ActionUserShellCreate, UserShellCreateRequest{SessionID: "session-1"})
_, err := handlers.wsUserShellCreate(context.Background(), msg)
if err == nil {
t.Error("expected error when interactive runner not available")
}
if err.Error() != "interactive runner not available" {
t.Errorf("expected 'interactive runner not available', got: %v", err)
}
}
func TestWsUserShellCreate_ScriptID_NoScriptService(t *testing.T) {
log := newTestLogger()
mgr := newTestManager()
// Pass nil for script service
handlers := NewShellHandlers(mgr, nil, log)
msg, _ := ws.NewRequest("test-1", ws.ActionUserShellCreate, UserShellCreateRequest{
SessionID: "session-1",
ScriptID: "script-123",
})
// This will fail because interactive runner is nil (checked before script service),
// so the error is "interactive runner not available"
_, err := handlers.wsUserShellCreate(context.Background(), msg)
if err == nil {
t.Error("expected error")
}
}
func TestWsUserShellStop_InvalidPayload(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, nil, log)
msg := &ws.Message{
ID: "test-1",
Action: ws.ActionUserShellStop,
Payload: json.RawMessage(`{invalid json`),
}
_, err := handlers.wsUserShellStop(context.Background(), msg)
if err == nil {
t.Error("expected error for invalid payload")
}
}
func TestWsUserShellStop_MissingSessionID(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, nil, log)
msg, _ := ws.NewRequest("test-1", ws.ActionUserShellStop, UserShellStopRequest{SessionID: "", TerminalID: "term-1"})
_, err := handlers.wsUserShellStop(context.Background(), msg)
if err == nil {
t.Error("expected error for missing session_id")
}
if err.Error() != "session_id is required" {
t.Errorf("expected 'session_id is required', got: %v", err)
}
}
func TestWsUserShellStop_MissingTerminalID(t *testing.T) {
log := newTestLogger()
handlers := NewShellHandlers(nil, nil, log)
msg, _ := ws.NewRequest("test-1", ws.ActionUserShellStop, UserShellStopRequest{SessionID: "session-1", TerminalID: ""})
_, err := handlers.wsUserShellStop(context.Background(), msg)
if err == nil {
t.Error("expected error for missing terminal_id")
}
if err.Error() != "terminal_id is required" {
t.Errorf("expected 'terminal_id is required', got: %v", err)
}
}
func TestWsUserShellStop_NoInteractiveRunner(t *testing.T) {
log := newTestLogger()
mgr := newTestManager()
handlers := NewShellHandlers(mgr, nil, log)
msg, _ := ws.NewRequest("test-1", ws.ActionUserShellStop, UserShellStopRequest{
SessionID: "session-1",
TerminalID: "term-1",
})
_, err := handlers.wsUserShellStop(context.Background(), msg)
if err == nil {
t.Error("expected error when interactive runner not available")
}
if err.Error() != "interactive runner not available" {
t.Errorf("expected 'interactive runner not available', got: %v", err)
}
}
@@ -2789,9 +2789,18 @@ func (m *Manager) handlePassthroughStatus(status *agentctltypes.ProcessStatusUpd
m.eventPublisher.PublishProcessStatus(execution, clientStatus)
// Check if process exited and should be auto-restarted
// Only restart if this is the ACTUAL passthrough process, not user shell terminals
// Run asynchronously to allow the old process to be cleaned up first
if status.Status == agentctltypes.ProcessStatusExited || status.Status == agentctltypes.ProcessStatusFailed {
go m.handlePassthroughExit(execution, status)
// Only trigger auto-restart for the passthrough process, not for user shell terminals
if execution.PassthroughProcessID != "" && status.ProcessID == execution.PassthroughProcessID {
go m.handlePassthroughExit(execution, status)
} else {
m.logger.Debug("process exited but not the passthrough process, skipping auto-restart",
zap.String("session_id", status.SessionID),
zap.String("exited_process_id", status.ProcessID),
zap.String("passthrough_process_id", execution.PassthroughProcessID))
}
}
}
@@ -14,6 +14,8 @@ import (
"os"
"os/exec"
"regexp"
"sort"
"strings"
"sync"
"syscall"
"time"
@@ -40,6 +42,7 @@ type InteractiveStartRequest struct {
ImmediateStart bool `json:"immediate_start,omitempty"` // Start immediately with default dimensions (don't wait for resize)
DefaultCols int `json:"default_cols,omitempty"` // Default columns if ImmediateStart (default 120)
DefaultRows int `json:"default_rows,omitempty"` // Default rows if ImmediateStart (default 40)
InitialCommand string `json:"initial_command,omitempty"` // Command to write to stdin after shell starts (for script terminals)
}
// InteractiveProcessInfo represents the state of an interactive process.
@@ -122,6 +125,15 @@ type sessionWebSocket struct {
mu sync.RWMutex
}
// userShellEntry tracks a user shell with its metadata.
type userShellEntry struct {
ProcessID string
Label string // Display name (e.g., "Terminal" or "Terminal 2")
InitialCommand string // Command that was run when shell started (empty for plain shells)
Closable bool // Whether the terminal can be closed (first terminal is not closable)
CreatedAt time.Time // When the shell was created (for stable ordering)
}
// InteractiveRunner manages interactive PTY-based processes with stdin support.
type InteractiveRunner struct {
logger *logger.Logger
@@ -138,6 +150,10 @@ type InteractiveRunner struct {
// Session-level WebSocket tracking - survives process restarts
sessionWsMu sync.RWMutex
sessionWs map[string]*sessionWebSocket
// User shell processes - key: "sessionId:terminalId"
userShellsMu sync.RWMutex
userShells map[string]*userShellEntry
}
// NewInteractiveRunner creates a new interactive process runner.
@@ -148,6 +164,7 @@ func NewInteractiveRunner(workspaceTracker *WorkspaceTracker, log *logger.Logger
bufferMaxBytes: bufferMaxBytes,
processes: make(map[string]*interactiveProcess),
sessionWs: make(map[string]*sessionWebSocket),
userShells: make(map[string]*userShellEntry),
}
}
@@ -363,6 +380,29 @@ func (r *InteractiveRunner) startProcess(proc *interactiveProcess, cols, rows in
go r.readOutput(proc)
go r.wait(proc)
// If an initial command was provided, write it to the PTY after a short delay
// to allow the shell to initialize and display its prompt
if req.InitialCommand != "" {
go func() {
time.Sleep(100 * time.Millisecond)
proc.mu.Lock()
pty := proc.ptmx
proc.mu.Unlock()
if pty != nil {
_, err := pty.Write([]byte(req.InitialCommand + "\n"))
if err != nil {
r.logger.Warn("failed to write initial command to PTY",
zap.String("process_id", proc.info.ID),
zap.Error(err))
} else {
r.logger.Debug("wrote initial command to PTY",
zap.String("process_id", proc.info.ID),
zap.String("command", req.InitialCommand))
}
}
}()
}
return nil
}
@@ -823,6 +863,7 @@ func (r *InteractiveRunner) wait(proc *interactiveProcess) {
)
// Log buffer contents if process exited with error (helps debug startup failures)
// Use Debug level since non-zero exit is normal for killed processes (e.g., user closing terminal)
if status == types.ProcessStatusFailed && proc.buffer != nil {
chunks := proc.buffer.snapshot()
if len(chunks) > 0 {
@@ -834,7 +875,7 @@ func (r *InteractiveRunner) wait(proc *interactiveProcess) {
if len(combinedOutput) > 2000 {
combinedOutput = combinedOutput[:2000] + "...(truncated)"
}
r.logger.Error("interactive process output before exit",
r.logger.Debug("interactive process output before exit",
zap.String("process_id", proc.info.ID),
zap.String("session_id", proc.info.SessionID),
zap.Int("exit_code", exitCode),
@@ -1189,6 +1230,373 @@ func (r *InteractiveRunner) WriteToDirectOutputBySession(sessionID string, data
return err
}
// UserShellOptions contains optional parameters for starting a user shell.
type UserShellOptions struct {
Label string // Display name (e.g., "Terminal" or script name)
InitialCommand string // Command to run after shell starts
Closable *bool // Whether the terminal can be closed (nil = auto-determine)
}
// CreateUserShellResult contains the result of creating a new user shell.
type CreateUserShellResult struct {
TerminalID string `json:"terminal_id"`
Label string `json:"label"`
Closable bool `json:"closable"`
}
// CreateUserShell creates a new user shell terminal with auto-assigned ID and label.
// The first shell for a session is labeled "Terminal" and is not closable.
// Subsequent shells are labeled "Terminal 2", "Terminal 3", etc. and are closable.
// The entry is registered atomically to prevent races with ListUserShells.
func (r *InteractiveRunner) CreateUserShell(sessionID string) CreateUserShellResult {
r.userShellsMu.Lock()
defer r.userShellsMu.Unlock()
// Count existing plain shell terminals for this session
prefix := sessionID + ":"
shellCount := 0
for key, entry := range r.userShells {
if strings.HasPrefix(key, prefix) {
terminalID := key[len(prefix):]
// Only count plain shells (not script terminals)
if strings.HasPrefix(terminalID, "shell-") && entry.InitialCommand == "" {
shellCount++
}
}
}
// Generate terminal ID and label
terminalID := "shell-" + uuid.New().String()
var label string
var closable bool
if shellCount == 0 {
label = "Terminal"
closable = false // First terminal is not closable
} else {
label = fmt.Sprintf("Terminal %d", shellCount+1)
closable = true
}
// Register the entry so ListUserShells includes it immediately
r.userShells[prefix+terminalID] = &userShellEntry{
ProcessID: "", // No process yet - will be started when WebSocket connects
Label: label,
InitialCommand: "",
Closable: closable,
CreatedAt: time.Now().UTC(),
}
return CreateUserShellResult{
TerminalID: terminalID,
Label: label,
Closable: closable,
}
}
// RegisterScriptShell registers a script terminal entry so ListUserShells returns it.
// The actual process is not started until the WebSocket connects (StartUserShell handles that).
func (r *InteractiveRunner) RegisterScriptShell(sessionID, terminalID, label, initialCommand string) {
key := sessionID + ":" + terminalID
r.userShellsMu.Lock()
defer r.userShellsMu.Unlock()
r.userShells[key] = &userShellEntry{
ProcessID: "", // No process yet - will be started when WebSocket connects
Label: label,
InitialCommand: initialCommand,
Closable: true, // Script terminals are always closable
CreatedAt: time.Now().UTC(),
}
}
// StartUserShell starts or returns an existing user shell for a terminal tab.
// Each terminal tab gets its own independent shell process.
// If opts.InitialCommand is provided, it will be written to stdin after the shell starts.
func (r *InteractiveRunner) StartUserShell(ctx context.Context, sessionID, terminalID, workingDir, preferredShell string, opts *UserShellOptions) (*InteractiveProcessInfo, error) {
key := sessionID + ":" + terminalID
// Normalize options
if opts == nil {
opts = &UserShellOptions{}
}
if opts.Label == "" {
opts.Label = "Terminal"
}
// Check if shell entry already exists (auto-created by ListUserShells or RegisterScriptShell)
var existingEntry *userShellEntry
r.userShellsMu.RLock()
entry, exists := r.userShells[key]
if exists {
// If entry has a process, check if it's still alive
if entry.ProcessID != "" {
if info, ok := r.Get(entry.ProcessID, false); ok {
r.userShellsMu.RUnlock()
return info, nil
}
// Process died - we'll start a new one below
}
// Entry exists but no process (pre-registered) or process died
// Keep the existing metadata (label, closable, createdAt, initialCommand)
existingEntry = entry
}
r.userShellsMu.RUnlock()
// Use initial command from pre-registered entry if not provided in opts
initialCommand := opts.InitialCommand
if initialCommand == "" && existingEntry != nil {
initialCommand = existingEntry.InitialCommand
}
// Determine shell to use
shell := preferredShell
if shell == "" {
shell = os.Getenv("SHELL")
}
if shell == "" {
shell = "/bin/sh"
}
req := InteractiveStartRequest{
SessionID: sessionID,
Command: []string{shell, "-l"}, // Login shell
WorkingDir: workingDir,
InitialCommand: initialCommand,
}
info, err := r.Start(ctx, req)
if err != nil {
return nil, err
}
// Track the user shell with metadata
// If entry already exists (auto-created by ListUserShells), preserve its metadata
r.userShellsMu.Lock()
if existingEntry != nil {
// Update existing entry with the new process ID
existingEntry.ProcessID = info.ID
r.userShells[key] = existingEntry
} else {
// Create new entry
closable := true // Default: closable
if opts.Closable != nil {
closable = *opts.Closable
}
r.userShells[key] = &userShellEntry{
ProcessID: info.ID,
Label: opts.Label,
InitialCommand: opts.InitialCommand,
Closable: closable,
CreatedAt: time.Now().UTC(),
}
}
r.userShellsMu.Unlock()
r.logger.Info("started user shell",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.String("process_id", info.ID),
zap.String("shell", shell),
zap.String("working_dir", workingDir),
zap.String("label", opts.Label),
zap.String("initial_command", opts.InitialCommand))
return info, nil
}
// UserShellInfo contains information about a running user shell.
type UserShellInfo struct {
TerminalID string `json:"terminal_id"`
ProcessID string `json:"process_id"`
Running bool `json:"running"`
Label string `json:"label"` // Display name (e.g., "Terminal" or "Terminal 2")
Closable bool `json:"closable"` // Whether the terminal can be closed
InitialCommand string `json:"initial_command"` // Command that was run (empty for plain shells)
CreatedAt time.Time `json:"created_at"` // When the shell was created (for stable ordering)
}
// ListUserShells returns all user shells for a session, sorted by creation time.
// If no plain shell terminals exist, automatically creates the first "Terminal" entry.
func (r *InteractiveRunner) ListUserShells(sessionID string) []UserShellInfo {
r.userShellsMu.Lock()
defer r.userShellsMu.Unlock()
prefix := sessionID + ":"
var shells []UserShellInfo
hasPlainShell := false
for key, entry := range r.userShells {
if strings.HasPrefix(key, prefix) {
terminalID := key[len(prefix):]
// Check if process is still alive
_, running := r.Get(entry.ProcessID, false)
shells = append(shells, UserShellInfo{
TerminalID: terminalID,
ProcessID: entry.ProcessID,
Running: running,
Label: entry.Label,
Closable: entry.Closable,
InitialCommand: entry.InitialCommand,
CreatedAt: entry.CreatedAt,
})
// Check if this is a plain shell (not a script terminal)
if entry.InitialCommand == "" {
hasPlainShell = true
}
}
}
// Auto-create the first "Terminal" if no plain shells exist
if !hasPlainShell {
terminalID := "shell-" + uuid.New().String()
now := time.Now().UTC()
entry := &userShellEntry{
ProcessID: "", // No process yet - will be started when WebSocket connects
Label: "Terminal",
InitialCommand: "",
Closable: false, // First terminal is not closable
CreatedAt: now,
}
r.userShells[prefix+terminalID] = entry
shells = append(shells, UserShellInfo{
TerminalID: terminalID,
ProcessID: "",
Running: false,
Label: "Terminal",
Closable: false,
InitialCommand: "",
CreatedAt: now,
})
}
// Sort by creation time for stable ordering
sort.Slice(shells, func(i, j int) bool {
return shells[i].CreatedAt.Before(shells[j].CreatedAt)
})
return shells
}
// StopUserShell stops a user shell for a terminal tab.
func (r *InteractiveRunner) StopUserShell(ctx context.Context, sessionID, terminalID string) error {
key := sessionID + ":" + terminalID
r.userShellsMu.Lock()
entry, exists := r.userShells[key]
if exists {
delete(r.userShells, key)
}
r.userShellsMu.Unlock()
if !exists {
return nil
}
r.logger.Info("stopping user shell",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.String("process_id", entry.ProcessID))
return r.Stop(ctx, entry.ProcessID)
}
// ResizeUserShell resizes the PTY for a user shell.
func (r *InteractiveRunner) ResizeUserShell(sessionID, terminalID string, cols, rows uint16) error {
key := sessionID + ":" + terminalID
r.userShellsMu.RLock()
entry, exists := r.userShells[key]
r.userShellsMu.RUnlock()
if !exists {
return fmt.Errorf("no user shell found for session %s terminal %s", sessionID, terminalID)
}
proc, ok := r.get(entry.ProcessID)
if !ok {
return fmt.Errorf("process not found: %s", entry.ProcessID)
}
// Lazy start: spawn process on first resize when we have exact dimensions
var startErr error
proc.startOnce.Do(func() {
r.logger.Info("first resize received for user shell - starting process",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Uint16("cols", cols),
zap.Uint16("rows", rows))
startErr = r.startProcess(proc, int(cols), int(rows))
})
if startErr != nil {
return fmt.Errorf("failed to start process on first resize: %w", startErr)
}
proc.mu.Lock()
ptyInstance := proc.ptmx
proc.mu.Unlock()
if ptyInstance != nil {
if err := pty.Setsize(ptyInstance, &pty.Winsize{
Cols: cols,
Rows: rows,
}); err != nil {
return fmt.Errorf("failed to resize PTY: %w", err)
}
}
return nil
}
// GetUserShellPtyWriter returns the PTY writer for a user shell.
func (r *InteractiveRunner) GetUserShellPtyWriter(sessionID, terminalID string) (io.Writer, string, error) {
key := sessionID + ":" + terminalID
r.userShellsMu.RLock()
entry, exists := r.userShells[key]
r.userShellsMu.RUnlock()
if !exists {
return nil, "", fmt.Errorf("no user shell found for session %s terminal %s", sessionID, terminalID)
}
writer, err := r.GetPtyWriter(entry.ProcessID)
if err != nil {
return nil, entry.ProcessID, err
}
return writer, entry.ProcessID, nil
}
// ClearUserShellDirectOutput clears the direct output for a user shell.
func (r *InteractiveRunner) ClearUserShellDirectOutput(sessionID, terminalID string) {
key := sessionID + ":" + terminalID
r.userShellsMu.RLock()
entry, exists := r.userShells[key]
r.userShellsMu.RUnlock()
if !exists {
return
}
proc, ok := r.get(entry.ProcessID)
if !ok {
return
}
proc.directOutputMu.Lock()
proc.directOutput = nil
proc.hasActiveWebSocket = false
proc.directOutputMu.Unlock()
r.logger.Info("direct output cleared for user shell",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID))
}
// containsDSRQuery checks if data contains a Device Status Report (cursor position) query.
// DSR query is: ESC [ 6 n or ESC [ ? 6 n
func containsDSRQuery(data []byte) bool {
@@ -687,3 +687,304 @@ func bytesContains(data, substr []byte) bool {
}
return false
}
// --- User Shell Tests ---
func TestInteractiveRunner_CreateUserShell_First(t *testing.T) {
log := newTestLogger(t)
runner := NewInteractiveRunner(nil, log, 2*1024*1024)
result := runner.CreateUserShell("session-1")
if result.TerminalID == "" {
t.Error("CreateUserShell() returned empty TerminalID")
}
if !strings.HasPrefix(result.TerminalID, "shell-") {
t.Errorf("CreateUserShell() TerminalID = %q, want prefix 'shell-'", result.TerminalID)
}
if result.Label != "Terminal" {
t.Errorf("CreateUserShell() Label = %q, want 'Terminal'", result.Label)
}
if result.Closable {
t.Error("CreateUserShell() first terminal should not be closable")
}
}
func TestInteractiveRunner_CreateUserShell_Subsequent(t *testing.T) {
log := newTestLogger(t)
runner := NewInteractiveRunner(nil, log, 2*1024*1024)
first := runner.CreateUserShell("session-1")
second := runner.CreateUserShell("session-1")
if first.TerminalID == second.TerminalID {
t.Error("CreateUserShell() should return different terminal IDs")
}
if second.Label != "Terminal 2" {
t.Errorf("CreateUserShell() second Label = %q, want 'Terminal 2'", second.Label)
}
if !second.Closable {
t.Error("CreateUserShell() second terminal should be closable")
}
third := runner.CreateUserShell("session-1")
if third.Label != "Terminal 3" {
t.Errorf("CreateUserShell() third Label = %q, want 'Terminal 3'", third.Label)
}
if !third.Closable {
t.Error("CreateUserShell() third terminal should be closable")
}
}
func TestInteractiveRunner_CreateUserShell_DifferentSessions(t *testing.T) {
log := newTestLogger(t)
runner := NewInteractiveRunner(nil, log, 2*1024*1024)
r1 := runner.CreateUserShell("session-1")
r2 := runner.CreateUserShell("session-2")
// Both should be "Terminal" (first in each session)
if r1.Label != "Terminal" {
t.Errorf("session-1 Label = %q, want 'Terminal'", r1.Label)
}
if r2.Label != "Terminal" {
t.Errorf("session-2 Label = %q, want 'Terminal'", r2.Label)
}
if r1.Closable || r2.Closable {
t.Error("first terminal in each session should not be closable")
}
}
func TestInteractiveRunner_RegisterScriptShell(t *testing.T) {
log := newTestLogger(t)
runner := NewInteractiveRunner(nil, log, 2*1024*1024)
runner.RegisterScriptShell("session-1", "script-abc", "npm start", "npm run start")
// Should appear in list
shells := runner.ListUserShells("session-1")
// Should have 2: auto-created "Terminal" + registered script
if len(shells) != 2 {
t.Fatalf("ListUserShells() returned %d shells, want 2", len(shells))
}
// Find the script shell
var scriptShell *UserShellInfo
for i := range shells {
if shells[i].TerminalID == "script-abc" {
scriptShell = &shells[i]
break
}
}
if scriptShell == nil {
t.Fatal("script shell not found in list")
}
if scriptShell.Label != "npm start" {
t.Errorf("script shell Label = %q, want 'npm start'", scriptShell.Label)
}
if scriptShell.InitialCommand != "npm run start" {
t.Errorf("script shell InitialCommand = %q, want 'npm run start'", scriptShell.InitialCommand)
}
if !scriptShell.Closable {
t.Error("script shell should be closable")
}
if scriptShell.ProcessID != "" {
t.Errorf("script shell should have empty ProcessID before WebSocket connect, got %q", scriptShell.ProcessID)
}
}
func TestInteractiveRunner_RegisterScriptShell_DoesNotAffectShellCount(t *testing.T) {
log := newTestLogger(t)
runner := NewInteractiveRunner(nil, log, 2*1024*1024)
// Register a script terminal
runner.RegisterScriptShell("session-1", "script-abc", "Build", "npm run build")
// Create a plain shell - should be "Terminal" (first plain shell), not "Terminal 2"
result := runner.CreateUserShell("session-1")
if result.Label != "Terminal" {
t.Errorf("CreateUserShell() Label = %q, want 'Terminal' (scripts should not count)", result.Label)
}
if result.Closable {
t.Error("first plain shell should not be closable regardless of script terminals")
}
}
func TestInteractiveRunner_ListUserShells_AutoCreatesFirst(t *testing.T) {
log := newTestLogger(t)
runner := NewInteractiveRunner(nil, log, 2*1024*1024)
// First call should auto-create "Terminal"
shells := runner.ListUserShells("session-1")
if len(shells) != 1 {
t.Fatalf("ListUserShells() returned %d shells, want 1", len(shells))
}
if shells[0].Label != "Terminal" {
t.Errorf("auto-created shell Label = %q, want 'Terminal'", shells[0].Label)
}
if shells[0].Closable {
t.Error("auto-created first shell should not be closable")
}
if shells[0].Running {
t.Error("auto-created shell should not be running (no process)")
}
if !strings.HasPrefix(shells[0].TerminalID, "shell-") {
t.Errorf("auto-created shell TerminalID = %q, want prefix 'shell-'", shells[0].TerminalID)
}
}
func TestInteractiveRunner_ListUserShells_StableAfterAutoCreate(t *testing.T) {
log := newTestLogger(t)
runner := NewInteractiveRunner(nil, log, 2*1024*1024)
// First call auto-creates
shells1 := runner.ListUserShells("session-1")
// Second call should return the same list (not create another)
shells2 := runner.ListUserShells("session-1")
if len(shells1) != 1 || len(shells2) != 1 {
t.Fatalf("ListUserShells() should return 1 shell each time, got %d and %d", len(shells1), len(shells2))
}
if shells1[0].TerminalID != shells2[0].TerminalID {
t.Error("ListUserShells() should return the same terminal ID across calls")
}
}
func TestInteractiveRunner_ListUserShells_Sorted(t *testing.T) {
log := newTestLogger(t)
runner := NewInteractiveRunner(nil, log, 2*1024*1024)
// Create shells with a small time gap
runner.CreateUserShell("session-1")
time.Sleep(10 * time.Millisecond)
runner.CreateUserShell("session-1")
time.Sleep(10 * time.Millisecond)
runner.RegisterScriptShell("session-1", "script-1", "Build", "make build")
shells := runner.ListUserShells("session-1")
if len(shells) != 3 {
t.Fatalf("ListUserShells() returned %d shells, want 3", len(shells))
}
// Should be sorted by creation time
for i := 1; i < len(shells); i++ {
if shells[i].CreatedAt.Before(shells[i-1].CreatedAt) {
t.Errorf("shells not sorted by creation time: shell[%d] (%v) before shell[%d] (%v)",
i, shells[i].CreatedAt, i-1, shells[i-1].CreatedAt)
}
}
}
func TestInteractiveRunner_ListUserShells_IsolatedBySessions(t *testing.T) {
log := newTestLogger(t)
runner := NewInteractiveRunner(nil, log, 2*1024*1024)
runner.CreateUserShell("session-1")
runner.CreateUserShell("session-1")
runner.CreateUserShell("session-2")
shells1 := runner.ListUserShells("session-1")
shells2 := runner.ListUserShells("session-2")
if len(shells1) != 2 {
t.Errorf("session-1 should have 2 shells, got %d", len(shells1))
}
if len(shells2) != 1 {
t.Errorf("session-2 should have 1 shell, got %d", len(shells2))
}
}
func TestInteractiveRunner_StopUserShell(t *testing.T) {
log := newTestLogger(t)
runner := NewInteractiveRunner(nil, log, 2*1024*1024)
// Create a shell
result := runner.CreateUserShell("session-1")
// Verify it's in the list
shells := runner.ListUserShells("session-1")
found := false
for _, s := range shells {
if s.TerminalID == result.TerminalID {
found = true
break
}
}
if !found {
t.Fatal("created shell not found in list")
}
// Stop the shell (no process running, so this should remove the entry)
ctx := context.Background()
err := runner.StopUserShell(ctx, "session-1", result.TerminalID)
// Error is expected since there's no process to stop
_ = err
// Shell should be removed from tracking
shells = runner.ListUserShells("session-1")
for _, s := range shells {
if s.TerminalID == result.TerminalID {
t.Error("stopped shell should be removed from list")
}
}
}
func TestInteractiveRunner_StopUserShell_NonExistent(t *testing.T) {
log := newTestLogger(t)
runner := NewInteractiveRunner(nil, log, 2*1024*1024)
// Stopping a non-existent shell should not error
ctx := context.Background()
err := runner.StopUserShell(ctx, "session-1", "nonexistent")
if err != nil {
t.Errorf("StopUserShell() for non-existent shell should return nil, got %v", err)
}
}
func TestInteractiveRunner_StopUserShell_ScriptTerminal(t *testing.T) {
log := newTestLogger(t)
runner := NewInteractiveRunner(nil, log, 2*1024*1024)
// Register and then stop a script terminal
runner.RegisterScriptShell("session-1", "script-abc", "Build", "npm run build")
ctx := context.Background()
err := runner.StopUserShell(ctx, "session-1", "script-abc")
_ = err // Error expected since no process
// Script should be removed from list (auto-created "Terminal" may still appear)
shells := runner.ListUserShells("session-1")
for _, s := range shells {
if s.TerminalID == "script-abc" {
t.Error("stopped script terminal should be removed from list")
}
}
}
func TestInteractiveRunner_CreateUserShell_AtomicRegistration(t *testing.T) {
log := newTestLogger(t)
runner := NewInteractiveRunner(nil, log, 2*1024*1024)
// Create a shell - it should be immediately visible in ListUserShells
result := runner.CreateUserShell("session-1")
shells := runner.ListUserShells("session-1")
found := false
for _, s := range shells {
if s.TerminalID == result.TerminalID {
found = true
if s.Label != result.Label {
t.Errorf("shell Label mismatch: list=%q, create=%q", s.Label, result.Label)
}
if s.Closable != result.Closable {
t.Errorf("shell Closable mismatch: list=%v, create=%v", s.Closable, result.Closable)
}
break
}
}
if !found {
t.Error("CreateUserShell() result should be immediately visible in ListUserShells()")
}
}
@@ -0,0 +1,16 @@
// Package scripts provides shared types for repository script lookups.
package scripts
import "context"
// RepositoryScript holds the minimal fields needed when looking up a script by ID.
type RepositoryScript struct {
ID string
Name string
Command string
}
// ScriptService provides access to repository scripts.
type ScriptService interface {
GetRepositoryScript(ctx context.Context, id string) (*RepositoryScript, error)
}
@@ -5,6 +5,7 @@ import (
"github.com/kandev/kandev/internal/agent/lifecycle"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/common/scripts"
ws "github.com/kandev/kandev/pkg/websocket"
)
@@ -36,8 +37,8 @@ func NewGateway(log *logger.Logger) *Gateway {
// SetLifecycleManager enables the dedicated terminal WebSocket handler for passthrough mode.
// This must be called before SetupRoutes if terminal passthrough is needed.
func (g *Gateway) SetLifecycleManager(lifecycleMgr *lifecycle.Manager) {
g.TerminalHandler = NewTerminalHandler(lifecycleMgr, g.logger)
func (g *Gateway) SetLifecycleManager(lifecycleMgr *lifecycle.Manager, userService UserService, scriptService scripts.ScriptService) {
g.TerminalHandler = NewTerminalHandler(lifecycleMgr, userService, scriptService, g.logger)
}
// SetupRoutes adds the WebSocket routes to the Gin engine
@@ -3,6 +3,7 @@ package websocket
import (
"bytes"
"context"
"encoding/json"
"io"
"net/http"
@@ -18,20 +19,30 @@ import (
"github.com/kandev/kandev/internal/agent/lifecycle"
"github.com/kandev/kandev/internal/agentctl/server/process"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/common/scripts"
)
// UserService interface for getting user preferences.
type UserService interface {
PreferredShell(ctx context.Context) (string, error)
}
// TerminalHandler handles dedicated binary WebSocket connections for terminal I/O.
// This bypasses JSON encoding for raw PTY communication via xterm.js AttachAddon.
type TerminalHandler struct {
lifecycleMgr *lifecycle.Manager
logger *logger.Logger
lifecycleMgr *lifecycle.Manager
userService UserService
scriptService scripts.ScriptService
logger *logger.Logger
}
// NewTerminalHandler creates a new TerminalHandler instance.
func NewTerminalHandler(lifecycleMgr *lifecycle.Manager, log *logger.Logger) *TerminalHandler {
func NewTerminalHandler(lifecycleMgr *lifecycle.Manager, userService UserService, scriptService scripts.ScriptService, log *logger.Logger) *TerminalHandler {
return &TerminalHandler{
lifecycleMgr: lifecycleMgr,
logger: log.WithFields(zap.String("component", "terminal_handler")),
lifecycleMgr: lifecycleMgr,
userService: userService,
scriptService: scriptService,
logger: log.WithFields(zap.String("component", "terminal_handler")),
}
}
@@ -130,6 +141,9 @@ func (w *wsWriter) Close() error {
// HandleTerminalWS handles WebSocket connections at /xterm.js/:sessionId
// This creates a binary WebSocket bridge between xterm.js and the PTY.
// Query parameter terminalId determines the type of terminal:
// - "default" or empty: Agent passthrough terminal (CLI passthrough mode)
// - "shell-1", "shell-2", etc.: Independent user shell terminals
func (h *TerminalHandler) HandleTerminalWS(c *gin.Context) {
sessionID := c.Param("sessionId")
if sessionID == "" {
@@ -137,8 +151,23 @@ func (h *TerminalHandler) HandleTerminalWS(c *gin.Context) {
return
}
terminalID := c.Query("terminalId")
// terminalId is required - "default" is for agent passthrough, anything else is for user shells
// Empty terminalId is rejected to prevent accidental fallback behavior
if terminalID == "" {
h.logger.Warn("terminal WebSocket connection rejected: terminalId query parameter is required (use 'default' for agent passthrough or a unique ID for user shells)",
zap.String("session_id", sessionID),
zap.String("raw_query", c.Request.URL.RawQuery),
zap.String("remote_addr", c.Request.RemoteAddr))
c.JSON(http.StatusBadRequest, gin.H{"error": "terminalId query parameter is required"})
return
}
h.logger.Info("terminal WebSocket connection request",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Bool("is_agent_passthrough", terminalID == "default"),
zap.String("raw_query", c.Request.URL.RawQuery),
zap.String("remote_addr", c.Request.RemoteAddr))
// Get the interactive runner first
@@ -149,6 +178,14 @@ func (h *TerminalHandler) HandleTerminalWS(c *gin.Context) {
return
}
// Route based on terminal ID
if terminalID != "default" {
// User shell terminal - create independent shell process
h.handleUserShellWS(c, sessionID, terminalID, interactiveRunner)
return
}
// Agent passthrough terminal - existing logic
// Ensure passthrough execution exists and is running.
// This handles:
// 1. Normal case: execution exists with running process
@@ -499,3 +536,327 @@ func (h *TerminalHandler) handleResize(
return resize.Cols, resize.Rows
}
// handleUserShellWS handles WebSocket connections for user shell terminals.
// Each terminal tab gets its own independent shell process.
func (h *TerminalHandler) handleUserShellWS(
c *gin.Context,
sessionID string,
terminalID string,
interactiveRunner *process.InteractiveRunner,
) {
// Get optional parameters from query
scriptID := c.Query("scriptId") // Repository script ID to run
labelParam := c.Query("label") // Label for plain shell terminals
var label string
var initialCommand string
// If scriptId is provided, look up the script from the database
if scriptID != "" && h.scriptService != nil {
script, err := h.scriptService.GetRepositoryScript(c.Request.Context(), scriptID)
if err != nil {
h.logger.Error("failed to get repository script",
zap.String("script_id", scriptID),
zap.Error(err))
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid script ID"})
return
}
label = script.Name
initialCommand = script.Command
h.logger.Info("handleUserShellWS: resolved script",
zap.String("script_id", scriptID),
zap.String("script_name", script.Name),
zap.String("script_command", script.Command))
} else if labelParam != "" {
// Use label from query param for plain shell terminals
label = labelParam
}
h.logger.Info("handleUserShellWS: starting user shell handling",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.String("script_id", scriptID),
zap.String("label", label),
zap.String("initial_command", initialCommand))
// Get preferred shell from user settings
var preferredShell string
if h.userService != nil {
shell, err := h.userService.PreferredShell(c.Request.Context())
if err != nil {
h.logger.Debug("failed to get preferred shell, using default",
zap.Error(err))
} else {
preferredShell = shell
}
}
// Get working directory from execution (workspace path)
workingDir := ""
if execution, exists := h.lifecycleMgr.GetExecutionBySessionID(sessionID); exists {
workingDir = execution.WorkspacePath
h.logger.Info("handleUserShellWS: got working directory from execution",
zap.String("working_dir", workingDir))
} else {
h.logger.Info("handleUserShellWS: no execution found, using empty working directory")
}
// Build shell options
opts := &process.UserShellOptions{
Label: label,
InitialCommand: initialCommand,
}
// Start or get existing user shell for this terminal
h.logger.Info("handleUserShellWS: calling StartUserShell",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.String("working_dir", workingDir),
zap.String("preferred_shell", preferredShell),
zap.String("label", opts.Label),
zap.String("initial_command", opts.InitialCommand))
info, err := interactiveRunner.StartUserShell(
c.Request.Context(),
sessionID,
terminalID,
workingDir,
preferredShell,
opts,
)
if err != nil {
h.logger.Error("failed to start user shell",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Error(err))
c.JSON(http.StatusServiceUnavailable, gin.H{"error": err.Error()})
return
}
processID := info.ID
h.logger.Info("handleUserShellWS: user shell started successfully",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.String("process_id", processID))
// Upgrade to WebSocket
conn, err := terminalUpgrader.Upgrade(c.Writer, c.Request, nil)
if err != nil {
h.logger.Error("failed to upgrade to WebSocket",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Error(err))
return
}
h.logger.Info("user shell WebSocket connected",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.String("process_id", processID))
// Create WebSocket writer for output
wsw := newWsWriter(conn)
// Run the user shell terminal bridge
h.runUserShellBridge(conn, sessionID, terminalID, processID, interactiveRunner, wsw)
}
// runUserShellBridge handles WebSocket I/O for user shell terminals.
func (h *TerminalHandler) runUserShellBridge(
conn *gorillaws.Conn,
sessionID string,
terminalID string,
processID string,
interactiveRunner *process.InteractiveRunner,
wsw *wsWriter,
) {
var ptyWriter io.Writer
var directOutputSet bool
defer func() {
// Clean up WebSocket resources but DON'T stop the process
// The process should only be stopped via explicit user_shell.stop message from frontend
// This allows reconnection after React remounts or temporary disconnects
interactiveRunner.ClearUserShellDirectOutput(sessionID, terminalID)
_ = wsw.Close()
_ = conn.Close()
h.logger.Info("user shell WebSocket disconnected (process still running for potential reconnect)",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID))
}()
// Read from WebSocket and handle input/resize
for {
messageType, data, err := conn.ReadMessage()
if err != nil {
if !gorillaws.IsCloseError(err, gorillaws.CloseNormalClosure, gorillaws.CloseGoingAway) {
h.logger.Debug("WebSocket read error",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Error(err))
}
return
}
if messageType != gorillaws.BinaryMessage && messageType != gorillaws.TextMessage {
continue
}
if len(data) == 0 {
continue
}
// Check for resize command (first byte 0x01)
if data[0] == resizeCommandByte {
// Set up PTY access BEFORE handling resize if not already done
if !directOutputSet {
if h.setupUserShellPtyAccess(sessionID, terminalID, processID, interactiveRunner, wsw, &ptyWriter) {
directOutputSet = true
}
}
// Handle resize for user shell
h.handleUserShellResize(data[1:], sessionID, terminalID, interactiveRunner)
continue
}
// Regular input - write to PTY if available
if ptyWriter != nil {
if _, err := ptyWriter.Write(data); err != nil {
h.logger.Debug("PTY write error",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Error(err))
// Try to re-establish PTY access
if h.setupUserShellPtyAccess(sessionID, terminalID, processID, interactiveRunner, wsw, &ptyWriter) {
directOutputSet = true
// Retry write
if _, err := ptyWriter.Write(data); err != nil {
h.logger.Debug("PTY write error after reconnect",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Error(err))
}
}
}
} else {
// PTY not ready yet - try to set it up
if h.setupUserShellPtyAccess(sessionID, terminalID, processID, interactiveRunner, wsw, &ptyWriter) {
directOutputSet = true
// Retry writing after setup
if _, err := ptyWriter.Write(data); err != nil {
h.logger.Debug("PTY write error after setup",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Error(err))
}
} else {
h.logger.Debug("PTY not ready, dropping input",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Int("bytes", len(data)))
}
}
}
}
// setupUserShellPtyAccess sets up PTY access for a user shell terminal.
func (h *TerminalHandler) setupUserShellPtyAccess(
sessionID string,
terminalID string,
processID string,
interactiveRunner *process.InteractiveRunner,
wsw *wsWriter,
ptyWriter *io.Writer,
) bool {
// Get PTY writer for the user shell
writer, _, err := interactiveRunner.GetUserShellPtyWriter(sessionID, terminalID)
if err != nil {
h.logger.Debug("user shell PTY writer not ready",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID))
return false
}
// Send buffered output
if chunks, ok := interactiveRunner.GetBuffer(processID); ok && len(chunks) > 0 {
var combined bytes.Buffer
for _, chunk := range chunks {
combined.WriteString(chunk.Data)
}
if combined.Len() > 0 {
if _, writeErr := wsw.Write(combined.Bytes()); writeErr != nil {
h.logger.Warn("failed to send buffered output",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Error(writeErr))
}
}
}
// Set up direct output
if err := interactiveRunner.SetDirectOutput(processID, wsw); err != nil {
h.logger.Error("failed to set direct output for user shell",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Error(err))
return false
}
*ptyWriter = writer
h.logger.Info("user shell PTY access established",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.String("process_id", processID))
return true
}
// handleUserShellResize processes resize commands for user shell terminals.
func (h *TerminalHandler) handleUserShellResize(
data []byte,
sessionID string,
terminalID string,
interactiveRunner *process.InteractiveRunner,
) {
var resize ResizePayload
if err := json.Unmarshal(data, &resize); err != nil {
h.logger.Warn("failed to parse resize command",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Error(err))
return
}
if resize.Cols == 0 || resize.Rows == 0 {
h.logger.Warn("invalid resize dimensions",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Uint16("cols", resize.Cols),
zap.Uint16("rows", resize.Rows))
return
}
// Resize the user shell PTY
if err := interactiveRunner.ResizeUserShell(sessionID, terminalID, resize.Cols, resize.Rows); err != nil {
h.logger.Warn("failed to resize user shell PTY",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Uint16("cols", resize.Cols),
zap.Uint16("rows", resize.Rows),
zap.Error(err))
} else {
h.logger.Debug("user shell PTY resized",
zap.String("session_id", sessionID),
zap.String("terminal_id", terminalID),
zap.Uint16("cols", resize.Cols),
zap.Uint16("rows", resize.Rows))
}
// Give the process a moment to start if this was the first resize
time.Sleep(50 * time.Millisecond)
}
+5
View File
@@ -180,6 +180,11 @@ const (
ActionShellInput = "shell.input" // Send input to shell
ActionSessionShellOutput = "session.shell.output" // Shell output notification (also used for exit with type: "exit")
// User shell actions (independent terminal tabs)
ActionUserShellList = "user_shell.list" // List running user shells for a session
ActionUserShellCreate = "user_shell.create" // Create a new user shell terminal (assigns ID and label)
ActionUserShellStop = "user_shell.stop" // Stop a user shell terminal
// Session git actions (requests)
ActionSessionGitSnapshots = "session.git.snapshots" // Get git snapshots for a session
ActionSessionGitCommits = "session.git.commits" // Get commits for a session
+14 -1
View File
@@ -14,7 +14,9 @@ import {
listWorkspaces,
} from '@/lib/api';
import { listSessionTurns } from '@/lib/api/domains/session-api';
import { fetchTerminals } from '@/lib/api/domains/user-shell-api';
import type { ListMessagesResponse, Task } from '@/lib/types/http';
import type { Terminal } from '@/hooks/domains/session/use-terminals';
import { snapshotToState, taskToState } from '@/lib/ssr/mapper';
import { TaskPageContent } from '@/components/task/task-page-content';
@@ -26,6 +28,7 @@ export default async function SessionPage({
let initialState: ReturnType<typeof taskToState> | null = null;
let task: Task | null = null;
let sessionId: string | null = null;
let initialTerminals: Terminal[] = [];
const defaultLayouts = await readLayoutDefaults();
try {
@@ -39,7 +42,7 @@ export default async function SessionPage({
}
task = await fetchTask(session.task_id, { cache: 'no-store' });
const [snapshot, agents, repositoriesResponse, allSessionsResponse, availableAgentsResponse, workspacesResponse, boardsResponse, turnsResponse, userSettingsResponse] = await Promise.all([
const [snapshot, agents, repositoriesResponse, allSessionsResponse, availableAgentsResponse, workspacesResponse, boardsResponse, turnsResponse, userSettingsResponse, terminalsResponse] = await Promise.all([
fetchBoardSnapshot(task.board_id, { cache: 'no-store' }),
listAgents({ cache: 'no-store' }),
listRepositories(task.workspace_id, { includeScripts: true }, { cache: 'no-store' }),
@@ -49,6 +52,7 @@ export default async function SessionPage({
listBoards(task.workspace_id, { cache: 'no-store' }).catch(() => ({ boards: [] })),
listSessionTurns(sessionId, { cache: 'no-store' }).catch(() => ({ turns: [], total: 0 })),
fetchUserSettings({ cache: 'no-store' }).catch(() => null),
fetchTerminals(sessionId).catch(() => []),
]);
const repositories = repositoriesResponse.repositories ?? [];
const allSessions = allSessionsResponse.sessions ?? [session];
@@ -58,6 +62,14 @@ export default async function SessionPage({
const turns = turnsResponse.turns ?? [];
const userSettings = userSettingsResponse?.settings;
// Transform terminals to frontend format
initialTerminals = terminalsResponse.map((t) => ({
id: t.terminal_id,
type: t.initial_command ? 'script' as const : 'shell' as const,
label: t.label,
closable: t.closable,
}));
// Get repository scripts from the repository (already fetched with includeScripts)
const repositoryId = task.repositories?.[0]?.repository_id;
const repository = repositories.find(r => r.id === repositoryId);
@@ -236,6 +248,7 @@ export default async function SessionPage({
sessionId={sessionId}
initialRepositories={initialState?.repositories?.itemsByWorkspaceId?.[task?.workspace_id ?? ''] ?? []}
initialScripts={initialState?.repositoryScripts?.itemsByRepositoryId?.[task?.repositories?.[0]?.repository_id ?? ''] ?? []}
initialTerminals={initialTerminals}
defaultLayouts={defaultLayouts}
/>
</>
@@ -33,6 +33,7 @@ import {
import type { LocalRepository, Repository, RepositoryScript, Workspace } from '@/lib/types/http';
import { useRequest } from '@/lib/http/use-request';
import { useToast } from '@/components/toast-provider';
import { useAppStore } from '@/components/state-provider';
type RepositoryWithScripts = Repository & { scripts: RepositoryScript[] };
type RepositoryItem = RepositoryWithScripts & { __autoOpen?: boolean };
@@ -48,6 +49,7 @@ export function WorkspaceRepositoriesClient({
}: WorkspaceRepositoriesClientProps) {
const router = useRouter();
const { toast } = useToast();
const clearRepositoryScripts = useAppStore((state) => state.clearRepositoryScripts);
const [repositoryItems, setRepositoryItems] = useState<RepositoryItem[]>(repositories);
const [savedRepositoryItems, setSavedRepositoryItems] = useState<RepositoryWithScripts[]>(repositories);
const [discoveredRepositories, setDiscoveredRepositories] = useState<LocalRepository[]>([]);
@@ -346,6 +348,9 @@ export function WorkspaceRepositoriesClient({
? prev.map((item) => (item.id === repoId ? cloneRepository(nextRepo) : item))
: [...prev, cloneRepository(nextRepo)]
);
// Clear the scripts cache so task pages will refetch the updated scripts
clearRepositoryScripts(repoId);
};
const handleDeleteRepository = async (repoId: string) => {
+15 -11
View File
@@ -48,7 +48,7 @@ export function SessionTabs({
rightContent,
}: SessionTabsProps) {
const tabsList = (
<TabsList className="p-0 !h-6 rounded-sm">
<TabsList className="p-0 !h-7 rounded-sm overflow-x-auto overflow-y-hidden min-w-0 shrink [&::-webkit-scrollbar]:hidden [-ms-overflow-style:none] [scrollbar-width:none]">
{tabs.map((tab, index) => (
<Fragment key={tab.id}>
{separatorAfterIndex !== undefined && index === separatorAfterIndex + 1 && (
@@ -56,19 +56,19 @@ export function SessionTabs({
)}
<TabsTrigger
value={tab.id}
className={tab.className + ' py-1 cursor-pointer rounded-sm'}
className={tab.className + ' group relative py-1 cursor-pointer rounded-sm max-w-[120px]'}
>
{tab.icon}
<span className={tab.icon ? 'ml-1.5' : undefined}>{tab.label}</span>
<span className={`truncate ${tab.icon ? 'ml-1.5' : ''}`} style={{ textOverflow: 'clip' }}>{tab.label}</span>
{tab.closable && tab.onClose && (
<span
role="button"
tabIndex={-1}
className={`ml-0.5 transition-opacity hover:text-foreground text-muted-foreground ${tab.alwaysShowClose ? 'opacity-100' : 'opacity-0 group-hover:opacity-100'}`}
className={`absolute right-1 rounded bg-background hover:bg-muted hover:text-foreground text-muted-foreground transition-opacity ${tab.alwaysShowClose ? 'opacity-100' : 'opacity-0 group-hover:opacity-100'}`}
onClick={tab.onClose}
>
<svg
className="h-3.5 w-3.5"
className="h-3 w-3"
xmlns="http://www.w3.org/2000/svg"
viewBox="0 0 24 24"
fill="none"
@@ -86,9 +86,13 @@ export function SessionTabs({
</Fragment>
))}
{showAddButton && onAddTab && (
<TabsTrigger value="add" onClick={onAddTab} className="cursor-pointer">
<button
type="button"
onClick={onAddTab}
className="inline-flex items-center justify-center whitespace-nowrap rounded-sm px-2 py-1 h-6 text-sm ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 cursor-pointer hover:bg-muted"
>
{addButtonLabel}
</TabsTrigger>
</button>
)}
</TabsList>
);
@@ -132,17 +136,17 @@ export function SessionTabs({
return (
<Tabs value={activeTab} onValueChange={onTabChange} className={className}>
{collapsible ? (
<div className={`flex items-center justify-between ${children ? '' : 'p-2'}`}>
<div className={`flex items-center justify-between gap-2 ${children ? '' : 'p-2'}`}>
{tabsList}
<div className="flex items-center gap-2">
<div className="flex items-center gap-2 shrink-0">
{rightContent}
{collapseButton}
</div>
</div>
) : rightContent ? (
<div className="flex items-center justify-between">
<div className="flex items-center justify-between gap-2">
{tabsList}
{rightContent}
<div className="shrink-0">{rightContent}</div>
</div>
) : (
tabsList
@@ -101,7 +101,7 @@ export const SessionMobileLayout = memo(function SessionMobileLayout({
{activeTaskId ? (
isPassthroughMode ? (
<div className="flex-1 min-h-0">
<PassthroughTerminal key={effectiveSessionId} sessionId={sessionId} />
<PassthroughTerminal key={effectiveSessionId} sessionId={sessionId} terminalId="default" />
</div>
) : (
<TaskChatPanel
@@ -135,7 +135,7 @@ export const SessionTabletLayout = memo(function SessionTabletLayout({
{/* Right Panel: Files + Terminal stacked */}
<Panel id="right" minSize="250px" className="min-h-0 min-w-0">
<TaskRightPanel topPanel={topFilesPanel} sessionId={sessionForPreview} />
<TaskRightPanel topPanel={topFilesPanel} sessionId={sessionForPreview} repositoryId={repository?.id ?? null} />
</Panel>
</Group>
@@ -15,6 +15,8 @@ import { terminalTheme, applyTransparentBackground } from '@/lib/terminal-theme'
type PassthroughTerminalProps = {
sessionId?: string | null;
terminalId?: string; // Terminal tab identifier (e.g., "shell-1", "shell-2")
label?: string; // Label for plain shell terminals (sent to backend for persistence)
};
// Debug flag - set to true to see detailed logs
@@ -37,7 +39,10 @@ const MIN_HEIGHT = 100;
* - Unicode11Addon enables proper unicode character support
* - Resize commands sent via binary protocol: [0x01][JSON {cols, rows}]
*/
export function PassthroughTerminal({ sessionId: propSessionId }: PassthroughTerminalProps) {
export function PassthroughTerminal({ sessionId: propSessionId, terminalId, label }: PassthroughTerminalProps) {
// Debug: log props on every render
log('Render - props:', { propSessionId, terminalId, label });
const terminalRef = useRef<HTMLDivElement>(null);
const xtermRef = useRef<Terminal | null>(null);
const fitAddonRef = useRef<FitAddon | null>(null);
@@ -312,9 +317,10 @@ export function PassthroughTerminal({ sessionId: propSessionId }: PassthroughTer
// Connect WebSocket when ready
useEffect(() => {
log('WebSocket effect:', { taskId, sessionId, canConnect, hasTerminal: !!xtermRef.current });
log('WebSocket effect:', { taskId, sessionId, terminalId, canConnect, hasTerminal: !!xtermRef.current });
if (!taskId || !sessionId || !canConnect) {
log('WebSocket effect: early return - missing requirements', { taskId, sessionId, canConnect });
return;
}
if (!xtermRef.current || !fitAddonRef.current) {
@@ -341,8 +347,18 @@ export function PassthroughTerminal({ sessionId: propSessionId }: PassthroughTer
wsRef.current = null;
}
const wsUrl = `${wsBaseUrl}/xterm.js/${sessionId}`;
log('Connecting to', wsUrl);
// Build WebSocket URL - terminalId is required for user shells
// If terminalId is not provided, this is an error for user shell terminals
if (!terminalId) {
log('ERROR: terminalId is required but was not provided!', { sessionId, terminalId });
return;
}
let wsUrl = `${wsBaseUrl}/xterm.js/${sessionId}?terminalId=${encodeURIComponent(terminalId)}`;
if (label) {
// For plain shell terminals, send the label for persistence
wsUrl += `&label=${encodeURIComponent(label)}`;
}
log('Connecting to', wsUrl, { terminalId, label });
const ws = new WebSocket(wsUrl);
ws.binaryType = 'arraybuffer';
@@ -415,7 +431,7 @@ export function PassthroughTerminal({ sessionId: propSessionId }: PassthroughTer
wsRef.current = null;
}
};
}, [taskId, sessionId, canConnect, fitAndResize, wsBaseUrl]);
}, [taskId, sessionId, canConnect, fitAndResize, wsBaseUrl, terminalId, label]);
return (
<div
@@ -614,7 +614,7 @@ export const TaskCenterPanel = memo(function TaskCenterPanel({
{activeTaskId ? (
isPassthroughMode ? (
<div className="flex-1 min-h-0 h-full" style={{ minHeight: '150px' }}>
<PassthroughTerminal key={activeSessionId} sessionId={sessionId} />
<PassthroughTerminal key={activeSessionId} sessionId={sessionId} terminalId="default" />
</div>
) : (
<TaskChatPanel
+4 -1
View File
@@ -14,6 +14,7 @@ import { PreviewPanel } from '@/components/task/preview/preview-panel';
import { PreviewController } from '@/components/task/preview/preview-controller';
import { useLayoutStore } from '@/lib/state/layout-store';
import type { Repository, RepositoryScript } from '@/lib/types/http';
import type { Terminal } from '@/hooks/domains/session/use-terminals';
// Re-export for backwards compatibility
export type { SelectedDiff } from '@/hooks/use-session-layout-state';
@@ -36,6 +37,7 @@ type TaskLayoutProps = {
sessionId?: string | null;
repository?: Repository | null;
initialScripts?: RepositoryScript[];
initialTerminals?: Terminal[];
defaultLayouts?: Record<string, Layout>;
taskTitle?: string;
baseBranch?: string;
@@ -48,6 +50,7 @@ export const TaskLayout = memo(function TaskLayout({
sessionId = null,
repository = null,
initialScripts = [],
initialTerminals,
defaultLayouts = {},
taskTitle,
baseBranch,
@@ -204,7 +207,7 @@ export const TaskLayout = memo(function TaskLayout({
{layoutState.right ? (
<>
<Panel id="right" minSize="310px" className="min-h-0 min-w-0">
<TaskRightPanel topPanel={topFilesPanel} sessionId={sessionForPreview} repositoryId={repository?.id ?? null} initialScripts={initialScripts} />
<TaskRightPanel topPanel={topFilesPanel} sessionId={sessionForPreview} repositoryId={repository?.id ?? null} initialScripts={initialScripts} initialTerminals={initialTerminals} />
</Panel>
</>
) : null}
@@ -5,6 +5,7 @@ import { TaskTopBar } from '@/components/task/task-top-bar';
import { TaskLayout } from '@/components/task/task-layout';
import { DebugOverlay } from '@/components/debug-overlay';
import type { Repository, RepositoryScript, Task } from '@/lib/types/http';
import type { Terminal } from '@/hooks/domains/session/use-terminals';
import type { KanbanState } from '@/lib/state/slices';
import { DEBUG_UI } from '@/lib/config';
import { TooltipProvider } from '@kandev/ui/tooltip';
@@ -23,6 +24,7 @@ type TaskPageContentProps = {
sessionId?: string | null;
initialRepositories?: Repository[];
initialScripts?: RepositoryScript[];
initialTerminals?: Terminal[];
defaultLayouts?: Record<string, Layout>;
};
@@ -37,6 +39,7 @@ export function TaskPageContent({
sessionId = null,
initialRepositories = [],
initialScripts = [],
initialTerminals,
defaultLayouts = {},
}: TaskPageContentProps) {
const [taskDetails, setTaskDetails] = useState<Task | null>(initialTask);
@@ -260,6 +263,7 @@ export function TaskPageContent({
sessionId={effectiveSessionId ?? null}
repository={repository ?? null}
initialScripts={initialScripts}
initialTerminals={initialTerminals}
defaultLayouts={defaultLayouts}
taskTitle={task?.title}
baseBranch={task?.repositories?.[0]?.base_branch}
+50 -455
View File
@@ -1,41 +1,34 @@
'use client';
import type { ReactNode, MouseEvent } from 'react';
import { memo, useEffect, useState, useCallback, useMemo, useRef } from 'react';
import { memo, useEffect, useCallback, useState, useMemo } from 'react';
import { Badge } from '@kandev/ui/badge';
import { SessionPanel, SessionPanelContent } from '@kandev/ui/pannel-session';
import { Group, Panel } from 'react-resizable-panels';
import { TabsContent } from '@kandev/ui/tabs';
import { getLocalStorage, setLocalStorage, getSessionStorage, setSessionStorage } from '@/lib/local-storage';
import { ShellTerminal } from '@/components/task/shell-terminal';
import { useAppStore, useAppStoreApi } from '@/components/state-provider';
import { PassthroughTerminal } from '@/components/task/passthrough-terminal';
import { useAppStore } from '@/components/state-provider';
import { useLayoutStore } from '@/lib/state/layout-store';
import { stopProcess, startProcess, getSessionProcess } from '@/lib/api';
import { useDefaultLayout } from '@/lib/layout/use-default-layout';
import { SessionTabs, type SessionTab } from '@/components/session-tabs';
import { useRepositoryScripts } from '@/hooks/domains/workspace/use-repository-scripts';
import { useTerminals } from '@/hooks/domains/session/use-terminals';
import type { RepositoryScript } from '@/lib/types/http';
type TerminalType = 'commands' | 'dev-server' | 'shell' | 'custom';
type Terminal = {
id: string;
type: TerminalType;
label: string;
processId?: string;
};
import type { Terminal } from '@/hooks/domains/session/use-terminals';
type TaskRightPanelProps = {
topPanel: ReactNode;
sessionId?: string | null;
repositoryId?: string | null;
initialScripts?: RepositoryScript[];
initialTerminals?: Terminal[];
};
const DEFAULT_RIGHT_LAYOUT: Record<string, number> = { top: 55, bottom: 45 };
const TaskRightPanel = memo(function TaskRightPanel({ topPanel, sessionId = null, repositoryId = null, initialScripts = [] }: TaskRightPanelProps) {
const storeApi = useAppStoreApi();
const TaskRightPanel = memo(function TaskRightPanel({ topPanel, sessionId = null, repositoryId = null, initialScripts = [], initialTerminals }: TaskRightPanelProps) {
const rightPanelIds = ['top', 'bottom'];
const rightLayoutKey = 'task-layout-right-v2';
const { defaultLayout: rightLayout, onLayoutChanged: onRightLayoutChange } = useDefaultLayout({
@@ -43,435 +36,61 @@ const TaskRightPanel = memo(function TaskRightPanel({ topPanel, sessionId = null
panelIds: rightPanelIds,
baseLayout: DEFAULT_RIGHT_LAYOUT,
});
// Initialize terminals from sessionStorage for persistence across remounts (within browser tab)
const [terminals, setTerminals] = useState<Terminal[]>(() => {
const baseTerminals: Terminal[] = [{ id: 'shell-1', type: 'shell', label: 'Terminal' }];
if (!sessionId) return baseTerminals;
const savedCustomTerminals = getSessionStorage<Terminal[]>(`customTerminals-${sessionId}`, []);
if (savedCustomTerminals.length > 0) {
return [...baseTerminals, ...savedCustomTerminals];
}
return baseTerminals;
});
const [isBottomCollapsed, setIsBottomCollapsed] = useState<boolean>(() =>
getLocalStorage('task-right-panel-collapsed', false)
);
const [isStoppingDev, setIsStoppingDev] = useState(false);
const activeTab = useAppStore((state) =>
sessionId ? state.rightPanel.activeTabBySessionId[sessionId] : undefined
);
const setRightPanelActiveTab = useAppStore((state) => state.setRightPanelActiveTab);
// Track if we've restored the tab from localStorage
const tabRestoredRef = useRef(false);
// Track the previous sessionId to detect changes
const prevSessionIdRef = useRef(sessionId);
// Track which process outputs we've already loaded (to prevent duplicates)
const loadedOutputsRef = useRef<Set<string>>(new Set());
// Track which process IDs have been explicitly closed (so sync effect doesn't re-add them)
const closedProcessIdsRef = useRef<Set<string>>(new Set());
// Track if we've initialized closedProcessIdsRef from sessionStorage
const closedIdsInitializedRef = useRef(false);
// Reset terminals and refs when sessionId changes
useEffect(() => {
if (prevSessionIdRef.current === sessionId) return;
prevSessionIdRef.current = sessionId;
// Reset refs
tabRestoredRef.current = false;
loadedOutputsRef.current = new Set();
closedProcessIdsRef.current = new Set();
closedIdsInitializedRef.current = false;
// Reset terminals for new session
const baseTerminals: Terminal[] = [{ id: 'shell-1', type: 'shell', label: 'Terminal' }];
if (!sessionId) {
setTerminals(baseTerminals);
return;
}
const savedCustomTerminals = getSessionStorage<Terminal[]>(`customTerminals-${sessionId}`, []);
if (savedCustomTerminals.length > 0) {
setTerminals([...baseTerminals, ...savedCustomTerminals]);
} else {
setTerminals(baseTerminals);
}
}, [sessionId]);
// Persist active tab to localStorage when it changes
useEffect(() => {
if (!sessionId || !activeTab) return;
setLocalStorage(`rightPanel-tab-${sessionId}`, activeTab);
}, [sessionId, activeTab]);
// Persist custom terminals to sessionStorage when they change
// Skip persisting during session transitions to avoid overwriting the new session's data
useEffect(() => {
if (!sessionId) return;
// Only persist if we're not in a session transition (prevSessionIdRef is updated in reset effect)
if (prevSessionIdRef.current !== sessionId) return;
const customTerminals = terminals.filter(t => t.type === 'custom');
setSessionStorage(`customTerminals-${sessionId}`, customTerminals);
}, [sessionId, terminals]);
const closeLayoutPreview = useLayoutStore((state) => state.closePreview);
const setPreviewOpen = useAppStore((state) => state.setPreviewOpen);
const setPreviewStage = useAppStore((state) => state.setPreviewStage);
const devProcessId = useAppStore((state) =>
sessionId ? state.processes.devProcessBySessionId[sessionId] : undefined
);
const devOutput = useAppStore((state) =>
devProcessId ? state.processes.outputsByProcessId[devProcessId] ?? '' : ''
);
const previewOpen = useAppStore((state) =>
sessionId ? state.previewPanel.openBySessionId[sessionId] ?? false : false
);
// Use the terminals hook
const {
terminals,
activeTab,
terminalTabValue,
addTerminal,
handleCloseDevTab: baseHandleCloseDevTab,
handleCloseTab,
handleRunCommand,
isStoppingDev,
devProcessId,
devOutput,
} = useTerminals({ sessionId, initialTerminals });
// Wrap handleCloseDevTab to also close the layout preview
const handleCloseDevTab = useCallback(async (event: MouseEvent) => {
await baseHandleCloseDevTab(event);
if (sessionId) {
closeLayoutPreview(sessionId);
}
}, [baseHandleCloseDevTab, sessionId, closeLayoutPreview]);
// Repository scripts - use initialScripts as fallback for SSR
const { scripts: storeScripts, isLoaded: scriptsLoaded } = useRepositoryScripts(repositoryId);
const scripts = scriptsLoaded ? storeScripts : (initialScripts.length > 0 ? initialScripts : storeScripts);
const hasScripts = scripts.length > 0;
// Restore non-custom tabs from localStorage
// Restore 'commands' tab from sessionStorage (needs hasScripts check)
useEffect(() => {
if (!sessionId || tabRestoredRef.current) return;
const savedTab = getLocalStorage<string | null>(`rightPanel-tab-${sessionId}`, null);
if (!savedTab) return;
// Skip custom tabs - they're handled in a separate effect after terminals are set up
if (savedTab.startsWith('custom-')) return;
// For 'commands' tab, verify scripts exist (either from SSR or loaded)
if (!sessionId || !hasScripts) return;
const savedTab = getSessionStorage<string | null>(`rightPanel-tab-${sessionId}`, null);
if (savedTab === 'commands') {
if (hasScripts) {
setRightPanelActiveTab(sessionId, savedTab);
tabRestoredRef.current = true;
}
return;
}
// For shell tabs, restore immediately
if (savedTab.startsWith('shell-')) {
setRightPanelActiveTab(sessionId, savedTab);
tabRestoredRef.current = true;
}
}, [sessionId, hasScripts, setRightPanelActiveTab]);
// Process state for custom processes
const processState = useAppStore((state) => state.processes);
const appendProcessOutput = useAppStore((state) => state.appendProcessOutput);
const clearProcessOutput = useAppStore((state) => state.clearProcessOutput);
const upsertProcessStatus = useAppStore((state) => state.upsertProcessStatus);
// Get custom processes for this session from store
const customProcesses = useMemo(() => {
if (!sessionId) return [];
const processIds = processState.processIdsBySessionId[sessionId] ?? [];
return processIds
.map(id => processState.processesById[id])
.filter(p => p && p.kind === 'custom');
}, [sessionId, processState.processIdsBySessionId, processState.processesById]);
// Initialize closedProcessIdsRef from sessionStorage on mount
// This prevents re-adding terminals that were closed before page refresh
useEffect(() => {
if (!sessionId || customProcesses.length === 0) return;
if (closedIdsInitializedRef.current) return;
closedIdsInitializedRef.current = true;
const savedCustomTerminals = getSessionStorage<Terminal[]>(`customTerminals-${sessionId}`, []);
const savedProcessIds = new Set(
savedCustomTerminals.map(t => t.processId).filter(Boolean)
);
// Any custom process in store that's not in savedTerminals was closed before refresh
customProcesses.forEach(proc => {
if (!savedProcessIds.has(proc.processId)) {
closedProcessIdsRef.current.add(proc.processId);
}
});
}, [sessionId, customProcesses]);
// Sync dev server terminal with preview state
useEffect(() => {
if (!sessionId) return;
setTerminals((prev) => {
const hasDevTerminal = prev.some((t) => t.type === 'dev-server');
if (previewOpen && !hasDevTerminal) {
// Add dev server terminal at the beginning
return [{ id: 'dev-server', type: 'dev-server', label: 'Dev Server' }, ...prev];
}
if (!previewOpen && hasDevTerminal) {
// Remove dev server terminal
return prev.filter((t) => t.type !== 'dev-server');
}
return prev;
});
}, [previewOpen, sessionId]);
// Sync custom terminals from store (adds any new processes not already in terminals)
useEffect(() => {
if (!sessionId || customProcesses.length === 0) return;
setTerminals(prev => {
const existingCustomIds = new Set(
prev.filter(t => t.type === 'custom').map(t => t.processId)
);
const newTerminals = customProcesses
.filter(p => !existingCustomIds.has(p.processId) && !closedProcessIdsRef.current.has(p.processId))
.map(p => ({
id: `custom-${p.processId}`,
type: 'custom' as const,
label: p.scriptName ?? 'Script',
processId: p.processId,
}));
if (newTerminals.length === 0) return prev;
return [...prev, ...newTerminals];
});
}, [sessionId, customProcesses]);
// Load output for custom terminals that are no longer running (restore after page refresh)
// Running processes get output via WebSocket streaming - don't fetch from API for those
useEffect(() => {
if (!sessionId) return;
const customTerminals = terminals.filter(t => t.type === 'custom' && t.processId);
customTerminals.forEach(async (terminal) => {
const processId = terminal.processId!;
if (loadedOutputsRef.current.has(processId)) return;
// Check process status - only fetch from API for completed/stopped/failed processes
// Running/starting processes get output via WebSocket streaming
const processInfo = processState.processesById[processId];
const isActive = !processInfo || processInfo.status === 'running' || processInfo.status === 'starting';
if (isActive) return;
// Process is completed/stopped/failed - check if we need to restore output from API
// Get current output from store (don't use as dependency to avoid re-runs on every output change)
const currentOutput = storeApi.getState().processes.outputsByProcessId[processId];
if (currentOutput && currentOutput.length > 0) {
loadedOutputsRef.current.add(processId);
return;
}
loadedOutputsRef.current.add(processId);
try {
const fullProc = await getSessionProcess(sessionId, processId, true);
clearProcessOutput(processId);
if (fullProc.command) {
appendProcessOutput(processId, `$ ${fullProc.command}\n\n`);
}
fullProc.output?.forEach(chunk => {
appendProcessOutput(processId, chunk.data);
});
} catch {
// Remove from loaded set on error so it can be retried
loadedOutputsRef.current.delete(processId);
}
});
}, [sessionId, terminals, processState.processesById, clearProcessOutput, appendProcessOutput, storeApi]);
// Restore saved custom tab after terminals are set up
useEffect(() => {
if (!sessionId || tabRestoredRef.current) return;
const savedTab = getLocalStorage<string | null>(`rightPanel-tab-${sessionId}`, null);
if (!savedTab?.startsWith('custom-')) return;
// Check if this custom tab exists in terminals
const terminalExists = terminals.some(t => t.id === savedTab);
if (terminalExists) {
setRightPanelActiveTab(sessionId, savedTab);
tabRestoredRef.current = true;
}
}, [sessionId, terminals, setRightPanelActiveTab]);
const addTerminal = useCallback(() => {
setTerminals((prev) => {
const shellTerminals = prev.filter((t) => t.type === 'shell');
const nextNum = shellTerminals.length + 1;
const newTerminal: Terminal = {
id: `shell-${nextNum}`,
type: 'shell',
label: nextNum === 1 ? 'Terminal' : `Terminal ${nextNum}`,
};
if (sessionId) {
setRightPanelActiveTab(sessionId, newTerminal.id);
}
return [...prev, newTerminal];
});
}, [sessionId, setRightPanelActiveTab]);
const removeTerminal = useCallback(
(id: string) => {
setTerminals((prev) => {
const terminalToRemove = prev.find((t) => t.id === id);
if (!terminalToRemove) return prev;
// Only enforce "keep at least one shell" for shell terminals
if (terminalToRemove.type === 'shell') {
const shellTerminals = prev.filter((t) => t.type === 'shell');
if (shellTerminals.length <= 1) {
return prev; // Keep at least one shell terminal
}
}
const nextTerminals = prev.filter((t) => t.id !== id);
// If removing active tab, switch to first available shell terminal
if (activeTab === id) {
const fallbackShell = nextTerminals.find((t) => t.type === 'shell');
if (fallbackShell && sessionId) {
setRightPanelActiveTab(sessionId, fallbackShell.id);
}
}
return nextTerminals;
});
},
[activeTab, sessionId, setRightPanelActiveTab]
);
const terminalTabValue = activeTab ?? terminals.find((t) => t.type === 'shell')?.id ?? 'commands';
// Validate active tab exists in terminals
// Persist active tab to sessionStorage when it changes
useEffect(() => {
if (!sessionId || !activeTab) return;
const tabExists =
activeTab === 'commands' ||
terminals.some((t) => t.id === activeTab);
if (!tabExists) {
const fallbackShell = terminals.find((t) => t.type === 'shell');
if (fallbackShell) {
setRightPanelActiveTab(sessionId, fallbackShell.id);
}
}
}, [activeTab, sessionId, terminals, setRightPanelActiveTab]);
setSessionStorage(`rightPanel-tab-${sessionId}`, activeTab);
}, [sessionId, activeTab]);
// Save collapse state to local storage
useEffect(() => {
setLocalStorage('task-right-panel-collapsed', isBottomCollapsed);
}, [isBottomCollapsed]);
const handleCloseDevTab = useCallback(
async (event: MouseEvent) => {
event.preventDefault();
event.stopPropagation();
if (!sessionId) return;
if (devProcessId) {
setIsStoppingDev(true);
try {
await stopProcess(sessionId, { process_id: devProcessId });
} finally {
setIsStoppingDev(false);
}
}
const fallbackShell = terminals.find((t) => t.type === 'shell');
if (fallbackShell) {
setRightPanelActiveTab(sessionId, fallbackShell.id);
}
setPreviewOpen(sessionId, false);
setPreviewStage(sessionId, 'closed');
closeLayoutPreview(sessionId);
},
[sessionId, devProcessId, terminals, setRightPanelActiveTab, setPreviewOpen, setPreviewStage, closeLayoutPreview]
);
const handleRunCommand = useCallback(async (script: RepositoryScript) => {
if (!sessionId) return;
try {
const response = await startProcess(sessionId, {
kind: 'custom',
script_name: script.name
});
if (response?.process) {
const newTerminal: Terminal = {
id: `custom-${response.process.id}`,
type: 'custom',
label: script.name,
processId: response.process.id,
};
// Mark as loaded immediately - WebSocket will stream output, no need to fetch from API
loadedOutputsRef.current.add(response.process.id);
// Display the command for processes that are still starting/running
// Completed/stopped/failed processes will have output restored by the effect (avoids race condition)
const status = response.process.status;
if (response.process.command && (status === 'starting' || status === 'running')) {
clearProcessOutput(response.process.id);
appendProcessOutput(response.process.id, `$ ${response.process.command}\n\n`);
}
setTerminals(prev => {
// Check if terminal already exists
if (prev.some(t => t.id === newTerminal.id)) {
return prev;
}
return [...prev, newTerminal];
});
setRightPanelActiveTab(sessionId, newTerminal.id);
// Update store with process status
upsertProcessStatus({
processId: response.process.id,
sessionId: response.process.session_id,
kind: response.process.kind,
scriptName: response.process.script_name,
status: response.process.status,
command: response.process.command,
workingDir: response.process.working_dir,
exitCode: response.process.exit_code ?? null,
startedAt: response.process.started_at,
updatedAt: response.process.updated_at,
});
}
} catch (error) {
console.error('Failed to start command:', error);
}
}, [sessionId, setRightPanelActiveTab, upsertProcessStatus, clearProcessOutput, appendProcessOutput]);
const handleCloseCustomTab = useCallback(async (
event: MouseEvent,
terminalId: string,
processId?: string
) => {
event.preventDefault();
event.stopPropagation();
// Mark as closed so sync effect doesn't re-add it
if (processId) {
closedProcessIdsRef.current.add(processId);
}
// Remove the terminal immediately
removeTerminal(terminalId);
// Stop process if still running (don't await - do it in background)
if (processId && sessionId) {
const proc = processState.processesById[processId];
if (proc?.status === 'running' || proc?.status === 'starting') {
stopProcess(sessionId, { process_id: processId }).catch((error) => {
console.error('Failed to stop process:', error);
});
}
}
}, [sessionId, processState.processesById, removeTerminal]);
const tabs: SessionTab[] = useMemo(() => {
const allTabs: SessionTab[] = [];
@@ -480,48 +99,25 @@ const TaskRightPanel = memo(function TaskRightPanel({ topPanel, sessionId = null
allTabs.push({ id: 'commands', label: 'Commands' });
}
// Add terminal tabs (dev-server, shell, custom)
// Add terminal tabs (dev-server, shell, script)
// Use closable from backend (source of truth) for shell terminals
const terminalTabs: SessionTab[] = terminals.map((terminal) => {
const shellCount = terminals.filter((t) => t.type === 'shell').length;
const isClosable =
terminal.type === 'dev-server' ||
terminal.type === 'custom' ||
(terminal.type === 'shell' && shellCount > 1);
// Check if custom process is running
let icon: React.ReactNode = undefined;
if (terminal.type === 'custom' && terminal.processId) {
const proc = processState.processesById[terminal.processId];
const isRunning = proc?.status === 'running' || proc?.status === 'starting';
if (isRunning) {
icon = <span className="w-1.5 h-1.5 rounded-full bg-green-500" />;
}
}
return {
id: terminal.id,
label: terminal.label,
icon,
className: isClosable
? 'group flex items-center gap-1 pr-1 cursor-pointer'
className: terminal.closable
? 'group flex items-center cursor-pointer'
: 'cursor-pointer',
closable: isClosable,
alwaysShowClose: terminal.type === 'custom',
closable: terminal.closable,
onClose:
terminal.type === 'dev-server'
? handleCloseDevTab
: terminal.type === 'custom'
? (e: MouseEvent) => handleCloseCustomTab(e, terminal.id, terminal.processId)
: (e: MouseEvent) => {
e.preventDefault();
e.stopPropagation();
removeTerminal(terminal.id);
},
: (e: MouseEvent) => handleCloseTab(e, terminal.id),
};
});
return [...allTabs, ...terminalTabs];
}, [hasScripts, terminals, processState.processesById, handleCloseDevTab, handleCloseCustomTab, removeTerminal]);
}, [hasScripts, terminals, handleCloseDevTab, handleCloseTab]);
if (isBottomCollapsed) {
return (
@@ -616,14 +212,13 @@ const TaskRightPanel = memo(function TaskRightPanel({ topPanel, sessionId = null
processId={devProcessId ?? null}
isStopping={isStoppingDev}
/>
) : terminal.type === 'custom' ? (
<ShellTerminal
key={terminal.processId}
processOutput={processState.outputsByProcessId[terminal.processId ?? ''] ?? ''}
processId={terminal.processId ?? null}
/>
) : (
<ShellTerminal key={sessionId} sessionId={sessionId ?? undefined} />
<PassthroughTerminal
key={terminal.id}
sessionId={sessionId ?? undefined}
terminalId={terminal.id}
label={terminal.type === 'shell' ? terminal.label : undefined}
/>
)}
</SessionPanelContent>
</TabsContent>
@@ -0,0 +1,330 @@
'use client';
import { useEffect, useLayoutEffect, useState, useCallback, useRef, useMemo } from 'react';
import { getSessionStorage } from '@/lib/local-storage';
import { useAppStore } from '@/components/state-provider';
import { stopProcess } from '@/lib/api';
import { stopUserShell, createUserShell } from '@/lib/api/domains/user-shell-api';
import { useUserShells } from './use-user-shells';
import type { RepositoryScript } from '@/lib/types/http';
import type { MouseEvent } from 'react';
export type TerminalType = 'dev-server' | 'shell' | 'script';
export type Terminal = {
id: string;
type: TerminalType;
label: string;
closable: boolean; // Whether the terminal can be closed (backend is source of truth)
};
interface UseTerminalsOptions {
sessionId: string | null;
initialTerminals?: Terminal[]; // Initial terminals from SSR
}
interface UseTerminalsReturn {
terminals: Terminal[];
activeTab: string | undefined;
terminalTabValue: string;
addTerminal: () => void;
removeTerminal: (id: string) => void;
handleCloseDevTab: (event: MouseEvent) => Promise<void>;
handleCloseTab: (event: MouseEvent, terminalId: string) => void;
handleRunCommand: (script: RepositoryScript) => void;
isStoppingDev: boolean;
devProcessId: string | undefined;
devOutput: string;
}
export function useTerminals({ sessionId, initialTerminals }: UseTerminalsOptions): UseTerminalsReturn {
// Initialize terminals from SSR props if provided, otherwise empty
const [terminals, setTerminals] = useState<Terminal[]>(() => initialTerminals ?? []);
const [isStoppingDev, setIsStoppingDev] = useState(false);
// Track refs
const tabRestoredRef = useRef(false);
const prevSessionIdRef = useRef(sessionId);
// Track if sessionId just changed - used to ignore stale store values during transition
const sessionJustChanged = sessionId !== prevSessionIdRef.current;
// Store selectors
const activeTab = useAppStore((state) =>
sessionId ? state.rightPanel.activeTabBySessionId[sessionId] : undefined
);
const setRightPanelActiveTab = useAppStore((state) => state.setRightPanelActiveTab);
const devProcessId = useAppStore((state) =>
sessionId ? state.processes.devProcessBySessionId[sessionId] : undefined
);
const devOutput = useAppStore((state) =>
devProcessId ? state.processes.outputsByProcessId[devProcessId] ?? '' : ''
);
const previewOpen = useAppStore((state) =>
sessionId ? state.previewPanel.openBySessionId[sessionId] ?? false : false
);
const setPreviewOpen = useAppStore((state) => state.setPreviewOpen);
const setPreviewStage = useAppStore((state) => state.setPreviewStage);
// Use the user shells hook - this fetches running shells from backend
// Backend now returns label and initialCommand for each shell
const { shells: userShells, isLoaded: userShellsLoaded } = useUserShells(sessionId);
// Reset terminals and refs when sessionId changes
useEffect(() => {
if (prevSessionIdRef.current === sessionId) return;
prevSessionIdRef.current = sessionId;
// Reset refs
tabRestoredRef.current = false;
// Clear terminals - will be populated by user shells effect
setTerminals([]);
// Clear active tab from store so sessionStorage restoration can set the correct value
// This prevents stale activeTab from store being used when switching back to a session
if (sessionId) {
setRightPanelActiveTab(sessionId, '');
}
}, [sessionId, setRightPanelActiveTab]);
// Populate terminals from user shells hook
// Backend is source of truth - always returns at least one "Terminal" entry
useEffect(() => {
if (!sessionId || !userShellsLoaded) return;
setTerminals(prev => {
// Keep dev-server terminal if it exists
const devTerminal = prev.find(t => t.type === 'dev-server');
// Build terminals from backend data, preserving the order returned by backend
// Backend returns them sorted by CreatedAt for stable ordering
const userTerminals: Terminal[] = userShells.map((shell) => {
const isScript = shell.terminalId.startsWith('script-');
return {
id: shell.terminalId,
type: isScript ? 'script' as const : 'shell' as const,
label: shell.label || (isScript ? 'Script' : 'Terminal'),
closable: shell.closable,
};
});
const result: Terminal[] = [];
if (devTerminal) result.push(devTerminal);
result.push(...userTerminals);
return result;
});
}, [sessionId, userShells, userShellsLoaded]);
// Sync dev server terminal with preview state
useEffect(() => {
if (!sessionId) return;
setTerminals((prev) => {
const hasDevTerminal = prev.some((t) => t.type === 'dev-server');
if (previewOpen && !hasDevTerminal) {
return [{ id: 'dev-server', type: 'dev-server' as const, label: 'Dev Server', closable: true }, ...prev];
}
if (!previewOpen && hasDevTerminal) {
return prev.filter((t) => t.type !== 'dev-server');
}
return prev;
});
}, [previewOpen, sessionId]);
// Sync saved tab to store - useLayoutEffect runs before paint
// This ensures the store has the correct value for subsequent interactions
useLayoutEffect(() => {
// Treat empty string as no active tab (we clear it on session change)
const hasActiveTab = activeTab && activeTab !== '';
if (!sessionId || tabRestoredRef.current || hasActiveTab) {
return;
}
const savedTab = getSessionStorage<string | null>(`rightPanel-tab-${sessionId}`, null);
if (!savedTab) {
return;
}
// Restore if the terminal exists
const exists = terminals.some(t => t.id === savedTab);
if (exists) {
setRightPanelActiveTab(sessionId, savedTab);
tabRestoredRef.current = true;
}
}, [sessionId, terminals, activeTab, setRightPanelActiveTab]);
// Validate active tab exists in terminals
// IMPORTANT: Only validate after terminals have been loaded for this session
// Skip validation if terminals are empty (still loading) or if tab hasn't been restored yet
useEffect(() => {
if (!sessionId || !activeTab || activeTab === '') return;
// Skip validation if terminals haven't been loaded yet (avoid validating against stale data)
if (terminals.length === 0) return;
// Skip validation if we haven't restored from sessionStorage yet
if (!tabRestoredRef.current) return;
const tabExists =
activeTab === 'commands' ||
terminals.some((t) => t.id === activeTab);
if (!tabExists) {
const fallbackShell = terminals.find((t) => t.type === 'shell');
if (fallbackShell) {
setRightPanelActiveTab(sessionId, fallbackShell.id);
}
}
}, [activeTab, sessionId, terminals, setRightPanelActiveTab]);
const addTerminal = useCallback(async () => {
if (!sessionId) return;
try {
// Ask backend to create terminal - backend assigns ID, label, and closable
const result = await createUserShell(sessionId);
const newTerminal: Terminal = {
id: result.terminalId,
type: 'shell',
label: result.label,
closable: result.closable,
};
setTerminals((prev) => [...prev, newTerminal]);
setRightPanelActiveTab(sessionId, result.terminalId);
} catch (error) {
console.error('Failed to create user shell:', error);
}
}, [sessionId, setRightPanelActiveTab]);
const removeTerminal = useCallback(
(id: string) => {
setTerminals((prev) => {
const indexToRemove = prev.findIndex((t) => t.id === id);
if (indexToRemove === -1) return prev;
const terminalToRemove = prev[indexToRemove];
// Don't allow removing non-closable terminals (backend is source of truth)
if (!terminalToRemove.closable) {
return prev;
}
const nextTerminals = prev.filter((t) => t.id !== id);
// If we're closing the active tab, focus the one to the left (or right if leftmost)
if (activeTab === id && sessionId) {
// Find the terminal to the left, or to the right if there's none on the left
const leftIndex = indexToRemove - 1;
const newFocusTerminal = leftIndex >= 0 ? prev[leftIndex] : nextTerminals[0];
if (newFocusTerminal) {
setRightPanelActiveTab(sessionId, newFocusTerminal.id);
}
}
return nextTerminals;
});
},
[activeTab, sessionId, setRightPanelActiveTab]
);
const handleCloseDevTab = useCallback(
async (event: MouseEvent) => {
event.preventDefault();
event.stopPropagation();
if (!sessionId) return;
if (devProcessId) {
setIsStoppingDev(true);
try {
await stopProcess(sessionId, { process_id: devProcessId });
} finally {
setIsStoppingDev(false);
}
}
const fallbackShell = terminals.find((t) => t.type === 'shell');
if (fallbackShell) {
setRightPanelActiveTab(sessionId, fallbackShell.id);
}
setPreviewOpen(sessionId, false);
setPreviewStage(sessionId, 'closed');
},
[sessionId, devProcessId, terminals, setRightPanelActiveTab, setPreviewOpen, setPreviewStage]
);
// Handle running a custom command - creates a script terminal via backend
// Backend looks up the script by ID, assigns terminal ID, label, and registers it
const handleRunCommand = useCallback(async (script: RepositoryScript) => {
if (!sessionId) return;
try {
const result = await createUserShell(sessionId, script.id);
const newTerminal: Terminal = {
id: result.terminalId,
type: 'script',
label: result.label,
closable: result.closable,
};
setTerminals(prev => [...prev, newTerminal]);
setRightPanelActiveTab(sessionId, result.terminalId);
} catch (error) {
console.error('Failed to create script terminal:', error);
}
}, [sessionId, setRightPanelActiveTab]);
// Handle closing a terminal tab (shell or script) - stops the user shell process
const handleCloseTab = useCallback((event: MouseEvent, terminalId: string) => {
event.preventDefault();
event.stopPropagation();
removeTerminal(terminalId);
if (sessionId) {
stopUserShell(sessionId, terminalId).catch((error) => {
console.error('Failed to stop terminal:', error);
});
}
}, [sessionId, removeTerminal]);
// Read saved tab from sessionStorage synchronously to avoid flicker on initial render
const savedTabFromStorage = useMemo(() => {
if (!sessionId) return null;
return getSessionStorage<string | null>(`rightPanel-tab-${sessionId}`, null);
}, [sessionId]);
// Check if saved tab exists in current terminals
const savedTabExists = savedTabFromStorage && terminals.some(t => t.id === savedTabFromStorage);
// Use saved tab as fallback before store is updated - this prevents flicker
// Trust the saved tab if terminals haven't loaded yet (length === 0) or if it exists
// Treat empty string activeTab as falsy (we clear it on session change)
// IMPORTANT: Ignore store's activeTab if session just changed - it may be stale from before switching away
const effectiveActiveTab = (!sessionJustChanged && activeTab && activeTab !== '') ? activeTab : null;
const terminalTabValue = effectiveActiveTab
?? (savedTabFromStorage && (terminals.length === 0 || savedTabExists) ? savedTabFromStorage : null)
?? terminals.find((t) => t.type === 'shell')?.id
?? 'commands';
return {
terminals,
activeTab,
terminalTabValue,
addTerminal,
removeTerminal,
handleCloseDevTab,
handleCloseTab,
handleRunCommand,
isStoppingDev,
devProcessId,
devOutput,
};
}
@@ -0,0 +1,139 @@
import { useEffect, useRef } from 'react';
import { getWebSocketClient } from '@/lib/ws/connection';
import { useAppStore, useAppStoreApi } from '@/components/state-provider';
import type { UserShellInfo } from '@/lib/state/slices';
interface UseUserShellsReturn {
shells: UserShellInfo[];
isLoading: boolean;
isLoaded: boolean;
addShell: (shell: UserShellInfo) => void;
removeShell: (terminalId: string) => void;
}
const EMPTY_SHELLS: UserShellInfo[] = [];
/**
* Hook to fetch and manage user shell terminals for a session.
*
* Follows the data fetching pattern:
* 1. Read from store first
* 2. Fetch from backend if not loaded
* 3. Track loading/loaded state
*/
export function useUserShells(sessionId: string | null): UseUserShellsReturn {
const store = useAppStoreApi();
// Read from store
const shells = useAppStore((state) =>
sessionId ? state.userShells.bySessionId[sessionId] ?? EMPTY_SHELLS : EMPTY_SHELLS
);
const isLoading = useAppStore((state) =>
sessionId ? state.userShells.loading[sessionId] ?? false : false
);
const isLoaded = useAppStore((state) =>
sessionId ? state.userShells.loaded[sessionId] ?? false : false
);
const connectionStatus = useAppStore((state) => state.connection.status);
// Guard refs to prevent duplicate fetches
const lastFetchedSessionIdRef = useRef<string | null>(null);
const prevSessionIdRef = useRef<string | null>(null);
// Reset refs when session clears
useEffect(() => {
if (!sessionId) {
lastFetchedSessionIdRef.current = null;
}
}, [sessionId]);
// Fetch user shells from backend
useEffect(() => {
if (!sessionId) return;
if (connectionStatus !== 'connected') return;
// Detect session change to force refetch
const sessionChanged = prevSessionIdRef.current !== null &&
prevSessionIdRef.current !== sessionId;
prevSessionIdRef.current = sessionId;
// If session changed, reset fetch guard
if (sessionChanged) {
lastFetchedSessionIdRef.current = null;
}
// Check if already loaded (unless session just changed)
if (isLoaded && !sessionChanged) {
lastFetchedSessionIdRef.current = sessionId;
return;
}
// Don't fetch again if already fetched for this session
if (lastFetchedSessionIdRef.current === sessionId) {
return;
}
const fetchShells = async () => {
const client = getWebSocketClient();
if (!client) return;
store.getState().setUserShellsLoading(sessionId, true);
try {
const response = await client.request<{ shells?: Array<{
terminal_id: string;
process_id: string;
running: boolean;
label: string;
closable: boolean;
initial_command?: string;
}> }>(
'user_shell.list',
{ session_id: sessionId },
10000
);
// Transform backend format (snake_case) to frontend format (camelCase)
const shells: UserShellInfo[] = (response.shells ?? []).map((s) => ({
terminalId: s.terminal_id,
processId: s.process_id,
running: s.running,
label: s.label || 'Terminal',
closable: s.closable,
initialCommand: s.initial_command,
}));
store.getState().setUserShells(sessionId, shells);
lastFetchedSessionIdRef.current = sessionId;
} catch (error) {
console.error('Failed to fetch user shells:', error);
// Set empty shells on error so we don't keep retrying
store.getState().setUserShells(sessionId, []);
lastFetchedSessionIdRef.current = sessionId;
}
};
fetchShells();
}, [sessionId, connectionStatus, isLoaded, store]);
// Actions
const addShell = (shell: UserShellInfo) => {
if (sessionId) {
store.getState().addUserShell(sessionId, shell);
}
};
const removeShell = (terminalId: string) => {
if (sessionId) {
store.getState().removeUserShell(sessionId, terminalId);
}
};
return {
shells,
isLoading,
isLoaded,
addShell,
removeShell,
};
}
@@ -41,7 +41,8 @@ export function useRepositoryScripts(repositoryId: string | null, enabled = true
if (cancelled) return;
setRepositoryScripts(repositoryId, response.scripts ?? []);
})
.catch(() => {
.catch((error) => {
console.error('[useRepositoryScripts] Fetch error:', { repositoryId, error });
if (cancelled) return;
setRepositoryScripts(repositoryId, []);
})
@@ -0,0 +1,99 @@
import { getWebSocketClient } from '@/lib/ws/connection';
import { getBackendConfig } from '@/lib/config';
/**
* Terminal info returned by HTTP API (for SSR).
*/
export type TerminalInfo = {
terminal_id: string;
process_id: string;
running: boolean;
label: string;
closable: boolean;
initial_command?: string;
};
/**
* Fetch terminals for a session via HTTP (for SSR).
* This endpoint auto-creates the first "Terminal" if none exist.
*/
export async function fetchTerminals(sessionId: string): Promise<TerminalInfo[]> {
const { apiBaseUrl } = getBackendConfig();
const url = `${apiBaseUrl}/api/v1/sessions/${sessionId}/terminals`;
try {
const response = await fetch(url);
if (!response.ok) {
console.warn('Failed to fetch terminals:', response.status);
return [];
}
const data = await response.json();
return data.terminals ?? [];
} catch (error) {
console.warn('Failed to fetch terminals:', error);
return [];
}
}
/**
* Result of creating a new user shell.
*/
export type CreateUserShellResult = {
terminalId: string;
label: string;
closable: boolean;
initialCommand?: string;
};
/**
* Create a new user shell terminal.
* Backend assigns the terminal ID, label, and closable status.
* First terminal is "Terminal" and not closable, subsequent are "Terminal 2", etc. and closable.
* If scriptId is provided, creates a script terminal with the script's name and command.
*/
export async function createUserShell(sessionId: string, scriptId?: string): Promise<CreateUserShellResult> {
const client = getWebSocketClient();
if (!client) {
throw new Error('WebSocket client not available');
}
const payload: Record<string, string> = { session_id: sessionId };
if (scriptId) {
payload.script_id = scriptId;
}
const response = await client.request('user_shell.create', payload) as {
terminal_id: string;
label: string;
closable: boolean;
initial_command?: string;
};
return {
terminalId: response.terminal_id,
label: response.label,
closable: response.closable,
initialCommand: response.initial_command,
};
}
/**
* Stop a user shell terminal process.
* This is called when closing a terminal tab to clean up the backend process.
*/
export async function stopUserShell(sessionId: string, terminalId: string): Promise<void> {
const client = getWebSocketClient();
if (!client) {
// WebSocket not available, silently fail (best-effort cleanup)
return;
}
try {
await client.request('user_shell.stop', {
session_id: sessionId,
terminal_id: terminalId,
});
} catch (error) {
// Log but don't throw - this is best-effort cleanup
console.warn('Failed to stop user shell:', error);
}
}
+2
View File
@@ -75,6 +75,8 @@ export type {
AgentState,
AvailableCommand,
AvailableCommandsState,
UserShellInfo,
UserShellsState,
} from './session-runtime/types';
export type {
PreviewStage,
@@ -26,6 +26,7 @@ export const defaultSessionRuntimeState: SessionRuntimeSliceState = {
contextWindow: { bySessionId: {} },
agents: { agents: [] },
availableCommands: { bySessionId: {} },
userShells: { bySessionId: {}, loading: {}, loaded: {} },
};
export const createSessionRuntimeSlice: StateCreator<
@@ -141,4 +142,28 @@ export const createSessionRuntimeSlice: StateCreator<
set((draft) => {
delete draft.availableCommands.bySessionId[sessionId];
}),
// User shells actions
setUserShells: (sessionId, shells) =>
set((draft) => {
draft.userShells.bySessionId[sessionId] = shells;
draft.userShells.loaded[sessionId] = true;
draft.userShells.loading[sessionId] = false;
}),
setUserShellsLoading: (sessionId, loading) =>
set((draft) => {
draft.userShells.loading[sessionId] = loading;
}),
addUserShell: (sessionId, shell) =>
set((draft) => {
const existing = draft.userShells.bySessionId[sessionId] || [];
// Don't add if already exists
if (!existing.some((s) => s.terminalId === shell.terminalId)) {
draft.userShells.bySessionId[sessionId] = [...existing, shell];
}
}),
removeUserShell: (sessionId, terminalId) =>
set((draft) => {
const existing = draft.userShells.bySessionId[sessionId] || [];
draft.userShells.bySessionId[sessionId] = existing.filter((s) => s.terminalId !== terminalId);
}),
});
@@ -146,6 +146,21 @@ export type AvailableCommandsState = {
bySessionId: Record<string, AvailableCommand[]>;
};
export type UserShellInfo = {
terminalId: string;
processId: string;
running: boolean;
label: string; // Display name (e.g., "Terminal" or script name)
closable: boolean; // Whether the terminal can be closed (first terminal is not closable)
initialCommand?: string; // Command that was run (empty for plain shells)
};
export type UserShellsState = {
bySessionId: Record<string, UserShellInfo[]>;
loading: Record<string, boolean>;
loaded: Record<string, boolean>;
};
export type SessionRuntimeSliceState = {
terminal: TerminalState;
shell: ShellState;
@@ -156,6 +171,7 @@ export type SessionRuntimeSliceState = {
contextWindow: ContextWindowState;
agents: AgentState;
availableCommands: AvailableCommandsState;
userShells: UserShellsState;
};
export type SessionRuntimeSliceActions = {
@@ -185,6 +201,11 @@ export type SessionRuntimeSliceActions = {
// Available commands actions
setAvailableCommands: (sessionId: string, commands: AvailableCommand[]) => void;
clearAvailableCommands: (sessionId: string) => void;
// User shells actions
setUserShells: (sessionId: string, shells: UserShellInfo[]) => void;
setUserShellsLoading: (sessionId: string, loading: boolean) => void;
addUserShell: (sessionId: string, shell: UserShellInfo) => void;
removeUserShell: (sessionId: string, terminalId: string) => void;
};
export type SessionRuntimeSlice = SessionRuntimeSliceState & SessionRuntimeSliceActions;
@@ -49,6 +49,7 @@ export type WorkspaceSliceActions = {
setRepositoryBranchesLoading: (repositoryId: string, loading: boolean) => void;
setRepositoryScripts: (repositoryId: string, scripts: RepositoryScript[]) => void;
setRepositoryScriptsLoading: (repositoryId: string, loading: boolean) => void;
clearRepositoryScripts: (repositoryId: string) => void;
};
export type WorkspaceSlice = WorkspaceSliceState & WorkspaceSliceActions;
@@ -60,4 +60,10 @@ export const createWorkspaceSlice: StateCreator<
set((draft) => {
draft.repositoryScripts.loadingByRepositoryId[repositoryId] = loading;
}),
clearRepositoryScripts: (repositoryId) =>
set((draft) => {
delete draft.repositoryScripts.itemsByRepositoryId[repositoryId];
delete draft.repositoryScripts.loadingByRepositoryId[repositoryId];
delete draft.repositoryScripts.loadedByRepositoryId[repositoryId];
}),
});
+12
View File
@@ -83,6 +83,8 @@ export type {
ContextWindowEntry,
ContextWindowState,
AgentState,
UserShellInfo,
UserShellsState,
PreviewStage,
PreviewViewMode,
PreviewDevicePreset,
@@ -141,6 +143,7 @@ export type AppState = {
contextWindow: typeof defaultSessionRuntimeState['contextWindow'];
agents: typeof defaultSessionRuntimeState['agents'];
availableCommands: typeof defaultSessionRuntimeState['availableCommands'];
userShells: typeof defaultSessionRuntimeState['userShells'];
// UI slice
previewPanel: typeof defaultUIState['previewPanel'];
@@ -170,6 +173,7 @@ export type AppState = {
setRepositoryBranchesLoading: (repositoryId: string, loading: boolean) => void;
setRepositoryScripts: (repositoryId: string, scripts: RepositoryScript[]) => void;
setRepositoryScriptsLoading: (repositoryId: string, loading: boolean) => void;
clearRepositoryScripts: (repositoryId: string) => void;
setSettingsData: (next: Partial<SettingsDataState>) => void;
setEditors: (editors: EditorsState['items']) => void;
setEditorsLoading: (loading: boolean) => void;
@@ -254,6 +258,11 @@ export type AppState = {
// Available commands actions
setAvailableCommands: (sessionId: string, commands: import('./slices/session-runtime/types').AvailableCommand[]) => void;
clearAvailableCommands: (sessionId: string) => void;
// User shells actions
setUserShells: (sessionId: string, shells: import('./slices/session-runtime/types').UserShellInfo[]) => void;
setUserShellsLoading: (sessionId: string, loading: boolean) => void;
addUserShell: (sessionId: string, shell: import('./slices/session-runtime/types').UserShellInfo) => void;
removeUserShell: (sessionId: string, terminalId: string) => void;
};
export type AppStore = ReturnType<typeof createAppStore>;
@@ -296,6 +305,7 @@ const defaultState = {
contextWindow: defaultSessionRuntimeState.contextWindow,
agents: defaultSessionRuntimeState.agents,
availableCommands: defaultSessionRuntimeState.availableCommands,
userShells: defaultSessionRuntimeState.userShells,
previewPanel: defaultUIState.previewPanel,
rightPanel: defaultUIState.rightPanel,
diffs: defaultUIState.diffs,
@@ -348,6 +358,7 @@ function mergeInitialState(initialState?: Partial<AppState>): typeof defaultStat
sessionCommits: { ...defaultState.sessionCommits, ...initialState.sessionCommits },
contextWindow: { ...defaultState.contextWindow, ...initialState.contextWindow },
agents: { ...defaultState.agents, ...initialState.agents },
userShells: { ...defaultState.userShells, ...initialState.userShells },
previewPanel: { ...defaultState.previewPanel, ...initialState.previewPanel },
rightPanel: { ...defaultState.rightPanel, ...initialState.rightPanel },
diffs: { ...defaultState.diffs, ...initialState.diffs },
@@ -411,6 +422,7 @@ export function createAppStore(initialState?: Partial<AppState>) {
gitStatus: merged.gitStatus,
contextWindow: merged.contextWindow,
agents: merged.agents,
userShells: merged.userShells,
previewPanel: merged.previewPanel,
rightPanel: merged.rightPanel,
diffs: merged.diffs,