Allow Remote sessions to outlive connection forms
This commit is contained in:
1 parent
b60cf5d5f2
commit
b4896a2eb4
10 files changed
+231
-14
No files matched your search
@@ -117,11 +117,13 @@ speech-owner mutex as observed utterances. An older delivery generation cannot
|
||||
publish behind that cancel. Remote publication never performs pipe, relay or
|
||||
backend I/O in the input loop. Incoming cancellation ownership remains pending.
|
||||
|
||||
The source command still holds a modal status form for its connection lifetime.
|
||||
That form captures local keys and suppresses ordinary application presentation;
|
||||
this increment does not detach it or provide an ordinary desktop workflow.
|
||||
Keep relay-testing warnings until that UI lifetime and incoming speech ownership
|
||||
are implemented and live acceptance is recorded.
|
||||
The source command now offers an explicit Return to desktop action after its
|
||||
reader lease opens. It closes status and releases local input capture while the
|
||||
original lease and heartbeat worker remain active. The Remote shortcut reopens
|
||||
status/Disconnect. Lock/handoff, expiry and process loss still revoke the lease.
|
||||
See [the terminal interaction contract](tentacle-sessions.md#reader-owned-consent-interactions).
|
||||
Incoming speech ownership and live acceptance remain pending; relay-testing
|
||||
warnings remain in place.
|
||||
|
||||
## Verification and remaining work
|
||||
|
||||
@@ -160,7 +162,8 @@ speech/Remote/Tentacle race checks, affected-package vet, a separate reader
|
||||
build, the existing speech regression harness and Tentacles `make check`.
|
||||
|
||||
Next: add incoming speech ownership, delivery-time policy, local priority and
|
||||
remote-only cancellation, and detach connection status from desktop capture.
|
||||
remote-only cancellation. Explicit status detachment is implemented; physical
|
||||
input capture/release and ordinary reading while connected still need acceptance.
|
||||
Review remaining output producers before assigning exportable origins.
|
||||
Atomic IPC assembly is implemented; it does not establish backend
|
||||
priority/cancel behavior or audible delivery.
|
||||
|
||||
@@ -114,6 +114,29 @@ cleanup context, so pre-lease inspection does not depend on a revocation event.
|
||||
No form values accompany that cleanup. Session failure/disable still uses
|
||||
normal process supervision. Existing non-remote interactions keep their path.
|
||||
|
||||
An explicit return-to-desktop action may instead finish with:
|
||||
|
||||
```json
|
||||
{"remote_background":{"lease":"0123456789abcdef0123456789abcdef","epoch":1},"done":true}
|
||||
```
|
||||
|
||||
This terminal result requires an already-open, unexpired lease belonging to the
|
||||
requesting process session. If this interaction approved an epoch, it must match
|
||||
the requested lease. Forms, continuations, polling, clipboard, reader/consent
|
||||
requests and uninterruptible speech cannot accompany it; ordinary speech/Braille
|
||||
presentation is allowed. A polling response cannot detach a form. Go exposes
|
||||
`Interaction.RemoteBackground`; Python uses the dictionary above.
|
||||
|
||||
On success, core releases the interaction/result slots without invoking child
|
||||
cancellation or revoking that epoch. The original policy/session lease remains
|
||||
its owner: heartbeats, expiry, lock, handoff, disconnect, replacement, disable,
|
||||
update and process loss retain their existing behavior. This result neither
|
||||
renews authority nor starts networking. The Tentacle must offer an explicit
|
||||
status/disconnect command; reopening status needs no new consent, while a new
|
||||
connection still does. Ordinary cancellation and form closure retain their
|
||||
existing cleanup behavior. `RemoteLeaseContext` checks identity/lifetime only;
|
||||
desktop effects still require `RemoteContext` with their specific grant.
|
||||
|
||||
This addition requires the matching updated reader; protocol 1.1 by itself does
|
||||
not imply that an older reader accepts the new interaction field. Remote still
|
||||
has no release manifest advertising a minimum supported reader version.
|
||||
|
||||
@@ -76,6 +76,20 @@ func (runtime *tentacleRuntime) interact(ctx context.Context, command tentacleCo
|
||||
if runtime.output.gate.Locked() || runtime.output.gate.Suspended() {
|
||||
return
|
||||
}
|
||||
if value.RemoteBackground != nil {
|
||||
lease := *value.RemoteBackground
|
||||
lifetime, leaseErr := command.session.RemoteLeaseContext(lease)
|
||||
if leaseErr != nil || ctx.Err() != nil || lifetime.Err() != nil || approvedEpoch != 0 && approvedEpoch != lease.Epoch {
|
||||
runtime.report("Remote connection ended. Start a fresh access review.")
|
||||
return
|
||||
}
|
||||
// The reader lease already belongs to the policy/session owner.
|
||||
// Returning to the desktop releases form and interaction capture,
|
||||
// without extending consent or running the cancellation continuation.
|
||||
approvedEpoch, cleanupNext = 0, ""
|
||||
runtime.output.Present(runtime.output.Capture(command.session.OutputContext()), value.Presentation, "tentacle/"+command.id)
|
||||
return
|
||||
}
|
||||
cleanupNext = value.Next
|
||||
if value.Remote != nil {
|
||||
action, approvalErr := runtime.authorize_remote_session(ctx, command.session, value.Remote.Role, value.Remote.Grants)
|
||||
@@ -255,7 +269,7 @@ func (runtime *tentacleRuntime) waitTentacleForm(ctx context.Context, command te
|
||||
return internalUIResult{Cancelled: true}, nil
|
||||
}
|
||||
status, err := tentaclewire.DecodeInteraction(raw)
|
||||
if err != nil || status.Form != nil || status.Source != "" || status.Next != "" || status.Reader != nil || status.Remote != nil {
|
||||
if err != nil || status.Form != nil || status.Source != "" || status.Next != "" || status.Reader != nil || status.Remote != nil || status.RemoteBackground != nil {
|
||||
command.session.Disable()
|
||||
return internalUIResult{Cancelled: true}, nil
|
||||
}
|
||||
|
||||
@@ -222,8 +222,14 @@ func TestRemoteConnectionCommandCancelsInspectionOnHandoff(t *testing.T) {
|
||||
}
|
||||
|
||||
func TestRemoteConnectionCommandPrivateRelay(t *testing.T) {
|
||||
for _, role := range []string{"controller", "controlled"} {
|
||||
t.Run(role, func(t *testing.T) {
|
||||
for _, test := range []struct{ role, ending string }{
|
||||
{"controller", "disconnect"}, {"controlled", "disconnect"},
|
||||
{"controller", "lock"}, {"controlled", "lock"},
|
||||
{"controller", "handoff"}, {"controlled", "handoff"},
|
||||
{"controller", "disable"}, {"controlled", "disable"},
|
||||
} {
|
||||
role, ending := test.role, test.ending
|
||||
t.Run(role+"/"+ending, func(t *testing.T) {
|
||||
remoteText := " " + strings.Repeat("é\x00世界 ", 1500) + " "
|
||||
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
|
||||
if err != nil {
|
||||
@@ -299,7 +305,7 @@ func TestRemoteConnectionCommandPrivateRelay(t *testing.T) {
|
||||
}
|
||||
close(closed)
|
||||
}()
|
||||
runtime, forms, _ := remote_command_fixture(t)
|
||||
runtime, forms, shortcut := remote_command_fixture(t)
|
||||
if role == "controlled" {
|
||||
worker := runtime.output.speech
|
||||
worker.speaker = &fakeSpeaker{spoken: make(chan string, 16)}
|
||||
@@ -356,6 +362,18 @@ func TestRemoteConnectionCommandPrivateRelay(t *testing.T) {
|
||||
if status.form.Title != "Remote relay status" {
|
||||
t.Fatal("missing connection status")
|
||||
}
|
||||
// Open has already succeeded before the relay can join. Return to
|
||||
// ordinary desktop work without holding either runtime slot or form.
|
||||
status.reply <- internalUIResult{Activated: "desktop"}
|
||||
waitTentacle(t, func() bool { return len(runtime.resultSlots) == 0 && len(runtime.interactionSlots) == 0 })
|
||||
if status.ctx.Err() == nil {
|
||||
t.Fatal("background connection retained its form context")
|
||||
}
|
||||
select {
|
||||
case <-closed:
|
||||
t.Fatal("return to desktop disconnected the relay")
|
||||
default:
|
||||
}
|
||||
var delivery tentacle.RemoteSpeechDelivery
|
||||
if role == "controller" {
|
||||
select {
|
||||
@@ -393,6 +411,8 @@ func TestRemoteConnectionCommandPrivateRelay(t *testing.T) {
|
||||
// Joining at the relay is earlier than the Tentacle admitting the
|
||||
// peer. Poll status before testing actual output rather than
|
||||
// depending on a scheduling delay or replaying pre-peer output.
|
||||
runtime.Invoke(t.Context(), shortcut)
|
||||
status = next_remote_form(t, forms)
|
||||
deadline := time.Now().Add(5 * time.Second)
|
||||
for {
|
||||
encoded, _ := json.Marshal(status.form)
|
||||
@@ -405,6 +425,8 @@ func TestRemoteConnectionCommandPrivateRelay(t *testing.T) {
|
||||
status.reply <- internalUIResult{Activated: "refresh"}
|
||||
status = next_remote_form(t, forms)
|
||||
}
|
||||
status.reply <- internalUIResult{Activated: "desktop"}
|
||||
waitTentacle(t, func() bool { return len(runtime.resultSlots) == 0 })
|
||||
worker := runtime.output.speech
|
||||
for _, request := range []speechRequest{
|
||||
{Text: "private form", Cause: "internal-ui"},
|
||||
@@ -455,16 +477,41 @@ func TestRemoteConnectionCommandPrivateRelay(t *testing.T) {
|
||||
t.Fatal("observation leaked private text or lost resolved output/boundaries")
|
||||
}
|
||||
}
|
||||
// Reopening returns to this attempt, with no second consent or
|
||||
// saved-key read. Lifecycle retirement must work with no form open.
|
||||
switch ending {
|
||||
case "disconnect":
|
||||
runtime.Invoke(t.Context(), shortcut)
|
||||
status = next_remote_form(t, forms)
|
||||
if status.form.Title != "Remote relay status" {
|
||||
t.Fatal("reopening lost the approved connection")
|
||||
}
|
||||
status.reply <- internalUIResult{Activated: "cancel"}
|
||||
case "lock":
|
||||
runtime.output.gate.SetLocked(true, nil, nil, nil, nil, &brailleWorker{})
|
||||
runtime.output.gate.SetLocked(false, nil, nil, nil, nil, &brailleWorker{})
|
||||
case "handoff":
|
||||
runtime.output.gate.SetSuspended(true)
|
||||
runtime.output.gate.SetSuspended(false)
|
||||
case "disable":
|
||||
runtime.Disable()
|
||||
}
|
||||
select {
|
||||
case <-closed:
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("Disconnect and close retained the relay")
|
||||
t.Fatal("background connection retained the relay after " + ending)
|
||||
}
|
||||
waitTentacle(t, func() bool { return len(runtime.resultSlots) == 0 })
|
||||
if role == "controller" && delivery.Context.Err() == nil {
|
||||
if role == "controller" {
|
||||
// Socket cancellation precedes the final sequenced lease close.
|
||||
// A reopened status interaction did not issue the original consent,
|
||||
// so its result-slot completion is not the lease-close barrier.
|
||||
select {
|
||||
case <-delivery.Context.Done():
|
||||
case <-time.After(3 * time.Second):
|
||||
t.Fatal("Disconnect retained remote delivery authority")
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -144,6 +144,19 @@ func (session *Session) RemoteContext(lease tentaclewire.RemoteLease, grant stri
|
||||
return access.ctx, nil
|
||||
}
|
||||
|
||||
// RemoteLeaseContext checks process ownership and lifetime, without authorizing
|
||||
// any desktop effect. Core uses it when returning from a connection form to the
|
||||
// desktop; effect owners must still use RemoteContext with their specific grant.
|
||||
func (session *Session) RemoteLeaseContext(lease tentaclewire.RemoteLease) (context.Context, error) {
|
||||
session.mutex.Lock()
|
||||
defer session.mutex.Unlock()
|
||||
access := session.remote_lease_locked(lease)
|
||||
if access == nil {
|
||||
return nil, ErrPermission
|
||||
}
|
||||
return access.ctx, nil
|
||||
}
|
||||
|
||||
func (session *Session) release_remote_owner() {
|
||||
session.manager.remoteMutex.Lock()
|
||||
if session.manager.remoteOwner == session {
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
// Copyright (c) 2026 Storm Dragon
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
package tentacle
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.stormux.org/storm/cthulhu/internal/tentaclewire"
|
||||
)
|
||||
|
||||
func TestRemoteBackgroundLeaseOwnershipAndLifetime(t *testing.T) {
|
||||
for _, language := range []string{"go", "python"} {
|
||||
t.Run(language, func(t *testing.T) {
|
||||
manager := test_manager(t, DefaultLimits(), nil)
|
||||
policy := NewRemotePolicy()
|
||||
if err := manager.UseRemotePolicy(policy); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
session := startSessionSDK(t, manager, language, "speech")
|
||||
lease := speech_fixture_lease(t, session, "controlled", []string{"output-observe"})
|
||||
lifetime, err := session.RemoteLeaseContext(lease)
|
||||
if err != nil || lifetime.Err() != nil {
|
||||
t.Fatal("live owned lease unavailable", err)
|
||||
}
|
||||
for _, invalid := range []tentaclewire.RemoteLease{{}, {Lease: lease.Lease, Epoch: lease.Epoch + 1}, {Lease: strings.Repeat("b", 32), Epoch: lease.Epoch}} {
|
||||
if _, err := session.RemoteLeaseContext(invalid); err == nil {
|
||||
t.Fatal("invalid ownership accepted")
|
||||
}
|
||||
}
|
||||
if _, err := session.RemoteContext(lease, ""); err == nil {
|
||||
t.Fatal("ownership check bypassed desktop grant requirement")
|
||||
}
|
||||
other := startSessionSDK(t, manager, language, "speech-other")
|
||||
if _, err := other.RemoteLeaseContext(lease); err == nil {
|
||||
t.Fatal("another process session acquired lease ownership")
|
||||
}
|
||||
policy.SetAvailable(false)
|
||||
policy.SetAvailable(true)
|
||||
if lifetime.Err() == nil {
|
||||
t.Fatal("lock/handoff round trip retained background lifetime")
|
||||
}
|
||||
if _, err := session.RemoteLeaseContext(lease); err == nil {
|
||||
t.Fatal("background ownership survived policy retirement")
|
||||
}
|
||||
// A replacement remains distinct, even while old forms finish.
|
||||
session.RevokeRemote()
|
||||
invokeSessionSDK(t, session, "event", nil)
|
||||
replacement := speech_fixture_lease(t, session, "controlled", []string{"output-observe"})
|
||||
if _, err := session.RemoteLeaseContext(lease); err == nil {
|
||||
t.Fatal("old controls followed replacement consent")
|
||||
}
|
||||
session.RevokeRemoteEpoch(lease.Epoch)
|
||||
if _, err := session.RemoteLeaseContext(replacement); err != nil {
|
||||
t.Fatal("old cleanup retired replacement", err)
|
||||
}
|
||||
session.mutex.Lock()
|
||||
session.remote.deadline = time.Now().Add(-time.Second)
|
||||
session.mutex.Unlock()
|
||||
if _, err := session.RemoteLeaseContext(replacement); err == nil {
|
||||
t.Fatal("expired lease accepted for background ownership")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -47,8 +47,16 @@ func (session *Session) EnableRemoteSpeech() <-chan RemoteSpeechDelivery {
|
||||
}
|
||||
|
||||
func (session *Session) remote_access_locked(lease tentaclewire.RemoteLease, grant string) *remoteAccess {
|
||||
access := session.remote_lease_locked(lease)
|
||||
if access == nil || !slices.Contains(access.grants, grant) {
|
||||
return nil
|
||||
}
|
||||
return access
|
||||
}
|
||||
|
||||
func (session *Session) remote_lease_locked(lease tentaclewire.RemoteLease) *remoteAccess {
|
||||
access := session.remote
|
||||
if session.state != Active || access == nil || access.lease == "" || access.lease != lease.Lease || access.epoch != lease.Epoch || !time.Now().Before(access.deadline) || access.ctx.Err() != nil || !slices.Contains(access.grants, grant) {
|
||||
if session.state != Active || access == nil || access.lease == "" || access.lease != lease.Lease || access.epoch != lease.Epoch || !time.Now().Before(access.deadline) || access.ctx.Err() != nil {
|
||||
return nil
|
||||
}
|
||||
return access
|
||||
|
||||
@@ -26,6 +26,9 @@ type Interaction struct {
|
||||
Done bool `json:"done,omitempty"`
|
||||
Reader *ReaderRequest `json:"reader,omitempty"`
|
||||
Remote *RemoteRequest `json:"remote,omitempty"`
|
||||
// RemoteBackground ends this interaction while retaining an already-open
|
||||
// lease owned by this process session. It grants no new access or lifetime.
|
||||
RemoteBackground *RemoteLease `json:"remote_background,omitempty"`
|
||||
}
|
||||
|
||||
// RemoteRequest asks the reader to show its own local consent form. It never
|
||||
@@ -80,7 +83,11 @@ func DecodeInteraction(data []byte) (Interaction, error) {
|
||||
if value.Source != "" && value.Source != "focus" && value.Source != "clipboard" {
|
||||
return value, ErrProtocol
|
||||
}
|
||||
if value.Remote != nil {
|
||||
if value.RemoteBackground != nil {
|
||||
if len(value.RemoteBackground.Lease) != 32 || value.RemoteBackground.Epoch == 0 || !value.Done || value.Next != "" || value.Poll != "" || value.Form != nil || value.Source != "" || value.Clipboard != nil || value.Reader != nil || value.Remote != nil || value.Uninterruptible {
|
||||
return value, ErrProtocol
|
||||
}
|
||||
} else if value.Remote != nil {
|
||||
if !ValidRoleGrants(value.Remote.Role, value.Remote.Grants) || value.Next == "" || value.Reader != nil || value.Form != nil || value.Source != "" || value.Poll != "" || value.Clipboard != nil || value.Done {
|
||||
return value, ErrProtocol
|
||||
}
|
||||
|
||||
@@ -4,6 +4,7 @@ package tentaclewire
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
@@ -32,3 +33,29 @@ func TestRemoteConsentInteractionValidation(t *testing.T) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestRemoteBackgroundInteractionValidation(t *testing.T) {
|
||||
lease := RemoteLease{Lease: strings.Repeat("a", 32), Epoch: 1}
|
||||
valid := Interaction{RemoteBackground: &lease, Done: true, Presentation: Presentation{Speech: "Connection controls closed"}}
|
||||
data, _ := json.Marshal(valid)
|
||||
if _, err := DecodeInteraction(data); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, raw := range []string{
|
||||
`{"remote_background":null,"done":true}`,
|
||||
`{"remote_background":{"lease":"short","epoch":1},"done":true}`,
|
||||
`{"remote_background":{"lease":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","epoch":0},"done":true}`,
|
||||
`{"remote_background":{"lease":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","epoch":1,"session":"other"},"done":true}`,
|
||||
`{"remote_background":{"lease":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","epoch":1}}`,
|
||||
} {
|
||||
if _, err := DecodeInteraction([]byte(raw)); err == nil {
|
||||
t.Fatal("invalid background interaction accepted", raw)
|
||||
}
|
||||
}
|
||||
for _, field := range []string{`"form":{"title":"Menu","elements":[]}`, `"next":"submit"`, `"poll":"poll"`, `"source":"focus"`, `"clipboard":"text"`, `"reader":{"snapshot":true}`, `"remote":{"role":"controller","grants":["remote-present"]}`, `"uninterruptible":true`} {
|
||||
raw := `{"remote_background":{"lease":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","epoch":1},"done":true,"speech":"Closed",` + field + `}`
|
||||
if _, err := DecodeInteraction([]byte(raw)); err == nil {
|
||||
t.Fatal("background interaction mixed with another effect", field)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -13,6 +13,14 @@ The continuation receives "remote" metadata after explicit local approval, or
|
||||
"cancelled": True on denial. Match approval to the actual SessionClient event;
|
||||
neither a request dictionary nor submitted metadata is itself consent. This
|
||||
interaction addition requires the matching updated reader.
|
||||
|
||||
After remote.open, an explicit return-to-desktop action can finish with
|
||||
{"remote_background": {"lease": lease["lease"], "epoch": lease["epoch"]},
|
||||
"done": True}. The host checks an already-open lease belonging to this process;
|
||||
this neither grants consent nor renews it. Keep heartbeating and provide an
|
||||
explicit status/disconnect command. Other interaction effects cannot accompany
|
||||
this terminal result, except ordinary speech/Braille presentation. Cancellation
|
||||
and normal form closure still end setup. Older hosts reject this addition.
|
||||
"""
|
||||
|
||||
import json
|
||||
|
||||
Reference in new issue
Block a user