Add service status and usage dashboard, refresh externally published edits
This commit is contained in:
@@ -127,7 +127,13 @@ From a run, press **p** / **:pipeline** to open the pipeline version it used.
|
||||
Initial run input also records `pwd`. Press **r** / **:retry** on a failed run
|
||||
(or `pipelines retry <run-id>`) to start a new attempt with the same original
|
||||
input, directory, and pipeline version. Completed side effects are not undone.
|
||||
On Home, **r** opens the failed-only runs list; both Home panels show the shortcut.
|
||||
On Home, **r** opens all recent runs; both Home panels show the shortcut.
|
||||
Wide terminals show runs and pipelines side by side; narrow terminals stack them.
|
||||
The dashboard includes all-history usage, success rate, average completed duration,
|
||||
per-pipeline usage, and a 14-day activity chart. CLI: `pipelines stats [--json]`.
|
||||
Use **:status** for a scrollable server/ntfy popup with health, ports, server-computer
|
||||
IPs and candidate URLs. CLI: `pipelines status [--json]`. Candidate URLs are not
|
||||
verified reachable; publishing endpoints and credentials are not disclosed.
|
||||
Retry is offered only after the failed run and its agent have fully stopped.
|
||||
The run inspector shows its actual path above the details, using the same graph
|
||||
renderer as pipeline definitions. **g** focuses the graph (arrows pan, j/k scroll).
|
||||
|
||||
+40
-2
@@ -8,6 +8,34 @@ service manager directly. Legacy Python-managed installations require an explici
|
||||
For source development, use `go run ./cmd/pipelines help`; start the native server
|
||||
separately. Set `PIPELINES_URL` or pass `--url` to select another server.
|
||||
|
||||
## Dashboard and status
|
||||
|
||||
Home's `r` opens **all** recent runs (latest 50), not only failures. Wide terminals
|
||||
show runs and pipelines side by side, with stacked panels on narrow terminals.
|
||||
Run cards show status, duration, start time and the current stage when active.
|
||||
The usage summary is aggregated over all stored history, including retry attempts:
|
||||
total/active runs, outcomes, success rate, average completed duration, pipeline
|
||||
usage and a zero-filled 14-day daily activity chart (UTC). Success rate is
|
||||
succeeded / (succeeded + failed); active, canceled and interrupted runs are excluded.
|
||||
The average includes all runs with a finish timestamp. No model cost/token counts
|
||||
are inferred from missing data. `pipelines stats --json` exposes these aggregates.
|
||||
|
||||
Use `:status` on any TUI page to open server and ntfy information. Scroll with
|
||||
arrows or `j/k`, PgUp/PgDn; `r` refreshes and Esc closes without changing the page.
|
||||
`pipelines status [--json]` returns the same server data, including hostname,
|
||||
start/uptime, the connected server endpoint/port, active interface IPs, ntfy
|
||||
publishing health, public phone URL/topic/port and candidate URLs. It does not
|
||||
start services or send a notification. The ntfy health probe has a two-second
|
||||
deadline; it checks the publishing server, not phone reachability.
|
||||
|
||||
IPs belong to the **server computer or container**, not necessarily the client.
|
||||
Candidate IP/port combinations are not reachability checks: loopback bindings,
|
||||
firewalls, container port mapping and TLS can prevent access. ntfy candidates
|
||||
are only derived when a configured endpoint identifies this computer; remote
|
||||
ntfy hosts are not misrepresented as local. Publishing URLs and credentials are
|
||||
never returned. Missing public phone configuration is labeled explicitly.
|
||||
`pipelines service status` remains the separate OS autostart status command.
|
||||
|
||||
## Draft-first OpenCode workflow
|
||||
|
||||
```sh
|
||||
@@ -42,6 +70,13 @@ the existing draft, `v` for server validation, and `s` for submission confirmati
|
||||
`r` refreshes the list. Submission preserves create-only/version guards and rejects
|
||||
drafts belonging to another server. An unnamed draft must be named through OpenCode
|
||||
or CLI `submit --name`. Draft selection/editor completion never publishes it.
|
||||
On editor exit, the connected TUI checks the authoritative server before asking
|
||||
to submit. If the draft source is already published (including a newer version
|
||||
after the draft's base that was subsequently superseded), it skips confirmation
|
||||
and reloads the latest pipeline/page and Home list. Local-only changes still need
|
||||
explicit submission. A failed check retains the draft and says publication could
|
||||
not be verified; it never assumes publication from an editor's exit code. Original
|
||||
draft conflict guards and retained draft files remain unchanged.
|
||||
New unnamed drafts open OpenCode so the skill can name them. For named drafts,
|
||||
the default editor is OpenCode; explicit `VISUAL`/`EDITOR` overrides remain.
|
||||
|
||||
@@ -81,7 +116,9 @@ Submitting activates included schedules, so review them before publishing.
|
||||
| Run history/inspection | `runs --json`, `inspect ID --json` |
|
||||
| Cancel | `cancel ID --json` |
|
||||
| Connection and phone settings | `connection --json`, `ping --json` |
|
||||
| Operational diagnostics | installed `logs`, `status`, `doctor` |
|
||||
| Server/ntfy status popup | `status --json` |
|
||||
| Usage statistics/charts | `stats --json` |
|
||||
| Legacy operational diagnostics | managed `logs`, `doctor` |
|
||||
|
||||
The TUI does not spawn CLI processes for each request. Both front ends share
|
||||
`internal/client`'s command transport and `internal/draft`'s persisted drafts;
|
||||
@@ -94,7 +131,8 @@ printf '%s' '{"type":"get_pipeline","pipeline_id":1,"version":1}' | pipelines rp
|
||||
|
||||
Existing protocol commands: `ping`, `list_pipelines`, `get_pipeline`,
|
||||
`list_templates`, `validate`, `submit`, `run_pipeline`, `list_runs`, `get_run`,
|
||||
`cancel_run`, `retry_run`. See `internal/protocol/message.go` for JSON envelopes. Mutating RPCs
|
||||
`cancel_run`, `retry_run`, `get_status`. `list_runs` also returns all-history `usage`
|
||||
aggregates. See `internal/protocol/message.go` for JSON envelopes. Mutating RPCs
|
||||
have real effects; they are not previews. TUI-only animation, scrolling, and
|
||||
transient client logs are presentation, not separate server capabilities.
|
||||
|
||||
|
||||
@@ -85,3 +85,22 @@ and optional file/command permission rules. A native stable no-inference live
|
||||
contract test accepted a `json_schema` message with `retryCount=0` and `noReply`.
|
||||
Real model-driven schema generation, formatter behavior and tool-permission
|
||||
enforcement remain **not tested**.
|
||||
|
||||
Status/dashboard checks execute server and fake ntfy HTTP health endpoints,
|
||||
CLI JSON/plain status and statistics, all-history SQL aggregation with more than
|
||||
50 runs, interrupted/unused pipeline counts, zero-filled daily activity, responsive
|
||||
dashboard columns, and status popup navigation from a run without losing its
|
||||
selection. Compiled-binary PTY integration also exercises `pipelines status`,
|
||||
`pipelines stats`, `:status`, dashboard activity and Home's all-runs `r` shortcut.
|
||||
Candidate URL reachability and phone reception are **not tested** and are not
|
||||
reported as verified by the UI.
|
||||
|
||||
Editor-return checks query actual published history before showing confirmation;
|
||||
tests cover a submitted draft followed by a newer publication, unsent edits,
|
||||
failed/stale verification, and immutable history. Compiled CLI/TUI PTY integration
|
||||
uses a mock OpenCode editor that submits with the real CLI, then verifies automatic
|
||||
reload to version 2 without another submission prompt. Another mock editor only
|
||||
saves changes and still requires confirmation. A real local V2 no-inference
|
||||
create/wait/delete contract succeeded; the reported remote planner `/wait` failure
|
||||
could not be reproduced here. Safe CLI failure classification/exit-code reporting
|
||||
was executed with a failing subprocess fixture.
|
||||
|
||||
@@ -41,6 +41,12 @@ Repair records include the original/candidate response, parsing diagnostic,
|
||||
method and acceptance flag in the bounded transcript preview. `pipelines
|
||||
inspect <run-id> --json` and the TUI evidence section expose these records.
|
||||
|
||||
OpenCode CLI failures include the HTTP status when supplied, process exit code,
|
||||
and a recognized safe error category (such as session not found or service
|
||||
unavailable). Arbitrary stderr, provider messages and response bodies are not
|
||||
copied into the diagnostic. A `/wait` command failure is not evidence that the
|
||||
agent prompt failed to start, and does not trigger replay of stage work.
|
||||
|
||||
## Optional machine-readable restrictions
|
||||
|
||||
`tools` enables actions per stage. A stage can narrow edit paths and shell
|
||||
|
||||
@@ -19,6 +19,7 @@ import (
|
||||
"git.a-wan.net/alan/pipelines/internal/pipeline"
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
"git.a-wan.net/alan/pipelines/internal/runinspect"
|
||||
"git.a-wan.net/alan/pipelines/internal/statusview"
|
||||
"git.a-wan.net/alan/pipelines/internal/tui"
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
)
|
||||
@@ -238,6 +239,17 @@ func (a App) Run(ctx context.Context, args []string) error {
|
||||
c, err := client.Open(dialCtx, o.url)
|
||||
cancel()
|
||||
if err != nil {
|
||||
if command == "status" && len(pos) == 0 {
|
||||
s := statusview.Offline(o.url)
|
||||
if o.json {
|
||||
if outputErr := a.output(s); outputErr != nil {
|
||||
return outputErr
|
||||
}
|
||||
} else {
|
||||
fmt.Fprintln(a.Out, strings.Join(statusview.Lines(s), "\n"))
|
||||
}
|
||||
return fmt.Errorf("Pipelines server unavailable")
|
||||
}
|
||||
return err
|
||||
}
|
||||
defer c.Close()
|
||||
@@ -272,6 +284,50 @@ func (a App) Run(ctx context.Context, args []string) error {
|
||||
return pos[0], nil
|
||||
}
|
||||
switch command {
|
||||
case "stats":
|
||||
if len(pos) != 0 {
|
||||
return fmt.Errorf("stats takes no arguments")
|
||||
}
|
||||
response, err := call(protocol.Message{Type: protocol.ListRuns})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if response.Usage == nil {
|
||||
return fmt.Errorf("server did not return usage statistics; update pipelines-server")
|
||||
}
|
||||
if o.json {
|
||||
return a.output(response.Usage)
|
||||
}
|
||||
u := response.Usage
|
||||
average := "—"
|
||||
if u.Total > u.Active {
|
||||
average = time.Duration(u.AverageSeconds * float64(time.Second)).Round(time.Second).String()
|
||||
}
|
||||
fmt.Fprintf(a.Out, "Usage · all history\n%d runs · %d succeeded · %d failed · %d canceled · %d interrupted · %d active\nAverage completed duration: %s\n\nPipeline\tRuns\tSucceeded\tFailed\tActive\n", u.Total, u.Succeeded, u.Failed, u.Canceled, u.Interrupted, u.Active, average)
|
||||
for _, p := range u.Pipelines {
|
||||
fmt.Fprintf(a.Out, "%s\t%d\t%d\t%d\t%d\n", p.Name, p.Total, p.Succeeded, p.Failed, p.Active)
|
||||
}
|
||||
fmt.Fprintln(a.Out, "\nDaily activity (UTC)")
|
||||
for _, d := range u.Days {
|
||||
fmt.Fprintf(a.Out, "%s\t%d\n", d.Date, d.Runs)
|
||||
}
|
||||
return nil
|
||||
case "status":
|
||||
if len(pos) != 0 {
|
||||
return fmt.Errorf("status takes no arguments")
|
||||
}
|
||||
response, err := call(protocol.Message{Type: protocol.GetStatus})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if response.Status == nil {
|
||||
return fmt.Errorf("server did not return status; update pipelines-server")
|
||||
}
|
||||
if o.json {
|
||||
return a.output(response.Status)
|
||||
}
|
||||
_, err = fmt.Fprintln(a.Out, strings.Join(statusview.Lines(response.Status), "\n"))
|
||||
return err
|
||||
case "debug":
|
||||
value, err := one()
|
||||
if err != nil {
|
||||
|
||||
@@ -53,6 +53,39 @@ func TestCLIHelpDoesNotNeedServer(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestCLIStatusAndStatistics(t *testing.T) {
|
||||
t.Setenv("PIPELINES_NTFY_URL", "")
|
||||
run, _, _ := setup(t)
|
||||
output, err := run("status")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, text := range []string{"Pipelines server", "ntfy", "not configured", "Server computer IPs", "Port:"} {
|
||||
if !strings.Contains(output, text) {
|
||||
t.Fatal("missing CLI status", text, output)
|
||||
}
|
||||
}
|
||||
output, err = run("status", "--json")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var status protocol.SystemStatus
|
||||
if err := json.Unmarshal([]byte(output), &status); err != nil || status.Server.Health != "healthy" || status.Server.Port == "" {
|
||||
t.Fatal(output, err)
|
||||
}
|
||||
output, err = run("stats", "--json")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var usage protocol.UsageStats
|
||||
if err := json.Unmarshal([]byte(output), &usage); err != nil || usage.Total != 0 || len(usage.Days) != 14 {
|
||||
t.Fatal(output, err)
|
||||
}
|
||||
if _, err := run("status", "extra"); err == nil {
|
||||
t.Fatal("status accepted extra positional")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCLIDraftValidateSubmitAndImmutableHistory(t *testing.T) {
|
||||
run, store, _ := setup(t)
|
||||
output, err := run("new", "example", "--template", "bug-fix", "--json")
|
||||
|
||||
@@ -22,6 +22,8 @@ var usage = map[string]string{
|
||||
"debug": "debug <run-id> [--json | --no-open]",
|
||||
"connection": "connection [--json]",
|
||||
"ping": "ping [--json]",
|
||||
"status": "status [--json]",
|
||||
"stats": "stats [--json]",
|
||||
"rpc": "rpc <request.json|->",
|
||||
"tui": "tui",
|
||||
}
|
||||
@@ -44,7 +46,6 @@ var serviceHelp = map[string]string{
|
||||
"start": "Start the per-user native pipeline server and this installation's Docker ntfy together.",
|
||||
"stop": "Stop both services. Active execution is interrupted; file changes are not rolled back.",
|
||||
"restart": "Stop, then start both services, retaining definitions, run history, and credentials.",
|
||||
"status": "Show pipeline/ntfy health and the public phone connection (no credentials).",
|
||||
"doctor": "Check both health endpoints and host OpenCode API discovery; does not execute a model.",
|
||||
"logs": "Follow the native server log. Press Ctrl+C to stop following.",
|
||||
"uninstall": "Remove verified Go binaries from this command's bin directory; retain data and drafts. --yes skips confirmation. Existing managed installations can be selected explicitly with PIPELINES_PREFIX.",
|
||||
|
||||
@@ -28,6 +28,8 @@ EXECUTE
|
||||
debug <run-id> Ask OpenCode questions about a recorded or active run
|
||||
draft-delete <draft.md> Delete a selected retained draft and its metadata
|
||||
connection Server and public phone connection (no secrets)
|
||||
status Server/ntfy health, ports and server computer IPs
|
||||
stats All-history usage, pipeline counts and daily activity
|
||||
ping Check the server connection
|
||||
rpc <request.json|-> Send any protocol command (automation escape hatch)
|
||||
|
||||
@@ -40,7 +42,7 @@ SERVER / INTERFACE
|
||||
uninstall [--yes] Remove verified Go binaries; retain data and drafts
|
||||
|
||||
Legacy managed installs: select PIPELINES_PREFIX explicitly for start/stop,
|
||||
restart/status/doctor/logs and retained-data or --purge uninstallation.
|
||||
restart/doctor/logs and retained-data or --purge uninstallation.
|
||||
|
||||
Options: --url ws://127.0.0.1:8080/connect --json --help
|
||||
Use pipelines help <command> for its flags. Names with spaces must be quoted.
|
||||
|
||||
@@ -68,7 +68,7 @@ func (c Config) Environment() error {
|
||||
|
||||
func Service(action string) bool {
|
||||
switch action {
|
||||
case "start", "stop", "restart", "status", "doctor", "logs", "uninstall":
|
||||
case "start", "stop", "restart", "doctor", "logs", "uninstall":
|
||||
return true
|
||||
}
|
||||
return false
|
||||
|
||||
@@ -0,0 +1,57 @@
|
||||
package pipeline
|
||||
|
||||
import (
|
||||
"context"
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
)
|
||||
|
||||
const countsSQL = `COUNT(r.id),COALESCE(SUM(r.status='succeeded'),0),COALESCE(SUM(r.status='failed'),0),COALESCE(SUM(r.status='canceled'),0),COALESCE(SUM(r.status='interrupted'),0),COALESCE(SUM(r.status IN ('queued','running')),0),COALESCE(AVG(CASE WHEN r.finished_at IS NOT NULL THEN MAX(0,(julianday(r.finished_at)-julianday(r.created_at))*86400) END),0)`
|
||||
|
||||
func (s *Store) UsageStats(ctx context.Context) (*protocol.UsageStats, error) {
|
||||
tx, err := s.db.BeginTx(ctx, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer tx.Rollback()
|
||||
stats := &protocol.UsageStats{Pipelines: []protocol.PipelineUsage{}, Days: []protocol.DailyUsage{}}
|
||||
c := &stats.RunCounts
|
||||
if err := tx.QueryRowContext(ctx, "SELECT "+countsSQL+" FROM pipeline_runs r").Scan(&c.Total, &c.Succeeded, &c.Failed, &c.Canceled, &c.Interrupted, &c.Active, &c.AverageSeconds); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
rows, err := tx.QueryContext(ctx, "SELECT p.id,p.name,"+countsSQL+" FROM pipelines p LEFT JOIN pipeline_runs r ON r.pipeline_id=p.id GROUP BY p.id ORDER BY COUNT(r.id) DESC,p.name")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for rows.Next() {
|
||||
var p protocol.PipelineUsage
|
||||
c := &p.RunCounts
|
||||
if err := rows.Scan(&p.PipelineID, &p.Name, &c.Total, &c.Succeeded, &c.Failed, &c.Canceled, &c.Interrupted, &c.Active, &c.AverageSeconds); err != nil {
|
||||
rows.Close()
|
||||
return nil, err
|
||||
}
|
||||
stats.Pipelines = append(stats.Pipelines, p)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
rows.Close()
|
||||
return nil, err
|
||||
}
|
||||
rows.Close()
|
||||
rows, err = tx.QueryContext(ctx, `WITH RECURSIVE days(day) AS (SELECT date('now','-13 days') UNION ALL SELECT date(day,'+1 day') FROM days WHERE day<date('now')) SELECT day,COUNT(r.id) FROM days LEFT JOIN pipeline_runs r ON r.created_at>=day AND r.created_at<date(day,'+1 day') GROUP BY day ORDER BY day`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for rows.Next() {
|
||||
var d protocol.DailyUsage
|
||||
if err := rows.Scan(&d.Date, &d.Runs); err != nil {
|
||||
rows.Close()
|
||||
return nil, err
|
||||
}
|
||||
stats.Days = append(stats.Days, d)
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
rows.Close()
|
||||
return nil, err
|
||||
}
|
||||
rows.Close()
|
||||
return stats, tx.Commit()
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
package pipeline
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"math"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestUsageStatsCountAllHistoryAndZeroFillDailyActivity(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
store, err := Open(filepath.Join(t.TempDir(), "stats.db"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer store.Close()
|
||||
stats, err := store.UsageStats(ctx)
|
||||
if err != nil || stats.Total != 0 || len(stats.Days) != 14 || len(stats.Pipelines) != 0 {
|
||||
t.Fatal("empty statistics", stats, err)
|
||||
}
|
||||
source := "# stage worker\n```output\nOutput map.\n```\n```prompt\nTask\n```\n```configs\nprovider=opencode-go\nmodel=deepseek-v4.1-flash\nretries=0\n```\n```edges\nsuccess -> #success\nerror -> #failure\n```\n"
|
||||
if _, err := store.Submit(ctx, "busy", source); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := store.Submit(ctx, "unused", source); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
items, err := store.List(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var id int64
|
||||
for _, p := range items {
|
||||
if p.Name == "busy" {
|
||||
id = p.ID
|
||||
}
|
||||
}
|
||||
d, err := store.Get(ctx, id, 0)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for i := 0; i < 60; i++ {
|
||||
run, _, err := store.CreateRun(ctx, d, fmt.Sprintf("key-%d", i), "/repo", false, nil, nil)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
status := "succeeded"
|
||||
if i == 0 {
|
||||
status = "failed"
|
||||
}
|
||||
if i == 1 {
|
||||
status = "canceled"
|
||||
}
|
||||
if i == 2 {
|
||||
status = "running"
|
||||
}
|
||||
if i == 3 {
|
||||
status = "interrupted"
|
||||
}
|
||||
_, err = store.db.ExecContext(ctx, `UPDATE pipeline_runs SET status=?,created_at=datetime('now','-60 seconds'),finished_at=CASE WHEN ?='running' THEN NULL ELSE datetime('now') END WHERE id=?`, status, status, run)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
stats, err = store.UsageStats(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if stats.Total != 60 || stats.Succeeded != 56 || stats.Failed != 1 || stats.Canceled != 1 || stats.Interrupted != 1 || stats.Active != 1 || math.Abs(stats.AverageSeconds-60) > .01 {
|
||||
t.Fatal("incorrect all-history aggregation", stats)
|
||||
}
|
||||
if len(stats.Pipelines) != 2 || stats.Pipelines[0].Total != 60 || stats.Pipelines[1].Total != 0 {
|
||||
t.Fatal("missing unused pipeline or per-pipeline usage", stats.Pipelines)
|
||||
}
|
||||
total := 0
|
||||
for _, day := range stats.Days {
|
||||
total += day.Runs
|
||||
}
|
||||
if total != 60 {
|
||||
t.Fatal("daily totals", stats.Days)
|
||||
}
|
||||
latest, err := store.ListRuns(ctx)
|
||||
if err != nil || len(latest) != 50 {
|
||||
t.Fatal("fixture must exceed latest-runs cap", latest, err)
|
||||
}
|
||||
}
|
||||
@@ -94,6 +94,8 @@ type PipelineSummary struct {
|
||||
|
||||
// Message is the JSON envelope shared by the server and client.
|
||||
type Message struct {
|
||||
Usage *UsageStats `json:"usage,omitempty"`
|
||||
Status *SystemStatus `json:"status,omitempty"`
|
||||
Graph *Graph `json:"graph,omitempty"`
|
||||
ExpectedVersion int `json:"expected_version,omitempty"`
|
||||
Templates []Template `json:"templates,omitempty"`
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
package protocol
|
||||
|
||||
type RunCounts struct {
|
||||
Total int `json:"total"`
|
||||
Succeeded int `json:"succeeded"`
|
||||
Failed int `json:"failed"`
|
||||
Canceled int `json:"canceled"`
|
||||
Interrupted int `json:"interrupted"`
|
||||
Active int `json:"active"`
|
||||
AverageSeconds float64 `json:"average_seconds"`
|
||||
}
|
||||
type PipelineUsage struct {
|
||||
PipelineID int64 `json:"pipeline_id"`
|
||||
Name string `json:"name"`
|
||||
RunCounts
|
||||
}
|
||||
type DailyUsage struct {
|
||||
Date string `json:"date"`
|
||||
Runs int `json:"runs"`
|
||||
}
|
||||
type UsageStats struct {
|
||||
RunCounts
|
||||
Pipelines []PipelineUsage `json:"pipelines"`
|
||||
Days []DailyUsage `json:"days"`
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
package protocol
|
||||
|
||||
const GetStatus = "get_status"
|
||||
const Status = "status"
|
||||
|
||||
type NetworkAddress struct {
|
||||
Interface string `json:"interface"`
|
||||
IP string `json:"ip"`
|
||||
}
|
||||
|
||||
type ServiceStatus struct {
|
||||
Health string `json:"health"`
|
||||
URL string `json:"url,omitempty"`
|
||||
Port string `json:"port,omitempty"`
|
||||
Candidates []string `json:"candidate_urls,omitempty"`
|
||||
}
|
||||
|
||||
type SystemStatus struct {
|
||||
Hostname string `json:"hostname"`
|
||||
StartedAt string `json:"started_at"`
|
||||
Uptime string `json:"uptime"`
|
||||
Addresses []NetworkAddress `json:"addresses"`
|
||||
Server ServiceStatus `json:"server"`
|
||||
Ntfy ServiceStatus `json:"ntfy"`
|
||||
Topic string `json:"topic,omitempty"`
|
||||
Note string `json:"note"`
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
"sort"
|
||||
"time"
|
||||
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
)
|
||||
|
||||
func networkAddresses() []protocol.NetworkAddress {
|
||||
result := []protocol.NetworkAddress{}
|
||||
interfaces, _ := net.Interfaces()
|
||||
for _, iface := range interfaces {
|
||||
if iface.Flags&net.FlagUp == 0 {
|
||||
continue
|
||||
}
|
||||
addresses, _ := iface.Addrs()
|
||||
for _, address := range addresses {
|
||||
ip, _, err := net.ParseCIDR(address.String())
|
||||
if err != nil || ip.IsUnspecified() {
|
||||
continue
|
||||
}
|
||||
text := ip.String()
|
||||
if ip.IsLinkLocalUnicast() && ip.To4() == nil {
|
||||
text += "%" + iface.Name
|
||||
}
|
||||
result = append(result, protocol.NetworkAddress{Interface: iface.Name, IP: text})
|
||||
}
|
||||
}
|
||||
sort.Slice(result, func(i, j int) bool {
|
||||
if result[i].Interface != result[j].Interface {
|
||||
return result[i].Interface < result[j].Interface
|
||||
}
|
||||
return result[i].IP < result[j].IP
|
||||
})
|
||||
return result
|
||||
}
|
||||
|
||||
func endpointPort(u *url.URL) string {
|
||||
if port := u.Port(); port != "" {
|
||||
return port
|
||||
}
|
||||
if u.Scheme == "https" || u.Scheme == "wss" {
|
||||
return "443"
|
||||
}
|
||||
return "80"
|
||||
}
|
||||
|
||||
func candidateURLs(addresses []protocol.NetworkAddress, scheme, port, path string) []string {
|
||||
result := []string{}
|
||||
for _, address := range addresses {
|
||||
u := url.URL{Scheme: scheme, Host: net.JoinHostPort(address.IP, port), Path: path}
|
||||
result = append(result, u.String())
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func localEndpoint(u *url.URL, hostname string, addresses []protocol.NetworkAddress) bool {
|
||||
host := u.Hostname()
|
||||
if host == "localhost" || host == hostname || net.ParseIP(host).IsLoopback() {
|
||||
return true
|
||||
}
|
||||
for _, address := range addresses {
|
||||
if host == address.IP {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func systemStatus(r *http.Request, started time.Time, runErr error) *protocol.SystemStatus {
|
||||
hostname, _ := os.Hostname()
|
||||
s := &protocol.SystemStatus{Hostname: hostname, StartedAt: started.UTC().Format(time.RFC3339), Uptime: time.Since(started).Round(time.Second).String(), Addresses: networkAddresses(), Server: protocol.ServiceStatus{Health: "healthy"}, Ntfy: protocol.ServiceStatus{Health: "not configured"}, Note: "Addresses belong to the server computer (or container). Candidate URLs are not reachability checks; binding, firewalls, port mapping and TLS may differ."}
|
||||
if runErr != nil {
|
||||
s.Server.Health = "execution unavailable"
|
||||
}
|
||||
if address, ok := r.Context().Value(http.LocalAddrContextKey).(net.Addr); ok {
|
||||
_, port, err := net.SplitHostPort(address.String())
|
||||
if err == nil {
|
||||
scheme := "ws"
|
||||
if r.TLS != nil {
|
||||
scheme = "wss"
|
||||
}
|
||||
s.Server.URL = (&url.URL{Scheme: scheme, Host: address.String(), Path: "/connect"}).String()
|
||||
s.Server.Port = port
|
||||
s.Server.Candidates = candidateURLs(s.Addresses, scheme, port, "/connect")
|
||||
}
|
||||
}
|
||||
endpoints := notificationEndpoints()
|
||||
if len(endpoints) == 0 {
|
||||
return s
|
||||
}
|
||||
s.Topic = endpoints[0].Topic
|
||||
s.Ntfy.Health = "not checked"
|
||||
// Only the validated public base is returned. Publishing URL and tokens
|
||||
// never leave the server, even on probe failure.
|
||||
s.Ntfy.URL = endpoints[0].ServerURL
|
||||
if u, err := url.Parse(s.Ntfy.URL); err == nil && u.Host != "" {
|
||||
s.Ntfy.Port = endpointPort(u)
|
||||
if localEndpoint(u, hostname, s.Addresses) {
|
||||
s.Ntfy.Candidates = candidateURLs(s.Addresses, u.Scheme, s.Ntfy.Port, "/"+s.Topic)
|
||||
}
|
||||
}
|
||||
publish, err := url.Parse(os.Getenv("PIPELINES_NTFY_URL"))
|
||||
if err != nil {
|
||||
return s
|
||||
}
|
||||
if s.Ntfy.URL == "" && localEndpoint(publish, hostname, s.Addresses) {
|
||||
s.Ntfy.Port = endpointPort(publish)
|
||||
s.Ntfy.Candidates = candidateURLs(s.Addresses, publish.Scheme, s.Ntfy.Port, "/"+s.Topic)
|
||||
}
|
||||
publish.Path = "/v1/health"
|
||||
publish.RawPath = ""
|
||||
publish.RawQuery = ""
|
||||
publish.Fragment = ""
|
||||
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
|
||||
defer cancel()
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, publish.String(), nil)
|
||||
if err != nil {
|
||||
return s
|
||||
}
|
||||
client := &http.Client{CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
|
||||
response, err := client.Do(req)
|
||||
s.Ntfy.Health = "unreachable"
|
||||
if err != nil {
|
||||
return s
|
||||
}
|
||||
defer response.Body.Close()
|
||||
s.Ntfy.Health = "unhealthy"
|
||||
var health struct {
|
||||
Healthy bool `json:"healthy"`
|
||||
}
|
||||
if response.StatusCode == http.StatusOK && json.NewDecoder(io.LimitReader(response.Body, 4096)).Decode(&health) == nil && health.Healthy {
|
||||
s.Ntfy.Health = "healthy"
|
||||
}
|
||||
return s
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"git.a-wan.net/alan/pipelines/internal/client"
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestStatusRPCReportsServerAndNtfyWithoutSecrets(t *testing.T) {
|
||||
ntfy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.URL.Path != "/v1/health" {
|
||||
t.Error("unexpected probe", r.URL.Path)
|
||||
}
|
||||
w.Write([]byte(`{"healthy":true}`))
|
||||
}))
|
||||
defer ntfy.Close()
|
||||
t.Setenv("PIPELINES_NTFY_URL", ntfy.URL+"/phone")
|
||||
t.Setenv("PIPELINES_NTFY_PUBLIC_URL", ntfy.URL)
|
||||
t.Setenv("PIPELINES_NTFY_TOKEN", "never-return-this-token")
|
||||
srv := httptest.NewServer(Handler(context.Background()))
|
||||
defer srv.Close()
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
c, err := client.Open(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer c.Close()
|
||||
response, err := c.Call(ctx, protocol.Message{Type: protocol.GetStatus})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
s := response.Status
|
||||
if s == nil || s.Server.Health != "healthy" || s.Ntfy.Health != "healthy" || s.Ntfy.URL != ntfy.URL || s.Topic != "phone" || len(s.Addresses) == 0 || s.Hostname == "" || s.Server.Port == "" || s.Ntfy.Port == "" || s.StartedAt == "" || len(s.Ntfy.Candidates) == 0 {
|
||||
t.Fatal("incomplete status", s)
|
||||
}
|
||||
encoded, _ := json.Marshal(s)
|
||||
if strings.Contains(string(encoded), "never-return") {
|
||||
t.Fatal("credentials leaked", string(encoded))
|
||||
}
|
||||
if !strings.Contains(s.Server.URL, s.Server.Port) || !strings.Contains(s.Note, "not reachability checks") {
|
||||
t.Fatal("ports or safety disclaimer missing", s)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStatusUnconfiguredUnhealthyAndIPv6Candidates(t *testing.T) {
|
||||
t.Setenv("PIPELINES_NTFY_URL", "")
|
||||
t.Setenv("PIPELINES_NTFY_PUBLIC_URL", "")
|
||||
r := httptest.NewRequest("GET", "http://localhost/connect", nil)
|
||||
if s := systemStatus(r, time.Now(), nil); s.Ntfy.Health != "not configured" {
|
||||
t.Fatal(s)
|
||||
}
|
||||
for _, body := range []string{`{"healthy":false}`, `not-json`} {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Write([]byte(body)) }))
|
||||
t.Setenv("PIPELINES_NTFY_URL", srv.URL+"/topic")
|
||||
s := systemStatus(r, time.Now(), nil)
|
||||
srv.Close()
|
||||
if s.Ntfy.Health != "unhealthy" || s.Ntfy.URL != "" || s.Ntfy.Port == "" {
|
||||
t.Fatal(s)
|
||||
}
|
||||
}
|
||||
addresses := []protocol.NetworkAddress{{Interface: "test", IP: "::1"}, {Interface: "test", IP: "192.0.2.1"}}
|
||||
urls := candidateURLs(addresses, "http", "8090", "/topic")
|
||||
if urls[0] != "http://[::1]:8090/topic" || urls[1] != "http://192.0.2.1:8090/topic" {
|
||||
t.Fatal(urls)
|
||||
}
|
||||
if localEndpoint(&url.URL{Host: "remote.example:8090", Scheme: "http"}, "test", addresses) {
|
||||
t.Fatal("remote endpoint guessed local")
|
||||
}
|
||||
}
|
||||
@@ -17,6 +17,7 @@ import (
|
||||
|
||||
// Handler serves the persistent connection. Canceling ctx stops active clients.
|
||||
func Handler(ctx context.Context, stores ...*pipeline.Store) http.Handler {
|
||||
started := time.Now()
|
||||
mux := http.NewServeMux()
|
||||
var runs *runner
|
||||
var runErr error
|
||||
@@ -66,7 +67,10 @@ func Handler(ctx context.Context, stores ...*pipeline.Store) http.Handler {
|
||||
if request.Type == protocol.List || request.Type == protocol.Submit {
|
||||
response.NotificationEndpoints = notificationEndpoints()
|
||||
}
|
||||
if request.Type == protocol.Ping {
|
||||
if request.Type == protocol.GetStatus {
|
||||
response.Type = protocol.Status
|
||||
response.Status = systemStatus(r, started, runErr)
|
||||
} else if request.Type == protocol.Ping {
|
||||
response.Time = time.Now().UTC().Format(time.RFC3339)
|
||||
} else if request.Type == protocol.ListTemplates {
|
||||
response.Type = protocol.Templates
|
||||
@@ -133,6 +137,9 @@ func Handler(ctx context.Context, stores ...*pipeline.Store) http.Handler {
|
||||
case protocol.ListRuns:
|
||||
response.Type = protocol.Runs
|
||||
response.Runs, err = runs.listRuns()
|
||||
if err == nil {
|
||||
response.Usage, err = stores[0].UsageStats(ctx)
|
||||
}
|
||||
case protocol.GetRun:
|
||||
response.Type = protocol.Run
|
||||
response.RunDetail, err = runs.getRun(request.RunID)
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
package stage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestActualCLIErrorReportsSafeClassificationAndExitCode(t *testing.T) {
|
||||
path := filepath.Join(t.TempDir(), "opencode")
|
||||
script := `#!/bin/sh
|
||||
echo '{"_tag":"SessionNotFoundError","message":"secret credential and private project data"}'
|
||||
echo 'HTTP 404 Not Found; secret stderr' >&2
|
||||
exit 7
|
||||
`
|
||||
if err := os.WriteFile(path, []byte(script), 0700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Setenv("PIPELINES_OPENCODE", path)
|
||||
_, err := (OpenCodeClient{Directory: t.TempDir()}).call(context.Background(), "post", "/api/experimental/session/ses_test/wait", nil)
|
||||
if err == nil || !strings.Contains(err.Error(), "HTTP 404") || !strings.Contains(err.Error(), "CLI exit code 7") || !strings.Contains(err.Error(), "session not found") || strings.Contains(err.Error(), "secret") || strings.Contains(err.Error(), "private project") {
|
||||
t.Fatal("unsafe or opaque command error", err)
|
||||
}
|
||||
}
|
||||
@@ -32,18 +32,23 @@ type OpenCodeClient struct {
|
||||
}
|
||||
|
||||
type openCodeError struct {
|
||||
operation string
|
||||
status int
|
||||
cause error
|
||||
operation string
|
||||
status int
|
||||
cause error
|
||||
diagnostic string
|
||||
}
|
||||
|
||||
func (e *openCodeError) Unwrap() error { return e.cause }
|
||||
|
||||
func (e *openCodeError) Error() string {
|
||||
if e.status > 0 {
|
||||
return fmt.Sprintf("OpenCode %s failed (HTTP %d)", e.operation, e.status)
|
||||
detail := ""
|
||||
if e.diagnostic != "" {
|
||||
detail = ": " + e.diagnostic
|
||||
}
|
||||
return fmt.Sprintf("OpenCode %s command failed", e.operation)
|
||||
if e.status > 0 {
|
||||
return fmt.Sprintf("OpenCode %s failed (HTTP %d)%s", e.operation, e.status, detail)
|
||||
}
|
||||
return fmt.Sprintf("OpenCode %s command failed%s", e.operation, detail)
|
||||
}
|
||||
func (e *openCodeError) Retryable() bool {
|
||||
return e.status == 429 || e.status == 502 || e.status == 503 || e.status == 504
|
||||
@@ -104,7 +109,7 @@ func (c OpenCodeClient) call(ctx context.Context, method, path string, body any)
|
||||
status, _ = strconv.Atoi(match[1])
|
||||
}
|
||||
// Do not embed provider responses, prompts, credentials, or CLI logs in errors.
|
||||
return nil, &openCodeError{operation: method + " " + path, status: status}
|
||||
return nil, &openCodeError{operation: method + " " + path, status: status, diagnostic: safeCommandDiagnostic(err, stdout.Bytes())}
|
||||
}
|
||||
if stdout.overflow {
|
||||
return nil, fmt.Errorf("OpenCode response exceeds 1 MiB limit")
|
||||
@@ -112,6 +117,25 @@ func (c OpenCodeClient) call(ctx context.Context, method, path string, body any)
|
||||
return stdout.Bytes(), nil
|
||||
}
|
||||
|
||||
func safeCommandDiagnostic(err error, data []byte) string {
|
||||
var exit *exec.ExitError
|
||||
detail := "could not execute CLI"
|
||||
if errors.As(err, &exit) {
|
||||
detail = fmt.Sprintf("CLI exit code %d", exit.ExitCode())
|
||||
}
|
||||
var response struct {
|
||||
Tag string `json:"_tag"`
|
||||
}
|
||||
if json.Unmarshal(data, &response) == nil {
|
||||
// Never copy provider messages, arbitrary stderr or response bodies.
|
||||
reasons := map[string]string{"SessionNotFoundError": "session not found on the selected OpenCode service", "LocationNotFoundError": "session location not found", "ServiceUnavailableError": "OpenCode service unavailable", "UnauthorizedError": "OpenCode service authentication failed", "InvalidRequestError": "OpenCode rejected the request", "SessionBusyError": "OpenCode session is busy"}
|
||||
if reason := reasons[response.Tag]; reason != "" {
|
||||
detail += "; " + reason
|
||||
}
|
||||
}
|
||||
return detail
|
||||
}
|
||||
|
||||
func (c OpenCodeClient) Generate(ctx context.Context, config ModelConfig, prompt string) (text string, err error) {
|
||||
if c.command == nil {
|
||||
connection, err := opencode.Open(ctx, opencode.Executable(), c.Directory, c.Backend)
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
package statusview
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
"net/url"
|
||||
)
|
||||
|
||||
func Offline(endpoint string) *protocol.SystemStatus {
|
||||
s := &protocol.SystemStatus{Server: protocol.ServiceStatus{Health: "unreachable"}, Ntfy: protocol.ServiceStatus{Health: "unknown (server unavailable)"}, Note: "Server information and ntfy configuration cannot be retrieved while disconnected."}
|
||||
if u, err := url.Parse(endpoint); err == nil {
|
||||
u.User = nil
|
||||
u.RawQuery = ""
|
||||
u.Fragment = ""
|
||||
s.Server.URL = u.String()
|
||||
s.Server.Port = u.Port()
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
// Lines is shared by the plain CLI and TUI popup. No credentials are included.
|
||||
func Lines(s *protocol.SystemStatus) []string {
|
||||
if s == nil {
|
||||
return []string{"No status returned by server."}
|
||||
}
|
||||
lines := []string{"Pipelines server", " Health: " + s.Server.Health}
|
||||
if s.Hostname != "" {
|
||||
lines = append(lines, " Host: "+s.Hostname, " Started: "+s.StartedAt+" · uptime "+s.Uptime)
|
||||
}
|
||||
lines = append(lines, " Connection: "+s.Server.URL, " Port: "+s.Server.Port, "", "ntfy", " Publishing health: "+s.Ntfy.Health)
|
||||
if s.Ntfy.URL != "" {
|
||||
lines = append(lines, " Phone server: "+s.Ntfy.URL)
|
||||
}
|
||||
if s.Topic != "" {
|
||||
lines = append(lines, " Topic: "+s.Topic)
|
||||
}
|
||||
if s.Ntfy.Port != "" {
|
||||
lines = append(lines, " Port: "+s.Ntfy.Port)
|
||||
}
|
||||
if s.Topic != "" && s.Ntfy.URL == "" {
|
||||
lines = append(lines, " Phone address not configured (PIPELINES_NTFY_PUBLIC_URL).")
|
||||
}
|
||||
lines = append(lines, "", "Server computer IPs")
|
||||
for _, address := range s.Addresses {
|
||||
lines = append(lines, fmt.Sprintf(" %s · %s", address.Interface, address.IP))
|
||||
}
|
||||
if len(s.Addresses) == 0 {
|
||||
lines = append(lines, " No address information available.")
|
||||
}
|
||||
if len(s.Server.Candidates) > 0 {
|
||||
lines = append(lines, "", "Candidate Pipelines URLs (not verified)")
|
||||
for _, candidate := range s.Server.Candidates {
|
||||
lines = append(lines, " "+candidate)
|
||||
}
|
||||
}
|
||||
if len(s.Ntfy.Candidates) > 0 {
|
||||
lines = append(lines, "", "Candidate ntfy topic URLs (not verified)")
|
||||
for _, candidate := range s.Ntfy.Candidates {
|
||||
lines = append(lines, " "+candidate)
|
||||
}
|
||||
}
|
||||
return append(lines, "", s.Note)
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
package statusview
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestOfflineStatusIncludesBothServicesAndRedactsURLCredentials(t *testing.T) {
|
||||
s := Offline("ws://user:password@localhost:8080/connect?token=secret#secret")
|
||||
text := strings.Join(Lines(s), "\n")
|
||||
for _, secret := range []string{"password", "token=", "secret", "user:"} {
|
||||
if strings.Contains(text, secret) {
|
||||
t.Fatal("credentials exposed", text)
|
||||
}
|
||||
}
|
||||
for _, expected := range []string{"Pipelines server", "unreachable", "ntfy", "unknown (server unavailable)", "8080"} {
|
||||
if !strings.Contains(text, expected) {
|
||||
t.Fatal("missing offline information", expected, text)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -48,7 +48,15 @@ func TestCreateAndSubmit(t *testing.T) {
|
||||
for _, draft := range []string{source, source, "invalid"} {
|
||||
updated, send := m.Update(editedMsg{name: "demo", path: "draft.md", source: draft})
|
||||
m = updated.(Model)
|
||||
if send != nil || !m.confirmOpen {
|
||||
if send == nil || m.confirmOpen {
|
||||
t.Fatal("editor publication check missing")
|
||||
}
|
||||
updated, _ = m.Update(send())
|
||||
m = updated.(Model)
|
||||
if !m.confirmOpen && strings.Contains(m.submitNotice, "Already published") {
|
||||
continue
|
||||
}
|
||||
if !m.confirmOpen {
|
||||
t.Fatal("editor completion bypassed explicit approval")
|
||||
}
|
||||
updated, send = m.updateConfirm(tea.KeyMsg{Type: tea.KeyEnter})
|
||||
@@ -61,7 +69,7 @@ func TestCreateAndSubmit(t *testing.T) {
|
||||
m = updated.(Model)
|
||||
}
|
||||
text := strings.Join(m.lines, "\n")
|
||||
for _, expected := range []string{"Submitted demo: version 1", "no changes", "unexpected text outside a block"} {
|
||||
for _, expected := range []string{"Submitted demo: version 1", "Already published", "unexpected text outside a block"} {
|
||||
if !strings.Contains(text, expected) {
|
||||
t.Fatalf("missing %q in %s", expected, text)
|
||||
}
|
||||
|
||||
+38
-14
@@ -13,7 +13,7 @@ import (
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
)
|
||||
|
||||
var commands = []string{":logs", ":new", ":drafts", ":templates", ":refresh", ":ping", ":edit", ":submit", ":versions", ":run", ":runs", ":retry", ":debug", ":pipeline", ":home", ":quit"}
|
||||
var commands = []string{":status", ":logs", ":new", ":drafts", ":templates", ":refresh", ":ping", ":edit", ":submit", ":versions", ":run", ":runs", ":retry", ":debug", ":pipeline", ":home", ":quit"}
|
||||
|
||||
func (m Model) footerContent() string {
|
||||
label := fmt.Sprintf(" LOGS %d · :logs ", len(m.lines))
|
||||
@@ -39,17 +39,27 @@ func (m Model) footerContent() string {
|
||||
}
|
||||
|
||||
func (m Model) homeLines() []string {
|
||||
runs := []string{bar("Latest runs", fmt.Sprint(len(m.runs)), max(1, m.width-4), true),
|
||||
"r failed runs",
|
||||
lipgloss.NewStyle().Foreground(themeMuted).Render("Pipeline · Version · Outcome · Finished"),
|
||||
"Inspect with :runs; open a pipeline then :run to start."}
|
||||
panelWidth := m.width
|
||||
if m.width >= 96 {
|
||||
panelWidth = (m.width - 1) / 2
|
||||
}
|
||||
runs := []string{bar("Latest runs", fmt.Sprint(len(m.runs)), max(1, panelWidth-4), true),
|
||||
"r all runs · :status server & ntfy",
|
||||
lipgloss.NewStyle().Foreground(themeMuted).Render("Pipeline · Version · Outcome · Duration"),
|
||||
"Inspect with :runs; use :run in a pipeline."}
|
||||
if len(m.runs) == 0 {
|
||||
runs = append(runs, "No runs yet.")
|
||||
}
|
||||
for _, r := range m.runs {
|
||||
runs = append(runs, fmt.Sprintf("#%d %s · v%d · %s · %s", r.ID, r.Name, r.Version, m.progress(r.Status), r.FinishedAt))
|
||||
for _, r := range m.runs[:min(8, len(m.runs))] {
|
||||
runs = append(runs, fmt.Sprintf("#%d %s · v%d · %s · %s", r.ID, r.Name, r.Version, m.progress(r.Status), runDuration(r.CreatedAt, r.FinishedAt)), " Started: "+dateLabel(r.CreatedAt))
|
||||
if r.CurrentStage != "" && (r.Status == "running" || r.Status == "queued") {
|
||||
runs = append(runs, " Stage: "+r.CurrentStage)
|
||||
}
|
||||
}
|
||||
lines := []string{bar("Existing pipelines", fmt.Sprintf("%d", len(m.pipelines)), max(1, m.width-4), true), "r failed runs", ""}
|
||||
if len(m.runs) > 8 {
|
||||
runs = append(runs, "More runs: r or :runs (latest 50)")
|
||||
}
|
||||
lines := []string{bar("Existing pipelines", fmt.Sprintf("%d", len(m.pipelines)), max(1, panelWidth-4), true), "r all runs · / search · n new", ""}
|
||||
if !m.loaded {
|
||||
lines = append(lines, "Waiting for pipeline data…")
|
||||
} else if len(m.pipelines) == 0 {
|
||||
@@ -58,22 +68,34 @@ func (m Model) homeLines() []string {
|
||||
for _, p := range m.pipelines {
|
||||
lines = append(lines,
|
||||
fmt.Sprintf("%s v%d · %d stages", p.Name, p.Version, p.Stages),
|
||||
" Created: "+p.CreatedAt+" · Updated: "+p.UpdatedAt)
|
||||
" Created: "+dateLabel(p.CreatedAt), " Updated: "+dateLabel(p.UpdatedAt))
|
||||
if m.usage != nil {
|
||||
for _, u := range m.usage.Pipelines {
|
||||
if u.PipelineID == p.ID {
|
||||
lines = append(lines, fmt.Sprintf(" %d runs · %s · avg %s", u.Total, successLabel(u.RunCounts), averageLabel(u.RunCounts)))
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if m.width < 8 {
|
||||
return append(append(runs, ""), lines...)
|
||||
}
|
||||
widget := func(rows []string) []string {
|
||||
widget := func(rows []string, width int) string {
|
||||
for i := range rows {
|
||||
rows[i] = ansi.Truncate(rows[i], m.width-4, "…")
|
||||
rows[i] = ansi.Truncate(rows[i], max(1, width-4), "…")
|
||||
}
|
||||
content := lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).
|
||||
BorderForeground(themeMuted).Padding(0, 1).Width(m.width - 2).
|
||||
BorderForeground(themeMuted).Padding(0, 1).Width(width - 2).
|
||||
Render(strings.Join(rows, "\n"))
|
||||
return strings.Split(content, "\n")
|
||||
return content
|
||||
}
|
||||
return append(append(widget(runs), ""), widget(lines)...)
|
||||
panels := widget(runs, panelWidth) + "\n\n" + widget(lines, panelWidth)
|
||||
if m.width >= 96 {
|
||||
panels = lipgloss.JoinHorizontal(lipgloss.Top, widget(runs, panelWidth), " ", widget(lines, m.width-panelWidth-1))
|
||||
}
|
||||
return strings.Split(widget(m.usageLines(), m.width)+"\n"+panels, "\n")
|
||||
}
|
||||
|
||||
func (m Model) homePage() bool {
|
||||
@@ -156,6 +178,8 @@ func (m Model) updatePalette(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
||||
m.paletteOpen = false
|
||||
m.keys.palette = false
|
||||
switch command {
|
||||
case ":status":
|
||||
return m.openStatus()
|
||||
case ":debug":
|
||||
return m.debugRun()
|
||||
case ":retry":
|
||||
|
||||
@@ -0,0 +1,129 @@
|
||||
package tui
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"git.a-wan.net/alan/pipelines/internal/client"
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
type editorPublicationMsg struct {
|
||||
edit editedMsg
|
||||
generation uint64
|
||||
pipelines []protocol.PipelineSummary
|
||||
detail *protocol.PipelineDetail
|
||||
published bool
|
||||
err error
|
||||
}
|
||||
|
||||
func checkEditorPublication(ctx context.Context, endpoint string, edit editedMsg, generation uint64) tea.Cmd {
|
||||
return func() tea.Msg {
|
||||
result := editorPublicationMsg{edit: edit, generation: generation}
|
||||
ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
|
||||
defer cancel()
|
||||
c, err := client.Open(ctx, endpoint)
|
||||
if err != nil {
|
||||
result.err = err
|
||||
return result
|
||||
}
|
||||
defer c.Close()
|
||||
list, err := c.Call(ctx, protocol.Message{Type: protocol.List})
|
||||
if err != nil {
|
||||
result.err = err
|
||||
return result
|
||||
}
|
||||
result.pipelines = list.Pipelines
|
||||
for _, p := range list.Pipelines {
|
||||
if p.Name != strings.TrimSpace(edit.name) {
|
||||
continue
|
||||
}
|
||||
response, err := c.Call(ctx, protocol.Message{Type: protocol.GetPipeline, PipelineID: p.ID})
|
||||
if err != nil {
|
||||
result.err = err
|
||||
return result
|
||||
}
|
||||
result.detail = response.Detail
|
||||
if result.detail == nil {
|
||||
result.err = fmt.Errorf("server returned no pipeline detail")
|
||||
return result
|
||||
}
|
||||
if result.detail.Source == edit.source {
|
||||
result.published = true
|
||||
return result
|
||||
}
|
||||
// If another version was published afterward, the editor's submitted
|
||||
// source still must not be offered for duplicate submission. Only
|
||||
// inspect versions newer than this draft's immutable starting point.
|
||||
for _, v := range result.detail.Versions {
|
||||
if v.Version <= edit.baseVersion || v.Version == result.detail.Version {
|
||||
continue
|
||||
}
|
||||
response, err := c.Call(ctx, protocol.Message{Type: protocol.GetPipeline, PipelineID: p.ID, Version: v.Version})
|
||||
if err != nil {
|
||||
result.err = err
|
||||
return result
|
||||
}
|
||||
if response.Detail != nil && response.Detail.Source == edit.source {
|
||||
result.published = true
|
||||
return result
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
return result
|
||||
}
|
||||
}
|
||||
|
||||
func (m Model) finishEditorPublication(msg editorPublicationMsg) (tea.Model, tea.Cmd) {
|
||||
if msg.generation != m.editorCheckGeneration {
|
||||
return m, nil
|
||||
}
|
||||
m.editorChecking = false
|
||||
if msg.err == nil {
|
||||
m.pipelines = msg.pipelines
|
||||
m.loaded = true
|
||||
if msg.detail != nil {
|
||||
m.detail = msg.detail
|
||||
m.keys.detail = true
|
||||
m.detailLoading = false
|
||||
m.detailError = ""
|
||||
m.detailRequest = ""
|
||||
m.requestedPipelineID = msg.detail.ID
|
||||
m.requestedVersion = msg.detail.Version
|
||||
m.resetPipelineView()
|
||||
}
|
||||
}
|
||||
if msg.published {
|
||||
m.pendingDraft = nil
|
||||
m.confirmOpen = false
|
||||
m.keys.confirm = false
|
||||
m.draftOpen = false
|
||||
m.keys.drafts = false
|
||||
m.templateOpen = false
|
||||
m.keys.templates = false
|
||||
m.submitNotice = "Already published; reloaded latest version."
|
||||
m.appendLine(m.submitNotice)
|
||||
return m, nil
|
||||
}
|
||||
if msg.edit.unchanged {
|
||||
m.confirmOpen = false
|
||||
m.keys.confirm = false
|
||||
m.submitNotice = "No local changes; page refreshed."
|
||||
if msg.err != nil {
|
||||
m.submitNotice = "No local changes; refresh failed: " + msg.err.Error()
|
||||
}
|
||||
m.appendLine(m.submitNotice)
|
||||
return m, nil
|
||||
}
|
||||
m.pendingDraft = &msg.edit
|
||||
m.confirmOpen = true
|
||||
m.keys.confirm = true
|
||||
m.submitNotice = ""
|
||||
if msg.err != nil {
|
||||
m.submitNotice = "Could not check publication; draft retained: " + msg.err.Error()
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
package tui
|
||||
|
||||
import (
|
||||
"context"
|
||||
"git.a-wan.net/alan/pipelines/internal/pipeline"
|
||||
"git.a-wan.net/alan/pipelines/internal/server"
|
||||
"net/http/httptest"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestEditorReturnFindsPublishedVersionAndReloadsLatest(t *testing.T) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
store, err := pipeline.Open(filepath.Join(t.TempDir(), "publication.db"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer store.Close()
|
||||
handler := server.Handler(ctx, store)
|
||||
srv := httptest.NewServer(handler)
|
||||
defer func() { cancel(); srv.Close(); server.WaitRuns(handler) }()
|
||||
source := pipeline.Template([]string{"planner"}, true)
|
||||
if _, err := store.Submit(ctx, "test", source); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
items, _ := store.List(ctx)
|
||||
original, _ := store.Get(ctx, items[0].ID, 1)
|
||||
edited := strings.Replace(source, "Describe the task.", "Published in OpenCode.", 1)
|
||||
if edited == source {
|
||||
t.Fatal("fixture did not change source")
|
||||
}
|
||||
if _, err := store.Submit(ctx, "test", edited); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
latest := strings.Replace(edited, "Published in OpenCode.", "Another newer update.", 1)
|
||||
if _, err := store.Submit(ctx, "test", latest); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
m := New(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect")
|
||||
connected := m.connect()().(connectedMsg)
|
||||
defer connected.conn.CloseNow()
|
||||
updated, _ := m.Update(connected)
|
||||
m = updated.(Model)
|
||||
m.detail = original
|
||||
m.keys.detail = true
|
||||
updated, check := m.Update(editedMsg{name: "test", path: "retained.md", source: edited, baseVersion: 1})
|
||||
m = updated.(Model)
|
||||
if check == nil || m.confirmOpen {
|
||||
t.Fatal("must check before asking to submit")
|
||||
}
|
||||
updated, _ = m.Update(check())
|
||||
m = updated.(Model)
|
||||
if m.confirmOpen || m.pendingDraft != nil || m.detail.Version != 3 || m.detail.Source != latest || m.pipelines[0].Version != 3 || !strings.Contains(m.submitNotice, "Already published") {
|
||||
t.Fatal("did not find earlier publication and reload latest", m.submitNotice, m.detail)
|
||||
}
|
||||
items, _ = store.List(ctx)
|
||||
if items[0].Version != 3 {
|
||||
t.Fatal("publication check created a duplicate version")
|
||||
}
|
||||
// A local unsent draft must still need approval, even if the server changed.
|
||||
unsent := strings.Replace(edited, "Published in OpenCode.", "Local unsent edits.", 1)
|
||||
updated, check = m.Update(editedMsg{name: "test", path: "retained.md", source: unsent, baseVersion: 1})
|
||||
m = updated.(Model)
|
||||
updated, _ = m.Update(check())
|
||||
m = updated.(Model)
|
||||
if !m.confirmOpen || m.pendingDraft.source != unsent || m.pendingDraft.baseVersion != 1 {
|
||||
t.Fatal("unsent changes or original conflict guard lost")
|
||||
}
|
||||
}
|
||||
|
||||
func TestEditorPublicationFailureAndStaleResultDoNotDiscardDraft(t *testing.T) {
|
||||
m := New(context.Background(), "")
|
||||
m.editorCheckGeneration = 2
|
||||
edit := editedMsg{name: "test", source: "unsent", baseVersion: 1}
|
||||
updated, _ := m.finishEditorPublication(editorPublicationMsg{generation: 1, edit: edit, published: true})
|
||||
m = updated.(Model)
|
||||
if m.confirmOpen {
|
||||
t.Fatal("stale result changed editor state")
|
||||
}
|
||||
result := checkEditorPublication(context.Background(), "invalid-url", edit, 2)().(editorPublicationMsg)
|
||||
updated, _ = m.finishEditorPublication(result)
|
||||
m = updated.(Model)
|
||||
if !m.confirmOpen || m.pendingDraft.source != "unsent" || !strings.Contains(m.submitNotice, "Could not check") {
|
||||
t.Fatal("failed check lost local edits", m.submitNotice)
|
||||
}
|
||||
}
|
||||
@@ -13,7 +13,7 @@ import (
|
||||
"github.com/charmbracelet/x/ansi"
|
||||
)
|
||||
|
||||
func TestHomeShortcutOpensFailedRunsAndDisplaysHintInBothPanels(t *testing.T) {
|
||||
func TestHomeShortcutOpensAllRunsAndDisplaysHintInBothPanels(t *testing.T) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
||||
defer cancel()
|
||||
srv := httptest.NewServer(server.Handler(ctx))
|
||||
@@ -27,25 +27,26 @@ func TestHomeShortcutOpensFailedRunsAndDisplaysHintInBothPanels(t *testing.T) {
|
||||
m.height = 40
|
||||
m.runs = []protocol.RunSummary{{ID: 1, Status: "succeeded", Name: "passed"}, {ID: 2, Status: "failed", Name: "broken", FinishedAt: "2026-10-09T00:00:00Z"}, {ID: 3, Status: "running", Name: "active"}, {ID: 4, Status: "canceled", Name: "canceled"}, {ID: 5, Status: "failed", Name: "also broken", FinishedAt: "2026-10-09T00:00:00Z"}}
|
||||
view := ansi.Strip(strings.Join(m.homeLines(), "\n"))
|
||||
if strings.Count(view, "r failed runs") != 2 {
|
||||
if strings.Count(view, "r all runs") < 2 || strings.Contains(view, "r failed runs") {
|
||||
t.Fatal("missing shortcut in both panels", view)
|
||||
}
|
||||
updated, send := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'r'}})
|
||||
m = updated.(Model)
|
||||
if send == nil || !m.runOpen || !m.keys.runs || !m.runFailedOnly || m.runIndex != 0 {
|
||||
t.Fatal("home shortcut did not open failed list")
|
||||
if send == nil || !m.runOpen || !m.keys.runs || m.runFailedOnly || m.runIndex != 0 {
|
||||
t.Fatal("home shortcut did not open all runs")
|
||||
}
|
||||
if _, ok := send().(sentMsg); !ok {
|
||||
t.Fatal("failed list refresh request failed")
|
||||
}
|
||||
visible := m.visibleRuns()
|
||||
if len(visible) != 2 || visible[0].ID != 2 || visible[1].ID != 5 {
|
||||
t.Fatal("nonfailed runs leaked into list", visible)
|
||||
if len(visible) != 5 || visible[0].ID != 1 || visible[1].ID != 2 {
|
||||
t.Fatal("home runs were filtered", visible)
|
||||
}
|
||||
view = ansi.Strip(m.runsView(30))
|
||||
if !strings.Contains(view, "Failed runs") || strings.Contains(view, "passed") || strings.Contains(view, "active") {
|
||||
t.Fatal("failed list view is incorrect", view)
|
||||
if strings.Contains(view, "Failed runs") || !strings.Contains(view, "passed") || !strings.Contains(view, "active") {
|
||||
t.Fatal("all runs view is incorrect", view)
|
||||
}
|
||||
m.runIndex = 1
|
||||
updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'r'}})
|
||||
m = updated.(Model)
|
||||
if cmd == nil || m.runStartRequest == "" {
|
||||
|
||||
+46
-2
@@ -85,11 +85,18 @@ func (k keyMap) ShortHelp() []key.Binding {
|
||||
if k.detail {
|
||||
return []key.Binding{k.commands, k.search, key.NewBinding(key.WithKeys("n", "p"), key.WithHelp("n/p", "next/prev stage")), key.NewBinding(key.WithKeys("tab"), key.WithHelp("Tab", "pane")), key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "runs")), key.NewBinding(key.WithKeys("j", "k"), key.WithHelp("j/k", "scroll")), key.NewBinding(key.WithKeys("esc"), key.WithHelp("esc", "home"))}
|
||||
}
|
||||
return []key.Binding{k.commands, k.search, k.create, key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "failed runs")), key.NewBinding(key.WithKeys("d"), key.WithHelp("d", "drafts")), key.NewBinding(key.WithKeys("b"), key.WithHelp("b", "templates")), k.ping, k.quit}
|
||||
return []key.Binding{k.commands, k.search, k.create, key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "all runs")), key.NewBinding(key.WithKeys("d"), key.WithHelp("d", "drafts")), key.NewBinding(key.WithKeys("b"), key.WithHelp("b", "templates")), k.ping, k.quit}
|
||||
}
|
||||
func (k keyMap) FullHelp() [][]key.Binding { return [][]key.Binding{k.ShortHelp()} }
|
||||
|
||||
type Model struct {
|
||||
editorCheckGeneration uint64
|
||||
editorChecking bool
|
||||
statusOpen bool
|
||||
statusTop int
|
||||
statusRequest, statusError string
|
||||
systemStatus *protocol.SystemStatus
|
||||
usage *protocol.UsageStats
|
||||
draftOpen bool
|
||||
draftItems []draft.Draft
|
||||
draftIndex, draftTop int
|
||||
@@ -295,6 +302,16 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
||||
}
|
||||
return m.Update(receivedMsg(msg.message))
|
||||
case receivedMsg:
|
||||
if msg.Type == protocol.Status && msg.ID == m.statusRequest {
|
||||
m.systemStatus = msg.Status
|
||||
m.statusError = ""
|
||||
m.statusRequest = ""
|
||||
return m, m.read()
|
||||
}
|
||||
if msg.Type == protocol.Error && msg.ID != "" && msg.ID == m.statusRequest {
|
||||
m.statusError = msg.Error
|
||||
m.statusRequest = ""
|
||||
}
|
||||
if msg.Type == protocol.PipelineList || msg.Type == protocol.Submitted {
|
||||
m.notificationEndpoints = msg.NotificationEndpoints
|
||||
}
|
||||
@@ -303,6 +320,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
||||
m.templateIndex = 0
|
||||
m.renderTemplate()
|
||||
} else if msg.Type == protocol.Runs {
|
||||
m.usage = msg.Usage
|
||||
m.runs = msg.Runs
|
||||
m.runIndex = min(m.runIndex, max(0, len(m.visibleRuns())-1))
|
||||
} else if msg.Type == protocol.Run || msg.Type == protocol.RunStarted {
|
||||
@@ -416,6 +434,14 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
||||
m.appendLine("editor: " + msg.err.Error())
|
||||
return m, nil
|
||||
}
|
||||
if m.conn != nil {
|
||||
m.editorCheckGeneration++
|
||||
m.editorChecking = true
|
||||
m.confirmOpen = false
|
||||
m.keys.confirm = false
|
||||
m.submitNotice = "Checking whether edits were published…"
|
||||
return m, checkEditorPublication(m.ctx, m.url, msg, m.editorCheckGeneration)
|
||||
}
|
||||
if msg.unchanged {
|
||||
m.confirmOpen = false
|
||||
m.keys.confirm = false
|
||||
@@ -429,6 +455,8 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
||||
m.keys.confirm = true
|
||||
m.submitNotice = ""
|
||||
return m, nil
|
||||
case editorPublicationMsg:
|
||||
return m.finishEditorPublication(msg)
|
||||
case errorMsg:
|
||||
if msg.conn != nil && msg.conn != m.conn {
|
||||
return m, nil
|
||||
@@ -437,6 +465,10 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
||||
return m, nil
|
||||
}
|
||||
m.status = "Reconnecting…"
|
||||
if m.statusOpen {
|
||||
m.statusError = "Connection lost; reconnecting. Press r to refresh after reconnect."
|
||||
m.statusRequest = ""
|
||||
}
|
||||
m.appendLine("error: " + msg.err.Error())
|
||||
m.detailRequest = ""
|
||||
m.detailLoading = m.keys.detail && m.requestedPipelineID > 0
|
||||
@@ -454,9 +486,15 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
||||
if msg.String() == "ctrl+c" {
|
||||
return m, tea.Quit
|
||||
}
|
||||
if m.editorChecking {
|
||||
return m, nil
|
||||
}
|
||||
if m.editorOpen {
|
||||
return m.updateEditorPicker(msg)
|
||||
}
|
||||
if m.statusOpen {
|
||||
return m.updateStatus(msg)
|
||||
}
|
||||
if m.logOpen {
|
||||
return m.updateLogs(msg)
|
||||
}
|
||||
@@ -487,7 +525,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
||||
switch {
|
||||
case m.homePage() && msg.String() == "r":
|
||||
m.closeRuns()
|
||||
m.runFailedOnly = true
|
||||
m.runFailedOnly = false
|
||||
m.runOpen = true
|
||||
m.keys.runs = true
|
||||
m.runIndex = 0
|
||||
@@ -673,6 +711,12 @@ func (m Model) View() string {
|
||||
if m.editorOpen {
|
||||
content = m.editorPickerView(bodyHeight)
|
||||
}
|
||||
if m.statusOpen {
|
||||
content = m.statusView(bodyHeight)
|
||||
}
|
||||
if m.editorChecking {
|
||||
content = popup(m.width, bodyHeight, 76, []string{"Checking published edits", "Refreshing pipeline information…", "Local draft remains retained."})
|
||||
}
|
||||
parts = append(parts, content)
|
||||
}
|
||||
return strings.Join(append(parts, footer), "\n")
|
||||
|
||||
@@ -74,7 +74,12 @@ func TestSearchVersionsAndEditSubmission(t *testing.T) {
|
||||
newSource := strings.Replace(source, "Describe the task.", "Edited from version one.", 1)
|
||||
updated, send = m.Update(editedMsg{name: "demo", path: "draft.md", source: newSource, confirm: true})
|
||||
m = updated.(Model)
|
||||
if send != nil || !m.confirmOpen {
|
||||
if send == nil || m.confirmOpen {
|
||||
t.Fatal("publication check missing")
|
||||
}
|
||||
updated, _ = m.Update(send())
|
||||
m = updated.(Model)
|
||||
if !m.confirmOpen {
|
||||
t.Fatal("edited pipeline should require explicit submission")
|
||||
}
|
||||
items, err := store.List(ctx)
|
||||
@@ -96,8 +101,16 @@ func TestSearchVersionsAndEditSubmission(t *testing.T) {
|
||||
t.Fatal("historic version mutated")
|
||||
}
|
||||
for _, draft := range []string{newSource, "invalid"} {
|
||||
updated, _ = m.Update(editedMsg{name: "demo", path: "draft.md", source: draft, confirm: true})
|
||||
updated, send = m.Update(editedMsg{name: "demo", path: "draft.md", source: draft, confirm: true})
|
||||
m = updated.(Model)
|
||||
updated, _ = m.Update(send())
|
||||
m = updated.(Model)
|
||||
if draft == newSource {
|
||||
if m.confirmOpen || m.pendingDraft != nil {
|
||||
t.Fatal("already-published edit offered duplicate submission")
|
||||
}
|
||||
continue
|
||||
}
|
||||
updated, send = m.Update(tea.KeyMsg{Type: tea.KeyEnter})
|
||||
m = updated.(Model)
|
||||
send()
|
||||
|
||||
@@ -0,0 +1,57 @@
|
||||
package tui
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
func successLabel(c protocol.RunCounts) string {
|
||||
resolved := c.Succeeded + c.Failed
|
||||
if resolved == 0 {
|
||||
return "success —"
|
||||
}
|
||||
return fmt.Sprintf("success %.0f%%", 100*float64(c.Succeeded)/float64(resolved))
|
||||
}
|
||||
func averageLabel(c protocol.RunCounts) string {
|
||||
if c.Total-c.Active <= 0 {
|
||||
return "—"
|
||||
}
|
||||
return (time.Duration(c.AverageSeconds * float64(time.Second))).Round(time.Second).String()
|
||||
}
|
||||
func usageChart(days []protocol.DailyUsage) string {
|
||||
maxRuns := 0
|
||||
for _, day := range days {
|
||||
maxRuns = max(maxRuns, day.Runs)
|
||||
}
|
||||
var b strings.Builder
|
||||
levels := []rune("▁▂▃▄▅▆▇█")
|
||||
for _, day := range days {
|
||||
if day.Runs == 0 {
|
||||
b.WriteRune('·')
|
||||
} else {
|
||||
level := min(7, max(0, (day.Runs*8-1)/maxRuns))
|
||||
b.WriteRune(levels[level])
|
||||
}
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
func (m Model) usageLines() []string {
|
||||
lines := []string{"Usage · all history"}
|
||||
if m.usage == nil {
|
||||
return append(lines, "Waiting for usage statistics…", ":status server & ntfy · r all runs")
|
||||
}
|
||||
c := m.usage.RunCounts
|
||||
lines = append(lines, fmt.Sprintf("%d pipelines · %d runs · %d active · %s · avg completed %s", len(m.pipelines), c.Total, c.Active, successLabel(c), averageLabel(c)), fmt.Sprintf("Outcomes: %d succeeded · %d failed · %d canceled · %d interrupted", c.Succeeded, c.Failed, c.Canceled, c.Interrupted))
|
||||
if len(m.usage.Days) > 0 {
|
||||
days := m.usage.Days
|
||||
total, peak := 0, 0
|
||||
for _, day := range days {
|
||||
total += day.Runs
|
||||
peak = max(peak, day.Runs)
|
||||
}
|
||||
lines = append(lines, fmt.Sprintf("14d activity %s · %d runs · peak %d/day (UTC)", usageChart(days), total, peak))
|
||||
}
|
||||
return lines
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
package tui
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
"git.a-wan.net/alan/pipelines/internal/statusview"
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
"net/url"
|
||||
)
|
||||
|
||||
func (m Model) openStatus() (tea.Model, tea.Cmd) {
|
||||
m.statusOpen = true
|
||||
m.statusTop = 0
|
||||
m.systemStatus = nil
|
||||
m.statusError = ""
|
||||
return m.refreshStatus()
|
||||
}
|
||||
func (m Model) refreshStatus() (tea.Model, tea.Cmd) {
|
||||
if m.conn == nil {
|
||||
m.statusError = "Not connected to the Pipelines server."
|
||||
return m, nil
|
||||
}
|
||||
m.nextID++
|
||||
m.statusRequest = fmt.Sprintf("status-%d", m.nextID)
|
||||
m.statusError = ""
|
||||
return m, m.send(protocol.Message{Type: protocol.GetStatus, ID: m.statusRequest})
|
||||
}
|
||||
func (m Model) updateStatus(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
||||
switch msg.String() {
|
||||
case "esc", "q":
|
||||
m.statusOpen = false
|
||||
return m, nil
|
||||
case "r":
|
||||
return m.refreshStatus()
|
||||
case "j", "down":
|
||||
m.statusTop++
|
||||
case "k", "up":
|
||||
m.statusTop--
|
||||
case "pgdown":
|
||||
m.statusTop += max(1, m.height-10)
|
||||
case "pgup":
|
||||
m.statusTop -= max(1, m.height-10)
|
||||
}
|
||||
m.statusTop = max(0, min(m.statusTop, max(0, len(m.statusLines())-max(1, m.height-9))))
|
||||
return m, nil
|
||||
}
|
||||
func (m Model) statusLines() []string {
|
||||
connection := "invalid URL"
|
||||
if u, err := url.Parse(m.url); err == nil {
|
||||
u.User = nil
|
||||
u.RawQuery = ""
|
||||
u.Fragment = ""
|
||||
connection = u.String()
|
||||
}
|
||||
lines := []string{"Client connection: " + connection}
|
||||
if m.statusRequest != "" {
|
||||
lines = append(lines, "Checking server and ntfy…")
|
||||
}
|
||||
if m.statusError != "" {
|
||||
lines = append(lines, m.statusError)
|
||||
if m.systemStatus == nil {
|
||||
lines = append(lines, "ntfy: unknown (server information unavailable)")
|
||||
}
|
||||
}
|
||||
if m.systemStatus != nil {
|
||||
lines = append(lines, " ")
|
||||
lines = append(lines, statusview.Lines(m.systemStatus)...)
|
||||
}
|
||||
return lines
|
||||
}
|
||||
func (m Model) statusView(height int) string {
|
||||
lines := m.statusLines()
|
||||
page := max(1, height-5)
|
||||
top := min(m.statusTop, max(0, len(lines)-page))
|
||||
rows := []string{"Status · Pipelines & ntfy", "↑/↓ scroll · PgUp/PgDn · r refresh · Esc close", ""}
|
||||
rows = append(rows, lines[top:min(len(lines), top+page)]...)
|
||||
return popup(m.width, height, 108, rows)
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
package tui
|
||||
|
||||
import (
|
||||
"context"
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
"github.com/charmbracelet/x/ansi"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestStatusPalettePopupAndClosePreservesUnderlyingPage(t *testing.T) {
|
||||
m := New(context.Background(), "ws://127.0.0.1:8080/connect")
|
||||
m.width = 120
|
||||
m.height = 40
|
||||
m.runOpen = true
|
||||
m.keys.runs = true
|
||||
m.runDetail = &protocol.RunDetail{RunSummary: protocol.RunSummary{ID: 42}}
|
||||
m = press(m, ":")
|
||||
m = press(m, "status")
|
||||
m = press(m, "enter")
|
||||
if !m.statusOpen || m.paletteOpen || !strings.Contains(ansi.Strip(m.View()), "Not connected") {
|
||||
t.Fatal("status unavailable off Home", m.View())
|
||||
}
|
||||
m.statusRequest = "status-1"
|
||||
updated, _ := m.Update(receivedMsg(protocol.Message{Type: protocol.Status, ID: "status-1", Status: &protocol.SystemStatus{Hostname: "test-machine", Server: protocol.ServiceStatus{Health: "healthy", Port: "8080"}, Ntfy: protocol.ServiceStatus{Health: "healthy", URL: "http://192.0.2.2:8090", Port: "8090"}, Addresses: []protocol.NetworkAddress{{Interface: "en0", IP: "192.0.2.2"}}}}))
|
||||
m = updated.(Model)
|
||||
view := ansi.Strip(m.View())
|
||||
for _, text := range []string{"Pipelines server", "ntfy", "test-machine", "8080", "8090", "192.0.2.2"} {
|
||||
if !strings.Contains(view, text) {
|
||||
t.Fatal("missing status info", text, view)
|
||||
}
|
||||
}
|
||||
m = press(m, "esc")
|
||||
if m.statusOpen || m.runDetail.ID != 42 {
|
||||
t.Fatal("status destroyed run selection")
|
||||
}
|
||||
updated, _ = m.Update(tea.WindowSizeMsg{Width: 40, Height: 12})
|
||||
m = updated.(Model)
|
||||
m.statusOpen = true
|
||||
if len(strings.Split(ansi.Strip(m.View()), "\n")) != 12 {
|
||||
t.Fatal("popup overflowed short terminal")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDashboardSideBySideStatsAndNarrowStacking(t *testing.T) {
|
||||
m := New(context.Background(), "")
|
||||
m.width = 120
|
||||
m.loaded = true
|
||||
m.pipelines = []protocol.PipelineSummary{{ID: 1, Name: "popular", Version: 2, Stages: 3}}
|
||||
m.usage = &protocol.UsageStats{RunCounts: protocol.RunCounts{Total: 80, Succeeded: 60, Failed: 20, AverageSeconds: 60}, Pipelines: []protocol.PipelineUsage{{PipelineID: 1, Name: "popular", RunCounts: protocol.RunCounts{Total: 80, Succeeded: 60, Failed: 20, AverageSeconds: 60}}}, Days: []protocol.DailyUsage{{Runs: 0}, {Runs: 1}, {Runs: 8}}}
|
||||
view := ansi.Strip(strings.Join(m.homeLines(), "\n"))
|
||||
for _, text := range []string{"80 runs", "success 75%", "avg completed 1m0s", "14d activity", "60 succeeded", "20 failed", "avg 1m0s"} {
|
||||
if !strings.Contains(view, text) {
|
||||
t.Fatal("missing dashboard metric", text, view)
|
||||
}
|
||||
}
|
||||
sameLine := false
|
||||
for _, line := range strings.Split(view, "\n") {
|
||||
if strings.Contains(line, "Latest runs") && strings.Contains(line, "Existing pipelines") {
|
||||
sameLine = true
|
||||
}
|
||||
}
|
||||
if !sameLine {
|
||||
t.Fatal("wide dashboard did not use columns", view)
|
||||
}
|
||||
m.width = 60
|
||||
view = ansi.Strip(strings.Join(m.homeLines(), "\n"))
|
||||
for _, line := range strings.Split(view, "\n") {
|
||||
if strings.Contains(line, "Latest runs") && strings.Contains(line, "Existing pipelines") {
|
||||
t.Fatal("narrow dashboard did not stack")
|
||||
}
|
||||
}
|
||||
if usageChart([]protocol.DailyUsage{{Runs: 0}, {Runs: 0}}) != "··" {
|
||||
t.Fatal("empty activity fabricated bars")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user