// Package repository persists ordinary user terminals in SQLite. // // The bottom-panel and script terminals are not persisted here — guards in // the terminal service decide which terminals get a row. This package is // scope-agnostic; it just stores what it's told. package repository import ( "context" "database/sql" "errors" "fmt" "github.com/jmoiron/sqlx" "github.com/kandev/kandev/internal/common/logger" "github.com/kandev/kandev/internal/terminal/models" ) // ErrNotFound is returned by Get when no terminal matches the id. var ErrNotFound = errors.New("terminal not found") // Repository persists user terminals. type Repository struct { db *sqlx.DB // writer ro *sqlx.DB // reader log *logger.Logger } // NewWithDB constructs a Repository sharing the supplied writer/reader pools. // initSchema creates the table on first call; subsequent calls are no-ops. func NewWithDB(writer, reader *sqlx.DB, log *logger.Logger) (*Repository, error) { r := &Repository{db: writer, ro: reader, log: log} if err := r.initSchema(); err != nil { return nil, fmt.Errorf("init terminal schema: %w", err) } return r, nil } func (r *Repository) initSchema() error { stmts := []string{ `CREATE TABLE IF NOT EXISTS user_terminals ( id TEXT PRIMARY KEY, task_id TEXT NOT NULL, environment_id TEXT NOT NULL, seq INTEGER NOT NULL, custom_name TEXT, state TEXT NOT NULL DEFAULT 'open', initial_command TEXT NOT NULL DEFAULT '', created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, UNIQUE(task_id, seq) )`, `CREATE INDEX IF NOT EXISTS idx_user_terminals_task ON user_terminals(task_id)`, `CREATE INDEX IF NOT EXISTS idx_user_terminals_env ON user_terminals(environment_id)`, } for _, s := range stmts { if _, err := r.db.Exec(s); err != nil { return err } } return nil } // Create inserts a new terminal row. The seq is computed as MAX(seq)+1 for // the task — never reused, so deletes leave gaps. // // Seq computation and insertion are folded into a single INSERT … SELECT // statement so the MAX read and the new row write happen atomically inside // SQLite's per-statement transaction. Two concurrent creates for the same // task can no longer pick the same seq — the second statement reads the // first's already-inserted row. // // The caller supplies the id (must be a UUID that's also used as the // agentctl PTY id). initialCommand is "" for plain shells. func (r *Repository) Create(ctx context.Context, taskID, envID, id, initialCommand string) (*models.Terminal, error) { if _, err := r.db.ExecContext(ctx, `INSERT INTO user_terminals (id, task_id, environment_id, seq, custom_name, state, initial_command) SELECT ?, ?, ?, COALESCE(MAX(seq), 0) + 1, NULL, 'open', ? FROM user_terminals WHERE task_id = ?`, id, taskID, envID, initialCommand, taskID, ); err != nil { return nil, fmt.Errorf("insert terminal: %w", err) } return r.Get(ctx, id) } // Get returns the terminal by id, or ErrNotFound. func (r *Repository) Get(ctx context.Context, id string) (*models.Terminal, error) { var t models.Terminal err := r.ro.GetContext(ctx, &t, `SELECT id, task_id, environment_id, seq, custom_name, state, initial_command, created_at FROM user_terminals WHERE id = ?`, id, ) if errors.Is(err, sql.ErrNoRows) { return nil, ErrNotFound } if err != nil { return nil, fmt.Errorf("get terminal: %w", err) } return &t, nil } // ListByTask returns terminals for taskID ordered by seq ascending. // includeParked controls whether parked rows are included. func (r *Repository) ListByTask(ctx context.Context, taskID string, includeParked bool) ([]*models.Terminal, error) { q := `SELECT id, task_id, environment_id, seq, custom_name, state, initial_command, created_at FROM user_terminals WHERE task_id = ?` args := []any{taskID} if !includeParked { q += ` AND state = 'open'` } q += ` ORDER BY seq ASC` var rows []*models.Terminal if err := r.ro.SelectContext(ctx, &rows, q, args...); err != nil { return nil, fmt.Errorf("list terminals: %w", err) } return rows, nil } // Rename sets or clears the custom_name. Pass nil to clear, a non-empty // string to set. func (r *Repository) Rename(ctx context.Context, id string, name *string) error { var nameArg any if name == nil { nameArg = nil } else { nameArg = *name } res, err := r.db.ExecContext(ctx, `UPDATE user_terminals SET custom_name = ? WHERE id = ?`, nameArg, id, ) if err != nil { return fmt.Errorf("rename terminal: %w", err) } n, _ := res.RowsAffected() if n == 0 { return ErrNotFound } return nil } // SetState updates the open/parked state. Does not touch any PTY — that's // the service's job. func (r *Repository) SetState(ctx context.Context, id string, state models.TerminalState) error { res, err := r.db.ExecContext(ctx, `UPDATE user_terminals SET state = ? WHERE id = ?`, string(state), id, ) if err != nil { return fmt.Errorf("set state: %w", err) } n, _ := res.RowsAffected() if n == 0 { return ErrNotFound } return nil } // Delete removes a single terminal row. func (r *Repository) Delete(ctx context.Context, id string) error { _, err := r.db.ExecContext(ctx, `DELETE FROM user_terminals WHERE id = ?`, id) if err != nil { return fmt.Errorf("delete terminal: %w", err) } return nil } // DeleteByTask removes every row for a task and returns the count. Used by // the task.deleted cascade subscriber. func (r *Repository) DeleteByTask(ctx context.Context, taskID string) (int, error) { res, err := r.db.ExecContext(ctx, `DELETE FROM user_terminals WHERE task_id = ?`, taskID) if err != nil { return 0, fmt.Errorf("delete by task: %w", err) } n, _ := res.RowsAffected() return int(n), nil }