feat: flue close ends sessions from the CLI

Holder-backed sessions outlive the daemon, so stopping it stopped being
a way to end them. flue close is the deliberate verb: --all retires
every session on the local daemon, ids retire the named ones, and
unknown ids are reported by name without failing the rest.

The semantics live on the registry (CloseAll, CloseByID), mirroring
Reap: victims leave the map under r.mu, are closed outside it, and
their meta files go with them. The daemon translates POST
/api/sessions/close — behind withAuth, named in methodPolicy — into
those calls, and the CLI owns argv, output, and exit codes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: karngyan

cmd/flue/close.go

@@ -0,0 +1,134 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+
+	"github.com/karnstack/flue/internal/daemon"
+	"github.com/karnstack/flue/internal/transport/local"
+)
+
+// errCloseUsage answers a bare `flue close`, which could mean either form and
+// so gets both. A sentinel rather than a plain error because cmdClose exits 2
+// on it — the code main uses for an unknown command, and the right one for
+// "you have not said what to close".
+var errCloseUsage = errors.New("usage: flue close <id>...  |  flue close --all")
+
+// errUnknownSessions reports that at least one named id closed nothing. The
+// per-id lines have already gone to stderr by the time it is returned, so
+// cmdClose turns it into a bare exit 1 rather than printing it again.
+var errUnknownSessions = errors.New("some sessions were not found")
+
+// cmdClose owns the exit codes runClose cannot: 2 for a usage error and 1 for
+// unknown ids, both already explained on stderr. Everything else flows back
+// to main's ordinary error path.
+func cmdClose(args []string) error {
+	err := runClose(os.Stdout, os.Stderr, args)
+	switch {
+	case errors.Is(err, errCloseUsage):
+		fmt.Fprintln(os.Stderr, "flue:", err)
+		os.Exit(2)
+	case errors.Is(err, errUnknownSessions):
+		os.Exit(1)
+	}
+	return err
+}
+
+// runClose ends sessions on the local daemon: every one under --all, the
+// named ones otherwise. The writers are the seam — same pattern as statusTo —
+// so the tests read both streams without capturing the process's own.
+//
+// A daemon that is not running is answered with a notice and success, not a
+// failure: the user asked for no sessions, and no daemon means exactly that.
+// Unknown ids are the one partial outcome — each is named on stderr, the rest
+// are closed and counted, and errUnknownSessions carries the failure out.
+func runClose(stdout, stderr io.Writer, args []string) error {
+	fs := flag.NewFlagSet("close", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	all := fs.Bool("all", false, "close every session, running and exited")
+	if err := fs.Parse(args); err != nil {
+		return errCloseUsage
+	}
+	ids := fs.Args()
+	if !*all && len(ids) == 0 {
+		return errCloseUsage
+	}
+
+	port, ok := ourDaemon()
+	if !ok {
+		fmt.Fprintln(stdout, "daemon not running; nothing to close")
+		return nil
+	}
+	token, err := loadToken()
+	if err != nil {
+		return fmt.Errorf("load auth token: %w", err)
+	}
+
+	closed, missing, err := postSessionsClose(port, token, *all, ids)
+	if err != nil {
+		return err
+	}
+	for _, id := range missing {
+		fmt.Fprintf(stderr, "flue: no such session: %s\n", id)
+	}
+	noun := "sessions"
+	if closed == 1 {
+		noun = "session"
+	}
+	fmt.Fprintf(stdout, "  ✓ closed %d %s\n", closed, noun)
+	if len(missing) > 0 {
+		return errUnknownSessions
+	}
+	return nil
+}
+
+// postSessionsClose asks the daemon to close sessions and relays its answer.
+// The shape mirrors fetchSessions — token in a header, status checked before
+// the body is decoded, the body bounded — because it is talking to the same
+// daemon under the same rules.
+func postSessionsClose(port int, token string, all bool, ids []string) (closed int, missing []string, err error) {
+	body, err := json.Marshal(map[string]any{"all": all, "ids": ids})
+	if err != nil {
+		return 0, nil, err
+	}
+	u := &url.URL{
+		Scheme: "http",
+		Host:   fmt.Sprintf("127.0.0.1:%d", port),
+		Path:   daemon.SessionsClosePath,
+	}
+	req, err := http.NewRequest(http.MethodPost, u.String(), bytes.NewReader(body))
+	if err != nil {
+		return 0, nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set(local.HeaderName, token)
+	resp, err := probeClient.Do(req)
+	if err != nil {
+		return 0, nil, err
+	}
+	defer resp.Body.Close()
+
+	switch resp.StatusCode {
+	case http.StatusOK:
+	case http.StatusUnauthorized:
+		return 0, nil, errTokenRejected
+	default:
+		return 0, nil, fmt.Errorf("daemon on 127.0.0.1:%d answered %s", port, resp.Status)
+	}
+
+	var out struct {
+		Closed  int      `json:"closed"`
+		Missing []string `json:"missing"`
+	}
+	if err := json.NewDecoder(io.LimitReader(resp.Body, maxListingBytes)).Decode(&out); err != nil {
+		return 0, nil, fmt.Errorf("decode close answer: %w", err)
+	}
+	return out.Closed, out.Missing, nil
+}

cmd/flue/close_test.go

@@ -0,0 +1,156 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"net/http/httptest"
+	"net/url"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/karnstack/flue/internal/config"
+	"github.com/karnstack/flue/internal/daemon"
+	"github.com/karnstack/flue/internal/session"
+	"github.com/karnstack/flue/internal/transport/local"
+)
+
+// newCloseTestDaemon is newTestDaemon with the registry exposed, because these
+// tests need to spawn the sessions the command is asked to close and to see
+// afterwards whether they went. It also writes the runtime record, which is
+// how runClose finds the daemon at all.
+func newCloseTestDaemon(t *testing.T) *session.Registry {
+	t.Helper()
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+
+	token, err := config.LoadOrCreateToken()
+	if err != nil {
+		t.Fatalf("LoadOrCreateToken: %v", err)
+	}
+	reg := session.NewRegistry(time.Now)
+	srv := daemon.New(reg, local.NewAuth(token, 0), uiHandler(), version, daemon.Identity{})
+	ts := httptest.NewServer(srv.Handler())
+	t.Cleanup(ts.Close)
+	t.Cleanup(srv.Shutdown)
+
+	u, err := url.Parse(ts.URL)
+	if err != nil {
+		t.Fatalf("parse test server URL %q: %v", ts.URL, err)
+	}
+	port, err := strconv.Atoi(u.Port())
+	if err != nil {
+		t.Fatalf("parse port from %q: %v", ts.URL, err)
+	}
+	srv.SetAuth(local.NewAuth(token, port))
+	if err := daemon.WriteRuntime(port); err != nil {
+		t.Fatalf("WriteRuntime: %v", err)
+	}
+	return reg
+}
+
+func spawnSleeper(t *testing.T, reg *session.Registry) session.Handle {
+	t.Helper()
+	h, err := reg.Spawn(session.SpawnOpts{Cmd: []string{"sleep", "5"}, Cols: 80, Rows: 24})
+	if err != nil {
+		t.Fatalf("Spawn: %v", err)
+	}
+	t.Cleanup(func() { _ = h.Close() })
+	return h
+}
+
+func TestRunCloseAllClosesEverySession(t *testing.T) {
+	reg := newCloseTestDaemon(t)
+	spawnSleeper(t, reg)
+	spawnSleeper(t, reg)
+
+	var out, errOut bytes.Buffer
+	if err := runClose(&out, &errOut, []string{"--all"}); err != nil {
+		t.Fatalf("runClose: %v", err)
+	}
+	if !strings.Contains(out.String(), "✓ closed 2 sessions") {
+		t.Errorf("output %q does not report the two closed sessions", out.String())
+	}
+	if left := reg.List(); len(left) != 0 {
+		t.Errorf("the registry still holds %d sessions", len(left))
+	}
+}
+
+// TestRunCloseByIDClosesOnlyTheNamedOne also pins the singular: one session
+// closed is "1 session", not "1 sessions".
+func TestRunCloseByIDClosesOnlyTheNamedOne(t *testing.T) {
+	reg := newCloseTestDaemon(t)
+	going := spawnSleeper(t, reg)
+	staying := spawnSleeper(t, reg)
+
+	var out, errOut bytes.Buffer
+	if err := runClose(&out, &errOut, []string{going.ID()}); err != nil {
+		t.Fatalf("runClose: %v", err)
+	}
+	if !strings.Contains(out.String(), "✓ closed 1 session\n") {
+		t.Errorf("output %q, want the singular closed line", out.String())
+	}
+	if _, ok := reg.Get(going.ID()); ok {
+		t.Error("the named session is still in the registry")
+	}
+	if _, ok := reg.Get(staying.ID()); !ok {
+		t.Error("the unnamed session went with it")
+	}
+}
+
+// TestRunCloseReportsUnknownIDs: each id that named nothing is reported on
+// stderr by name, the ones that exist are closed anyway, and the command
+// fails — that is the errUnknownSessions cmdClose turns into exit 1.
+func TestRunCloseReportsUnknownIDs(t *testing.T) {
+	reg := newCloseTestDaemon(t)
+	real := spawnSleeper(t, reg)
+
+	var out, errOut bytes.Buffer
+	err := runClose(&out, &errOut, []string{real.ID(), "feedfeed00000000"})
+	if !errors.Is(err, errUnknownSessions) {
+		t.Fatalf("runClose = %v, want errUnknownSessions", err)
+	}
+	if !strings.Contains(errOut.String(), "no such session: feedfeed00000000") {
+		t.Errorf("stderr %q does not name the unknown id", errOut.String())
+	}
+	if !strings.Contains(out.String(), "✓ closed 1 session\n") {
+		t.Errorf("output %q, want the real session still closed and counted", out.String())
+	}
+	if _, ok := reg.Get(real.ID()); ok {
+		t.Error("the real session is still in the registry")
+	}
+}
+
+// TestRunCloseWithNoArgumentsIsAUsageError: bare `flue close` could mean
+// either form, so it gets the usage line naming both — errCloseUsage, which
+// cmdClose turns into exit 2 — and never talks to the daemon at all.
+func TestRunCloseWithNoArgumentsIsAUsageError(t *testing.T) {
+	var out, errOut bytes.Buffer
+	err := runClose(&out, &errOut, nil)
+	if !errors.Is(err, errCloseUsage) {
+		t.Fatalf("runClose = %v, want errCloseUsage", err)
+	}
+	for _, form := range []string{"--all", "<id>"} {
+		if !strings.Contains(err.Error(), form) {
+			t.Errorf("usage error %q does not show the %s form", err, form)
+		}
+	}
+}
+
+func TestRunCloseSaysDaemonNotRunning(t *testing.T) {
+	t.Setenv("XDG_CONFIG_HOME", t.TempDir()) // no runtime record, no daemon
+
+	var out, errOut bytes.Buffer
+	if err := runClose(&out, &errOut, []string{"--all"}); err != nil {
+		t.Fatalf("runClose = %v, want nil: nothing to close is not a failure", err)
+	}
+	if !strings.Contains(out.String(), "daemon not running; nothing to close") {
+		t.Errorf("output %q, want the not-running notice", out.String())
+	}
+}
+
+func TestUsageMentionsClose(t *testing.T) {
+	if !strings.Contains(usageText, "flue close") {
+		t.Fatalf("usage text does not mention %q:\n%s", "flue close", usageText)
+	}
+}

cmd/flue/main.go

@@ -80,6 +80,8 @@ func main() {
 		err = cmdServe(os.Args[2:])
 	case "open":
 		err = cmdOpen(os.Args[2:])
+	case "close":
+		err = cmdClose(os.Args[2:])
 	case "enable":
 		err = cmdEnable()
 	case "disable":
@@ -124,6 +126,7 @@ const usageText = `flue — your terminal, as a browser tab
   flue relay leave        take this machine off its relay; the Worker stays deployed
   flue relay reset        empty the relay's fleet directory; the fleet republishes
   flue open [path]        spawn a session in path and open it in the browser
+  flue close <id>...      close the named sessions; --all closes every one
   flue serve [--port N] [--open]   run the daemon in the foreground
   flue update             download the newest release, swap this binary, restart the daemon
   flue version            print the version (also --version, -v)