From 95ae400392f07bfc0705c6abcc844b0632934b14 Mon Sep 17 00:00:00 2001 From: Geno Roupsky <185580+groupsky@users.noreply.github.com> Date: Thu, 19 Nov 2026 14:27:25 +0200 Subject: [PATCH 1/2] feat: /resume and /ask-again from Telegram, limited so they cannot undo a safety stop Fixes #33 Co-Authored-By: Claude Opus 5.5 --- DESIGN.md | 16 ++++- README.md | 12 +++- THREAT-MODEL.md | 15 +++- internal/gate/check.go | 58 +++++++++++++++- internal/gate/request_test.go | 107 +++++++++++++++++++++++++++++ internal/gate/run.go | 7 ++ internal/listener/listener.go | 26 ++++--- internal/listener/listener_test.go | 18 ++++- internal/spool/spool.go | 16 +++-- internal/state/state.go | 28 ++++++++ 10 files changed, 281 insertions(+), 22 deletions(-) diff --git a/DESIGN.md b/DESIGN.md index 9f7191c..c15f153 100644 --- a/DESIGN.md +++ b/DESIGN.md @@ -499,7 +499,21 @@ nothing): - Then the normal run goes on, so a stream of `/status` never stops the fetches. After a `/pause`, the run ends as paused. -To go on after `/pause`, root runs `pullgate status NAME --resume`. +**`/resume NAME` and `/ask-again NAME`** (code6x/pullgate#33) go the same +way, with request files `resume` and `ask-again`. They are limited, so +that they cannot undo a safety stop: + +- `resume`: root lifts the pause only if the pause file is one that + `/pause` wrote: a regular file of root, with one link, of exactly one + line `paused from Telegram at YYYY-MM-DD HH:MM UTC`. A pause by pullgate + itself (a cut-off apply), by root (`pullgate status --pause`) or with + any other text stays, and the reply says to run `pullgate status NAME + --resume` as root. `/resume` never ends the broken state (section 10). +- `ask-again`: root clears only an open question for the last tip (its + message may be lost; the next question has a new code) or an `expired` + mark. It refuses a tip that is skipped, failed, held, refused, failed its + check, or the failed commit of the broken state. Root's `pullgate status + NAME --ask-again` still clears every mark. **`/check`.** The listener writes a check request (section 8) only when all of these hold, else it writes nothing: diff --git a/README.md b/README.md index 74a577d..4cbf795 100644 --- a/README.md +++ b/README.md @@ -191,16 +191,24 @@ usual Apply question, or "No new commit (the applied commit is …)", or - Without `pullgate-check@NAME.path`, the request waits for the next timer run. -## Status and pause: `/status`, `/pause` +## Status and pause: `/status`, `/pause`, `/resume`, `/ask-again` - `/status` (all instances) or `/status NAME`: the mode, the applied commit, the last tip, the open question, paused or not and why, broken or not. It changes nothing. At most one answer per instance a minute. - `/pause NAME`: pauses the instance. Nothing is fetched, asked or applied - until root runs `pullgate status NAME --resume` on the host. If it is + you send `/resume NAME` (or root runs `pullgate status NAME --resume`). If it is paused already, the old pause stays as it is. A reason after NAME is not sent to the host. +- `/resume NAME`: lifts a pause that `/pause` set. Any other pause (one + that pullgate set itself after a cut-off apply, or one that root set) + stays: run `pullgate status NAME --resume` as root. +- `/ask-again NAME`: asks again about the newest commit, but only when its + question expired or was lost. A commit that was skipped, failed, held or + refused is not asked again from Telegram; root can, with + `pullgate status NAME --ask-again`. + As with `/check`, only your user ID in your chat counts, and the listener only writes a small request file; root does the work. diff --git a/THREAT-MODEL.md b/THREAT-MODEL.md index bdd766b..c68d5cb 100644 --- a/THREAT-MODEL.md +++ b/THREAT-MODEL.md @@ -479,7 +479,7 @@ until the owner resets it (DESIGN.md section 8). The run unit has no start limit, so the timer goes on. This denies; it never approves. A clock jump back of more than a minute allows one more run. -### T18b. `/status` and `/pause` from a stolen token or the listener +### T18b. `/status`, `/pause`, `/resume`, `/ask-again` from a stolen token or the listener *Attack.* Someone with the bot token, or a compromised listener, sends `/status` or `/pause`, or writes the request files directly. @@ -500,7 +500,18 @@ reads its own state and acts. So the most they can do: `/pause` cannot replace the reason of a safety pause, and a later limited `/resume` (code6x/pullgate#33) cannot use it to lift one. -They cannot resume, approve, or change the state: the state directory is +*`/resume` and `/ask-again`* (code6x/pullgate#33) can undo a stop, so +they are limited. `/resume` lifts only a pause whose file is exactly what +`/pause` writes (root's regular file, one link, one line in that form): +the only pause a thief could set anyway. A pause that pullgate set after a +cut-off apply, or that root set, stays, and so does the broken state +(T6). `/ask-again` clears only an expired mark or an open question; it +never re-asks a commit that the owner skipped or that failed, was held or +was refused, so a thief cannot re-ask a skipped commit and hope for a +wrong tap. A new question still needs the owner's tap, and counts in +`questions_per_day`. + +Apart from that, they cannot approve or change the state: the state directory is root's (0700), and any other file in the check directory is removed and does nothing (a test). diff --git a/internal/gate/check.go b/internal/gate/check.go index 1e84e08..4ee4282 100644 --- a/internal/gate/check.go +++ b/internal/gate/check.go @@ -48,7 +48,7 @@ func (e *Env) pauseRequest(st *state.State) { text = "⏸ " + e.Cfg.Name + " was paused already: " + message.Code(e.Dir.PauseReason()) default: e.Log.Info("paused from Telegram") - text = "⏸ " + e.Cfg.Name + " is paused. Nothing is fetched, asked or applied. To go on, run as root: pullgate status " + e.Cfg.Name + " --resume" + text = "⏸ " + e.Cfg.Name + " is paused. Nothing is fetched, asked or applied. To go on, send /resume " + e.Cfg.Name + "." } if d := now.Sub(st.PauseNote); d >= CheckInterval || d <= -CheckInterval { st.PauseNote = now @@ -56,6 +56,62 @@ func (e *Env) pauseRequest(st *state.State) { } } +// resumeRequest acts on /resume: it lifts only a pause that /pause wrote +// (code6x/pullgate#33). A pause by pullgate itself (a cut-off apply) or by +// root stays: a compromised listener must not undo a safety stop. +func (e *Env) resumeRequest(st *state.State) { + var text string + switch { + case !e.Dir.Paused(): + text = e.Cfg.Name + " is not paused." + case !e.Dir.TelegramPaused(e.UID): + text = "⏸ " + e.Cfg.Name + " stays paused: this pause was not set from Telegram (" + message.Code(e.Dir.PauseReason()) + "), so /resume does not lift it. Check the host, then run as root: pullgate status " + e.Cfg.Name + " --resume" + default: + if err := e.Dir.Resume(); err != nil { + e.Log.Error("remove the pause file", "err", err) + text = "Error: " + e.Cfg.Name + " could not be resumed. See the journal of the host." + break + } + e.Log.Info("resumed from Telegram") + text = "▶ " + e.Cfg.Name + " goes on." + if st.Broken != nil { + text += " It is still broken: only a fix forward is asked." + } + } + e.notice(text) +} + +// askAgainRequest acts on /ask-again: it asks again only about a question +// that expired or was lost (an open one), never about a commit that was +// skipped, failed, held, refused or failed its check (code6x/pullgate#33). +func (e *Env) askAgainRequest(st *state.State) { + tip := st.LastTip + m := st.Marks[tip] + switch { + case tip == "" || tip == st.Applied: + e.notice("Nothing to ask again: there is no new commit.") + case st.Broken != nil && (tip == st.Broken.SHA || tip == st.Broken.OldSHA): + e.notice("Not asked again: " + code(tip) + " is the failed commit of the broken state. Push a fix forward, or check the host and run as root: pullgate status " + e.Cfg.Name + " --resume") + case tip == st.Held: + e.notice("Not asked again: the apply of " + code(tip) + " failed and it is held. To try it again, run as root: pullgate status " + e.Cfg.Name + " --ask-again") + case m != nil && m.Mark == state.MarkAsked: + if q := forgetOpen(st, tip); q != nil && !q.Auto { + e.edit(q.ID, "This question for "+code(q.SHA)+" is closed: the owner sent /ask-again. The next question has a new code.") + } + delete(st.Marks, tip) + e.Log.Info("ask again from Telegram: open question", "sha", tip) + e.notice("Asking again about " + code(tip) + ".") + case m != nil && m.Mark == state.MarkExpired: + delete(st.Marks, tip) + e.Log.Info("ask again from Telegram: expired question", "sha", tip) + e.notice("Asking again about " + code(tip) + ".") + case m == nil: + e.notice("Nothing to ask again: " + code(tip) + " has no question that expired or was lost.") + default: + e.notice("Not asked again: " + code(tip) + " was " + m.Mark + ". /ask-again asks only about a question that expired or was lost. To ask anyway, run as root: pullgate status " + e.Cfg.Name + " --ask-again") + } +} + // statusRequest answers /status with the facts of "pullgate status", // at most once a minute. func (e *Env) statusRequest(st *state.State) { diff --git a/internal/gate/request_test.go b/internal/gate/request_test.go index c852328..7732ec4 100644 --- a/internal/gate/request_test.go +++ b/internal/gate/request_test.go @@ -113,3 +113,110 @@ func TestListenerCannotPauseByOtherFiles(t *testing.T) { }) } } + +func TestResumeLiftsOnlyATelegramPause(t *testing.T) { + cases := map[string]func(f *fixture){ + "root --pause": func(f *fixture) { _ = f.env.Status(new(strings.Builder), StatusFlags{Pause: true}) }, + "cut off": func(f *fixture) { _ = f.env.Dir.Pause("the apply of x was cut off") }, + "planted prefix": func(f *fixture) { _ = f.env.Dir.Pause(state.TelegramPause + "2026-11-11 12:00 UTC and more") }, + "two lines": func(f *fixture) { _ = f.env.Dir.Pause(state.TelegramPause + "2026-11-11 12:00 UTC\nx") }, + "telegram": nil, + } + for name, pause := range cases { + t.Run(name, func(t *testing.T) { + f := newFixture(t, ``, "") + f.applyNew("one") + if pause == nil { + f.requestKind(spool.RequestPause) + f.run() + } else { + pause(f) + } + f.outbox() + f.requestKind(spool.RequestResume) + f.run() + out := f.outbox() + if pause == nil { + if f.env.Dir.Paused() || !contains(out, "goes on") { + t.Fatal("/resume must lift a /pause") + } + return + } + if !f.env.Dir.Paused() || !contains(out, "this pause was not set from Telegram") { + t.Fatalf("/resume must not lift this pause: %+v", out) + } + }) + } +} + +func TestResumeDoesNotEndBroken(t *testing.T) { + f := newFixture(t, `on_failure = "rollback"`, "") + breakIt(t, f) + f.requestKind(spool.RequestPause) + f.run() + f.requestKind(spool.RequestResume) + f.run() + if f.env.Dir.Paused() || f.state().Broken == nil || !contains(f.outbox(), "still broken") { + t.Fatal("/resume lifts the pause, but the broken state stays") + } +} + +func TestAskAgainOnlyExpiredOrLost(t *testing.T) { + t.Run("expired", func(t *testing.T) { + f := newFixture(t, ``, "") + f.applyNew("one") + f.commit("second", "two", nil) + f.run() + f.ask() + f.now = f.now.Add(13 * time.Hour) // approval_ttl is 12h + if r := f.run(); r != Nothing { + t.Fatalf("after expiry: %s", r) + } + f.outbox() + f.requestKind(spool.RequestAskAgain) + if r := f.run(); r != Asked { + t.Fatalf("/ask-again on an expired question: %s", r) + } + }) + t.Run("lost", func(t *testing.T) { + f := newFixture(t, ``, "") + f.applyNew("one") + f.commit("second", "two", nil) + f.run() + old := f.ask() // as if it never reached the chat + f.requestKind(spool.RequestAskAgain) + if r := f.run(); r != Asked { + t.Fatalf("/ask-again on an open question: %s", r) + } + if f.ask().Code == old.Code { + t.Fatal("the new question needs a new code") + } + }) + for _, mark := range []string{"skipped", "failed", "held", "refused", "check-failed"} { + t.Run(mark, func(t *testing.T) { + f := newFixture(t, ``, "") + f.applyNew("one") + sha := f.commit("second", "two", nil) + f.run() + f.outbox() + st := f.state() + st.Questions = nil + if mark == "held" { + st.Held = sha + st.SetMark(sha, state.MarkFailed, f.now) + } else { + st.SetMark(sha, mark, f.now) + } + if err := f.env.Dir.Save(st); err != nil { + t.Fatal(err) + } + f.requestKind(spool.RequestAskAgain) + if r := f.run(); r != Nothing { + t.Fatalf("/ask-again on %s: %s", mark, r) + } + if !contains(f.outbox(), "Not asked again") { + t.Fatal("no reply") + } + }) + } +} diff --git a/internal/gate/run.go b/internal/gate/run.go index c616840..638d7f4 100644 --- a/internal/gate/run.go +++ b/internal/gate/run.go @@ -161,6 +161,13 @@ func (e *Env) Run(ctx context.Context) (Result, error) { e.pauseRequest(st) paused = e.Dir.Paused() } + if requests.Resume > 0 { + e.resumeRequest(st) + paused = e.Dir.Paused() + } + if requests.AskAgain > 0 { + e.askAgainRequest(st) + } if requests.Status > 0 { e.statusRequest(st) } diff --git a/internal/listener/listener.go b/internal/listener/listener.go index 1f29422..a187d52 100644 --- a/internal/listener/listener.go +++ b/internal/listener/listener.go @@ -431,8 +431,10 @@ const updateCommand = "/update" // statusCommand and pauseCommand ask root for the status, or to pause an // instance (code6x/pullgate#32). const ( - statusCommand = "/status" - pauseCommand = "/pause" + statusCommand = "/status" + pauseCommand = "/pause" + resumeCommand = "/resume" // code6x/pullgate#33 + askAgainCommand = "/ask-again" // code6x/pullgate#33 ) // RequestGap is the least time between two /status or two /pause for the @@ -459,8 +461,8 @@ func (l *Listener) request(ctx context.Context, m *telegram.Message, kind string default: l.Log.Info("message ignored", "reason", "bad "+kind+" arguments", "from", fromID(m)) use := "/status or /status NAME" - if kind == spool.RequestPause { - use = "/pause NAME" + if kind != spool.RequestStatus { + use = "/" + kind + " NAME" } l.sendReply(ctx, m, "Use "+use+". NAME is one of: "+html.EscapeString(strings.Join(l.Cfg.Instances, ", "))+".") return @@ -488,10 +490,8 @@ func (l *Listener) request(ctx context.Context, m *telegram.Message, kind string l.Log.Info(kind+" request taken", "instances", ok) var text []string if len(ok) > 0 { - verb := "Asking for the status of" - if kind == spool.RequestPause { - verb = "Pausing" - } + verb := map[string]string{spool.RequestStatus: "Asking for the status of", spool.RequestPause: "Pausing", + spool.RequestResume: "Asking to resume", spool.RequestAskAgain: "Asking to ask again on"}[kind] line := verb + " " + html.EscapeString(strings.Join(ok, ", ")) + "…" if kind == spool.RequestPause && len(f) > 2 { line += " (the reason is not sent to the host: a request holds no text)" @@ -523,7 +523,9 @@ func (l *Listener) helpText() string { "/check: look for a new commit now, on every instance", "/check NAME: the same, on one instance", "/status or /status NAME: the mode, the applied commit, the open question, paused or not", - "/pause NAME: stop the instance; to go on, root runs pullgate status NAME --resume", + "/pause NAME: stop the instance", + "/resume NAME: go on after a /pause; any other pause needs root", + "/ask-again NAME: ask again about a question that expired or was lost", "/update: look for a new release of pullgate; a question asks before it is installed", "/help: this list", "", @@ -557,7 +559,7 @@ func (l *Listener) command(ctx context.Context, m *telegram.Message) { l.update(ctx, m) return } - if why == spool.RequestStatus || why == spool.RequestPause { + if why == spool.RequestStatus || why == spool.RequestPause || why == spool.RequestResume || why == spool.RequestAskAgain { l.request(ctx, m, why) return } @@ -629,6 +631,10 @@ func (l *Listener) checkNames(m *telegram.Message) ([]string, string, bool) { return nil, spool.RequestStatus, false case firstWord(m.Text) == pauseCommand: return nil, spool.RequestPause, false + case firstWord(m.Text) == resumeCommand: + return nil, spool.RequestResume, false + case firstWord(m.Text) == askAgainCommand: + return nil, spool.RequestAskAgain, false case !strings.HasPrefix(m.Text, checkCommand): return nil, "not a command", false case m.Text == checkCommand: diff --git a/internal/listener/listener_test.go b/internal/listener/listener_test.go index cf75516..bf000d5 100644 --- a/internal/listener/listener_test.go +++ b/internal/listener/listener_test.go @@ -393,7 +393,7 @@ func TestHelp(t *testing.T) { if len(ms) != 1 || ms[0].Chat != chat || ms[0].ReplyTo == 0 { t.Fatalf("want one reply: %+v", ms) } - for _, want := range []string{"/check", "/check NAME", "/help", "" + inst + "", "" + inst2 + "", "Apply", "Skip", "--pause", "--resume", "--ask-again", "/status", "/pause NAME"} { + for _, want := range []string{"/check", "/check NAME", "/help", "" + inst + "", "" + inst2 + "", "Apply", "Skip", "--pause", "--resume", "--ask-again", "/status", "/pause NAME", "/resume NAME", "/ask-again NAME"} { if !strings.Contains(ms[0].Text, want) { t.Errorf("the help must hold %q:\n%s", want, ms[0].Text) } @@ -664,3 +664,19 @@ func TestStatusAndPauseNotForOthers(t *testing.T) { t.Fatal("others get no reply and write no request") } } + +func TestResumeAndAskAgainCommands(t *testing.T) { + f := newL(t) + f.say(owner, chat, "/resume "+inst, false) + f.say(owner, chat, "/ask-again "+inst, false) + f.say(owner, chat, "/resume", false) // needs a name + f.say(owner, chat, "/ask-again "+inst+" x", false) // no more words + f.say(999, chat, "/resume "+inst, false) // not the owner + r, bad, err := f.d.TakeRequests(os.Geteuid()) + if r != (spool.Requests{Resume: 1, AskAgain: 1}) || len(bad) != 0 || err != nil { + t.Fatalf("requests: %+v %v %v", r, bad, err) + } + if ms := f.tg.Messages(); len(ms) != 4 { + t.Fatalf("want 2 answers and 2 usage replies, got %+v", ms) + } +} diff --git a/internal/spool/spool.go b/internal/spool/spool.go index 5a244e4..c7b9413 100644 --- a/internal/spool/spool.go +++ b/internal/spool/spool.go @@ -261,23 +261,25 @@ func (d Dirs) HasCheck() bool { // one file name, and its content is the name and a newline: no data from // the message. const ( - RequestStatus = "status" - RequestPause = "pause" + RequestStatus = "status" + RequestPause = "pause" + RequestResume = "resume" // code6x/pullgate#33 + RequestAskAgain = "ask-again" // code6x/pullgate#33 ) // WriteRequest writes a status or pause request (the listener). func (d Dirs) WriteRequest(kind string) error { - if kind != RequestStatus && kind != RequestPause { + if kind != RequestStatus && kind != RequestPause && kind != RequestResume && kind != RequestAskAgain { return fmt.Errorf("unknown request kind %q", kind) } return writeIn(d.CheckDir(), []byte(kind+"\n"), 0o600, -1, kind) } // Requests counts the valid requests that TakeRequests took. -type Requests struct{ Check, Status, Pause int } +type Requests struct{ Check, Status, Pause, Resume, AskAgain int } // Any reports whether there was a valid request. -func (r Requests) Any() bool { return r.Check+r.Status+r.Pause > 0 } +func (r Requests) Any() bool { return r.Check+r.Status+r.Pause+r.Resume+r.AskAgain > 0 } // TakeChecks is TakeRequests, for callers that know only check requests. func (d Dirs) TakeChecks(listenerUID int) (int, []error, error) { @@ -319,6 +321,10 @@ func (d Dirs) TakeRequests(listenerUID int) (Requests, []error, error) { count, want = &r.Status, RequestStatus+"\n" case RequestPause: count, want = &r.Pause, RequestPause+"\n" + case RequestResume: + count, want = &r.Resume, RequestResume+"\n" + case RequestAskAgain: + count, want = &r.AskAgain, RequestAskAgain+"\n" } switch { case err != nil: diff --git a/internal/state/state.go b/internal/state/state.go index a9e2420..4e35252 100644 --- a/internal/state/state.go +++ b/internal/state/state.go @@ -15,6 +15,7 @@ import ( "io/fs" "os" "path/filepath" + "regexp" "sort" "strings" "syscall" @@ -271,6 +272,33 @@ func (d Dir) PauseReason() string { return line } +// telegramPauseRE is the whole first line of a pause from /pause. +var telegramPauseRE = regexp.MustCompile(`^` + regexp.QuoteMeta(TelegramPause) + `[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2} UTC$`) + +// TelegramPaused reports whether the pause file is one that /pause wrote: +// a regular file of uid, not linked twice, of one line that is exactly the +// reason of /pause. Any other pause (by pullgate itself or by root) is not. +func (d Dir) TelegramPaused(uid uint32) bool { + f, err := os.OpenFile(d.PauseFile(), os.O_RDONLY|syscall.O_NOFOLLOW|syscall.O_NONBLOCK, 0) + if err != nil { + return false + } + defer func() { _ = f.Close() }() + fi, err := f.Stat() + if err != nil { + return false + } + st, ok := fi.Sys().(*syscall.Stat_t) + if !ok || !fi.Mode().IsRegular() || st.Uid != uid || st.Nlink != 1 || fi.Size() > 100 { + return false + } + b, err := io.ReadAll(io.LimitReader(f, 101)) + if err != nil { + return false + } + return telegramPauseRE.MatchString(strings.TrimSuffix(string(b), "\n")) && strings.Count(string(b), "\n") == 1 +} + // Resume removes the pause file. func (d Dir) Resume() error { err := os.Remove(d.PauseFile()) From 79a246d6b62283add0f801728e8d7b9d2415d154 Mon Sep 17 00:00:00 2001 From: Geno Roupsky <185580+groupsky@users.noreply.github.com> Date: Thu, 19 Nov 2026 14:31:29 +0200 Subject: [PATCH 2/2] fix: review findings of /resume and /ask-again Co-Authored-By: Claude Opus 5.5 --- DESIGN.md | 7 +++- README.md | 5 ++- THREAT-MODEL.md | 6 ++- internal/gate/apply.go | 2 +- internal/gate/check.go | 34 ++++++++++++++--- internal/gate/request_test.go | 70 +++++++++++++++++++++++++++++++++++ internal/gate/run.go | 11 +++--- internal/state/state.go | 36 ++++++++++++++++++ 8 files changed, 154 insertions(+), 17 deletions(-) diff --git a/DESIGN.md b/DESIGN.md index c15f153..c92799a 100644 --- a/DESIGN.md +++ b/DESIGN.md @@ -511,8 +511,11 @@ that they cannot undo a safety stop: --resume` as root. `/resume` never ends the broken state (section 10). - `ask-again`: root clears only an open question for the last tip (its message may be lost; the next question has a new code) or an `expired` - mark. It refuses a tip that is skipped, failed, held, refused, failed its - check, or the failed commit of the broken state. Root's `pullgate status + mark, and saves the state before the listener closes the message. It + refuses every other case: a tip that is skipped, failed, held, refused, + failed its check, the failed commit of the broken state, or an instance + that is paused or off. When `resume` and `pause` come in one run, the + pause wins. Root's `pullgate status NAME --ask-again` still clears every mark. **`/check`.** The listener writes a check request (section 8) only when all diff --git a/README.md b/README.md index 4cbf795..f563b31 100644 --- a/README.md +++ b/README.md @@ -197,11 +197,12 @@ usual Apply question, or "No new commit (the applied commit is …)", or commit, the last tip, the open question, paused or not and why, broken or not. It changes nothing. At most one answer per instance a minute. - `/pause NAME`: pauses the instance. Nothing is fetched, asked or applied - you send `/resume NAME` (or root runs `pullgate status NAME --resume`). If it is + until you send `/resume NAME` (or root runs `pullgate status NAME --resume`). If it is paused already, the old pause stays as it is. A reason after NAME is not sent to the host. -- `/resume NAME`: lifts a pause that `/pause` set. Any other pause (one +- `/resume NAME`: lifts a pause that `/pause` set. Whoever holds the bot + token can do that too: if you suspect the token, pause as root. Any other pause (one that pullgate set itself after a cut-off apply, or one that root set) stays: run `pullgate status NAME --resume` as root. - `/ask-again NAME`: asks again about the newest commit, but only when its diff --git a/THREAT-MODEL.md b/THREAT-MODEL.md index c68d5cb..9b11e1d 100644 --- a/THREAT-MODEL.md +++ b/THREAT-MODEL.md @@ -503,7 +503,11 @@ reads its own state and acts. So the most they can do: *`/resume` and `/ask-again`* (code6x/pullgate#33) can undo a stop, so they are limited. `/resume` lifts only a pause whose file is exactly what `/pause` writes (root's regular file, one link, one line in that form): -the only pause a thief could set anyway. A pause that pullgate set after a +the only pause a thief could set anyway. So if the owner suspects the +token or the listener, the owner pauses as root (`pullgate status NAME +--pause`): a token holder can lift a `/pause`. `/resume` moves the file +aside and checks that it is the file it checked, so a pause that root +writes at the same moment is put back and stays. A pause that pullgate set after a cut-off apply, or that root set, stays, and so does the broken state (T6). `/ask-again` clears only an expired mark or an open question; it never re-asks a commit that the owner skipped or that failed, was held or diff --git a/internal/gate/apply.go b/internal/gate/apply.go index 3cdaa9c..789b37c 100644 --- a/internal/gate/apply.go +++ b/internal/gate/apply.go @@ -124,7 +124,7 @@ func (e *Env) ignoreAll(st *state.State, paused bool) (Result, error) { why := "the instance is off (mode = \"off\")." res := Off if paused { - why = "the instance is paused. Run as root: pullgate status " + e.Cfg.Name + " --resume" + why = "the instance is paused. " + e.resumeHint() res = Paused } for { diff --git a/internal/gate/check.go b/internal/gate/check.go index 4ee4282..167c345 100644 --- a/internal/gate/check.go +++ b/internal/gate/check.go @@ -4,6 +4,7 @@ import ( "strings" "time" + "github.com/code6x/pullgate/internal/config" "github.com/code6x/pullgate/internal/message" "github.com/code6x/pullgate/internal/spool" @@ -27,11 +28,20 @@ func (e *Env) takeChecks() spool.Requests { e.Log.Error("read the check requests", "err", err) } if r.Any() { - e.Log.Info("requests taken", "check", r.Check, "status", r.Status, "pause", r.Pause) + e.Log.Info("requests taken", "check", r.Check, "status", r.Status, "pause", r.Pause, "resume", r.Resume, "ask-again", r.AskAgain) } return r } +// resumeHint says how to go on after a pause: /resume for a /pause, else +// root. +func (e *Env) resumeHint() string { + if e.Dir.TelegramPaused(e.UID) { + return "Send /resume " + e.Cfg.Name + "" + } + return "Run as root: pullgate status " + e.Cfg.Name + " --resume" +} + // pauseRequest acts on /pause: it writes the pause file, unless there is // one. A pause that is there already is never changed, so that a later // /resume (code6x/pullgate#33) cannot lift it. The pause itself is never @@ -64,14 +74,17 @@ func (e *Env) resumeRequest(st *state.State) { switch { case !e.Dir.Paused(): text = e.Cfg.Name + " is not paused." - case !e.Dir.TelegramPaused(e.UID): - text = "⏸ " + e.Cfg.Name + " stays paused: this pause was not set from Telegram (" + message.Code(e.Dir.PauseReason()) + "), so /resume does not lift it. Check the host, then run as root: pullgate status " + e.Cfg.Name + " --resume" default: - if err := e.Dir.Resume(); err != nil { + lifted, err := e.Dir.ResumeTelegram(e.UID) + if err != nil { e.Log.Error("remove the pause file", "err", err) text = "Error: " + e.Cfg.Name + " could not be resumed. See the journal of the host." break } + if !lifted { + text = "⏸ " + e.Cfg.Name + " stays paused: this pause was not set from Telegram (" + message.Code(e.Dir.PauseReason()) + "), so /resume does not lift it. Check the host, then run as root: pullgate status " + e.Cfg.Name + " --resume" + break + } e.Log.Info("resumed from Telegram") text = "▶ " + e.Cfg.Name + " goes on." if st.Broken != nil { @@ -88,6 +101,8 @@ func (e *Env) askAgainRequest(st *state.State) { tip := st.LastTip m := st.Marks[tip] switch { + case e.Dir.Paused() || e.Cfg.Mode == config.ModeOff: + e.notice("Not asked again: " + e.Cfg.Name + " is paused or off. Resume it first.") case tip == "" || tip == st.Applied: e.notice("Nothing to ask again: there is no new commit.") case st.Broken != nil && (tip == st.Broken.SHA || tip == st.Broken.OldSHA): @@ -95,10 +110,17 @@ func (e *Env) askAgainRequest(st *state.State) { case tip == st.Held: e.notice("Not asked again: the apply of " + code(tip) + " failed and it is held. To try it again, run as root: pullgate status " + e.Cfg.Name + " --ask-again") case m != nil && m.Mark == state.MarkAsked: - if q := forgetOpen(st, tip); q != nil && !q.Auto { + q := forgetOpen(st, tip) + delete(st.Marks, tip) + // Save first: the listener forgets the code only when root has. + if err := e.Dir.Save(st); err != nil { + e.Log.Error("save the state", "err", err) + e.notice("Error: the question could not be closed. See the journal of the host.") + return + } + if q != nil && !q.Auto { e.edit(q.ID, "This question for "+code(q.SHA)+" is closed: the owner sent /ask-again. The next question has a new code.") } - delete(st.Marks, tip) e.Log.Info("ask again from Telegram: open question", "sha", tip) e.notice("Asking again about " + code(tip) + ".") case m != nil && m.Mark == state.MarkExpired: diff --git a/internal/gate/request_test.go b/internal/gate/request_test.go index 7732ec4..5d6cf2a 100644 --- a/internal/gate/request_test.go +++ b/internal/gate/request_test.go @@ -220,3 +220,73 @@ func TestAskAgainOnlyExpiredOrLost(t *testing.T) { }) } } + +func TestTelegramPauseFileForm(t *testing.T) { + good := state.TelegramPause + "2026-11-11 12:00 UTC" + for name, setup := range map[string]func(f *fixture){ + "hard link": func(f *fixture) { + _ = f.env.Dir.Pause(good) + _ = os.Link(f.env.Dir.PauseFile(), f.env.Dir.PauseFile()+"2") + }, + "symlink": func(f *fixture) { + other := filepath.Join(f.base, "other") + _ = os.WriteFile(other, []byte(good+"\n"), 0o644) + _ = os.Symlink(other, f.env.Dir.PauseFile()) + }, + "trailing space": func(f *fixture) { _ = f.env.Dir.Pause(good + " ") }, + "not UTC": func(f *fixture) { _ = f.env.Dir.Pause(state.TelegramPause + "2026-11-11 12:00 CET") }, + } { + t.Run(name, func(t *testing.T) { + f := newFixture(t, ``, "") + if err := f.env.Dir.Ensure(); err != nil { + t.Fatal(err) + } + setup(f) + if f.env.Dir.TelegramPaused(f.env.UID) { + t.Fatal("must not count as a /pause") + } + if ok, _ := f.env.Dir.ResumeTelegram(f.env.UID); ok || !f.env.Dir.Paused() { + t.Fatal("must not be lifted") + } + }) + } +} + +func TestPauseWinsOverResumeInOneRun(t *testing.T) { + f := newFixture(t, ``, "") + f.applyNew("one") + f.requestKind(spool.RequestPause) + f.run() + f.now = f.now.Add(2 * time.Minute) + f.requestKind(spool.RequestResume) + f.requestKind(spool.RequestPause) + f.run() + if !f.env.Dir.Paused() { + t.Fatal("with /resume and /pause in one run, the pause wins") + } +} + +func TestAskAgainRefusedWhilePausedOrBroken(t *testing.T) { + f := newFixture(t, `on_failure = "rollback"`, "") + breakIt(t, f) + f.outbox() + f.requestKind(spool.RequestAskAgain) + f.run() + if !contains(f.outbox(), "failed commit of the broken state") { + t.Fatal("/ask-again must refuse the broken failed commit") + } + g := newFixture(t, ``, "") + g.applyNew("one") + g.commit("second", "two", nil) + g.run() + q := g.ask() + _ = g.env.Dir.Pause("paused by the owner") + g.requestKind(spool.RequestAskAgain) + g.run() + if !contains(g.outbox(), "is paused or off") { + t.Fatal("/ask-again while paused must be refused") + } + if g.state().FindCode(q.Code) < 0 { + t.Fatal("the question must stay while paused") + } +} diff --git a/internal/gate/run.go b/internal/gate/run.go index 638d7f4..4a62e45 100644 --- a/internal/gate/run.go +++ b/internal/gate/run.go @@ -157,14 +157,15 @@ func (e *Env) Run(ctx context.Context) (Result, error) { if err != nil { return "", err } - if requests.Pause > 0 { - e.pauseRequest(st) - paused = e.Dir.Paused() - } + // Resume before pause: when both came, the pause wins (fail closed). if requests.Resume > 0 { e.resumeRequest(st) paused = e.Dir.Paused() } + if requests.Pause > 0 { + e.pauseRequest(st) + paused = e.Dir.Paused() + } if requests.AskAgain > 0 { e.askAgainRequest(st) } @@ -186,7 +187,7 @@ func (e *Env) Run(ctx context.Context) (Result, error) { why := e.Cfg.Name + " is off (mode = \"off\"), so nothing was fetched." res := Off if paused { - why = e.Cfg.Name + " is paused, so nothing was fetched. Run as root: pullgate status " + e.Cfg.Name + " --resume" + why = e.Cfg.Name + " is paused, so nothing was fetched. " + e.resumeHint() res = Paused } e.Log.Info(string(res)) diff --git a/internal/state/state.go b/internal/state/state.go index 4e35252..b15792a 100644 --- a/internal/state/state.go +++ b/internal/state/state.go @@ -275,6 +275,38 @@ func (d Dir) PauseReason() string { // telegramPauseRE is the whole first line of a pause from /pause. var telegramPauseRE = regexp.MustCompile(`^` + regexp.QuoteMeta(TelegramPause) + `[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2} UTC$`) +// ResumeTelegram removes the pause file only if it is a /pause one +// (TelegramPaused). It moves the file aside first and checks that the file +// it moved is the one it checked; if not (root wrote a new pause in +// between), it puts that one back without replacing anything, and keeps +// the pause. It reports whether the pause was lifted. +func (d Dir) ResumeTelegram(uid uint32) (bool, error) { + f, err := os.OpenFile(d.PauseFile(), os.O_RDONLY|syscall.O_NOFOLLOW|syscall.O_NONBLOCK, 0) + if err != nil { + return false, nil + } + defer func() { _ = f.Close() }() + checked, err := f.Stat() + if err != nil || !telegramPauseFile(f, checked, uid) { + return false, nil + } + tmp := d.file(".resume-tmp") + _ = os.Remove(tmp) + if err := os.Rename(d.PauseFile(), tmp); err != nil { + return false, err + } + moved, err := os.Lstat(tmp) + if err != nil || !os.SameFile(checked, moved) { + // Not the file that was checked: put it back, never over a new one. + if lerr := os.Link(tmp, d.PauseFile()); lerr != nil && !errors.Is(lerr, fs.ErrExist) { + return false, lerr + } + _ = os.Remove(tmp) + return false, nil + } + return true, os.Remove(tmp) +} + // TelegramPaused reports whether the pause file is one that /pause wrote: // a regular file of uid, not linked twice, of one line that is exactly the // reason of /pause. Any other pause (by pullgate itself or by root) is not. @@ -288,6 +320,10 @@ func (d Dir) TelegramPaused(uid uint32) bool { if err != nil { return false } + return telegramPauseFile(f, fi, uid) +} + +func telegramPauseFile(f *os.File, fi os.FileInfo, uid uint32) bool { st, ok := fi.Sys().(*syscall.Stat_t) if !ok || !fi.Mode().IsRegular() || st.Uid != uid || st.Nlink != 1 || fi.Size() > 100 { return false