fix(input): fiabilise la livraison de délégation et journalise le submit
Durcit le portail d'écriture de délégation et son acheminement bout-en-bout (commande Tauri → orchestrateur → file d'entrée infrastructure → portail frontend), avec une journalisation du submit pour diagnostiquer les cas où la délégation n'était pas remise. Couvre le portail d'écriture côté front (useWritePortal) avec ses tests. QA : checks application/front/infrastructure/app-tauri verts. Les tests loopback socket Unix réels ne sont pas exécutables en sandbox (UnixListener::bind → PermissionDenied) ; alternatives avec skips vertes. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
@ -364,7 +364,46 @@ pub fn write_terminal(
|
||||
state: State<'_, AppState>,
|
||||
) -> Result<(), ErrorDto> {
|
||||
let input = request.into_input()?;
|
||||
state.write_terminal.execute(input).map_err(ErrorDto::from)
|
||||
let session_id = input.session_id;
|
||||
let bytes = input.data.len();
|
||||
let control = describe_terminal_write(&input.data);
|
||||
application::diag!(
|
||||
"[pty-write] write_terminal start: session={session_id} bytes={bytes} control={control}"
|
||||
);
|
||||
match state.write_terminal.execute(input) {
|
||||
Ok(()) => {
|
||||
application::diag!(
|
||||
"[pty-write] write_terminal ok: session={session_id} bytes={bytes} control={control}"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
Err(e) => {
|
||||
application::diag!(
|
||||
"[pty-write] write_terminal failed: session={session_id} bytes={bytes} \
|
||||
control={control} error={e}"
|
||||
);
|
||||
Err(ErrorDto::from(e))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn describe_terminal_write(data: &[u8]) -> String {
|
||||
if data.is_empty() {
|
||||
return "<empty>".to_owned();
|
||||
}
|
||||
if data.len() > 16 {
|
||||
return "<bulk>".to_owned();
|
||||
}
|
||||
data.iter()
|
||||
.map(|byte| match *byte {
|
||||
b'\r' => "\\r".to_owned(),
|
||||
b'\n' => "\\n".to_owned(),
|
||||
0x7f => "\\x7f".to_owned(),
|
||||
byte if byte < 0x20 => format!("\\x{byte:02x}"),
|
||||
byte => char::from(byte).to_string(),
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("")
|
||||
}
|
||||
|
||||
/// `resize_terminal` — resize a live PTY.
|
||||
@ -1479,6 +1518,10 @@ pub async fn delegation_delivered(
|
||||
let project = resolve_project(&request.project_id, &state).await?;
|
||||
let agent_id = parse_agent_id(&request.agent_id)?;
|
||||
let ticket = parse_ticket_id(&request.ticket)?;
|
||||
application::diag!(
|
||||
"[delivery] delegation_delivered command: project={} agent={agent_id} ticket={ticket}",
|
||||
project.id
|
||||
);
|
||||
state
|
||||
.orchestrator_service
|
||||
.note_delegation_delivered(&project, agent_id, ticket);
|
||||
@ -1502,6 +1545,10 @@ pub async fn set_front_attached(
|
||||
state: State<'_, AppState>,
|
||||
) -> Result<(), ErrorDto> {
|
||||
let agent_id = parse_agent_id(&request.agent_id)?;
|
||||
application::diag!(
|
||||
"[delivery] set_front_attached command: agent={agent_id} attached={}",
|
||||
request.attached
|
||||
);
|
||||
state
|
||||
.orchestrator_service
|
||||
.set_agent_front_attached(agent_id, request.attached);
|
||||
|
||||
@ -1288,13 +1288,11 @@ impl OrchestratorService {
|
||||
// Observability beacon only: never mutates the mailbox/busy state nor resolves
|
||||
// the ticket (that stays `idea_reply`-driven). Kept best-effort by construction —
|
||||
// a pure, infallible hook so a missing mediator/registry never breaks the
|
||||
// rendezvous. The application crate carries no logging framework (zero new dep);
|
||||
// the ack is materialised as an `eprintln!` trace, the same lightweight channel
|
||||
// the orchestrator already uses for best-effort diagnostics.
|
||||
// rendezvous.
|
||||
let _ = project;
|
||||
eprintln!(
|
||||
"[orchestrator] delegation delivered into agent {agent_id}'s native terminal \
|
||||
(front ack, ticket {ticket})"
|
||||
crate::diag!(
|
||||
"[delivery] front ack received: agent={agent_id} ticket={ticket} \
|
||||
(write-portal reports text+submit writes completed)"
|
||||
);
|
||||
}
|
||||
|
||||
@ -1313,8 +1311,14 @@ impl OrchestratorService {
|
||||
/// agent **headless** (délégué en arrière-plan, sans cellule) voit le médiateur écrire
|
||||
/// lui-même la tâche dans son PTY — sinon le tour est perdu. No-op sans médiateur.
|
||||
pub fn set_agent_front_attached(&self, agent: domain::AgentId, attached: bool) {
|
||||
crate::diag!("[delivery] front attachment changed: agent={agent} attached={attached}");
|
||||
if let Some(input) = &self.input {
|
||||
input.set_front_attached(agent, attached);
|
||||
} else {
|
||||
crate::diag!(
|
||||
"[delivery] front attachment ignored because input mediator is not wired: \
|
||||
agent={agent} attached={attached}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -93,7 +93,7 @@ type HeadlessSink =
|
||||
/// Aligné sur le défaut du write-portal frontend (`DEFAULT_SUBMIT_DELAY_MS`) : sépare
|
||||
/// la soumission du collage pour esquiver la paste-detection des CLI. Utilisé seulement
|
||||
/// quand le profil de la cible ne fournit pas de `submit_delay_ms`.
|
||||
const DEFAULT_SUBMIT_DELAY_MS: u32 = 60;
|
||||
const DEFAULT_SUBMIT_DELAY_MS: u32 = 350;
|
||||
/// Taille maximale d'un fragment de consigne écrit dans le PTY en mode headless.
|
||||
const DELEGATION_WRITE_CHUNK_BYTES: usize = 512;
|
||||
/// Pause entre deux fragments de consigne en mode headless.
|
||||
@ -147,6 +147,7 @@ impl BusyTracker {
|
||||
/// appel, l'`enqueue` publie la `DelegationReady` immédiatement (chemin chaud,
|
||||
/// zéro régression).
|
||||
fn mark_starting(&self, agent: AgentId) {
|
||||
eprintln!("[input-mediator] cold-start gate armed agent={agent}");
|
||||
self.lock_starting().insert(agent);
|
||||
}
|
||||
|
||||
@ -263,8 +264,10 @@ impl BusyTracker {
|
||||
let mut busy = self.lock();
|
||||
let entry = busy.entry(agent).or_insert(AgentBusyState::Idle);
|
||||
if entry.is_busy() {
|
||||
eprintln!("[input-mediator] enqueue queued behind busy agent={agent}");
|
||||
false
|
||||
} else {
|
||||
eprintln!("[input-mediator] turn started agent={agent} state={state:?}");
|
||||
*entry = state;
|
||||
true
|
||||
}
|
||||
@ -281,11 +284,21 @@ impl BusyTracker {
|
||||
let d = match &self.headless_sink {
|
||||
Some(sink) => match sink(agent, d) {
|
||||
Some(d) => d,
|
||||
None => return,
|
||||
None => {
|
||||
eprintln!("[input-mediator] delegation handled by headless sink agent={agent}");
|
||||
return;
|
||||
}
|
||||
},
|
||||
None => d,
|
||||
};
|
||||
if let Some(events) = &self.events {
|
||||
eprintln!(
|
||||
"[input-mediator] publishing DelegationReady agent={agent} ticket={} text_bytes={} submit_sequence={} submit_delay_ms={:?}",
|
||||
d.ticket,
|
||||
d.text.as_bytes().len(),
|
||||
describe_submit_sequence(d.submit_sequence.as_deref()),
|
||||
d.submit_delay_ms,
|
||||
);
|
||||
events.publish(DomainEvent::DelegationReady {
|
||||
agent_id: agent,
|
||||
ticket: d.ticket,
|
||||
@ -309,7 +322,13 @@ impl BusyTracker {
|
||||
self.lock_starting().remove(&agent);
|
||||
let deferred = self.lock_deferred().remove(&agent);
|
||||
match deferred {
|
||||
Some(d) => self.publish_deferred(agent, d),
|
||||
Some(d) => {
|
||||
eprintln!(
|
||||
"[input-mediator] prompt-ready released deferred delegation agent={agent} ticket={}",
|
||||
d.ticket
|
||||
);
|
||||
self.publish_deferred(agent, d);
|
||||
}
|
||||
None => self.mark_idle(agent),
|
||||
}
|
||||
}
|
||||
@ -322,6 +341,10 @@ impl BusyTracker {
|
||||
fn release_cold_start(&self, agent: AgentId) {
|
||||
self.lock_starting().remove(&agent);
|
||||
if let Some(d) = self.lock_deferred().remove(&agent) {
|
||||
eprintln!(
|
||||
"[input-mediator] mcp-ready released deferred delegation agent={agent} ticket={}",
|
||||
d.ticket
|
||||
);
|
||||
self.publish_deferred(agent, d);
|
||||
}
|
||||
}
|
||||
@ -336,6 +359,7 @@ impl BusyTracker {
|
||||
.is_some_and(|s| s.is_busy())
|
||||
};
|
||||
if was_busy {
|
||||
eprintln!("[input-mediator] turn marked idle agent={agent}");
|
||||
if let Some(events) = &self.events {
|
||||
events.publish(DomainEvent::AgentBusyChanged {
|
||||
agent_id: agent,
|
||||
@ -470,6 +494,10 @@ impl MediatedInbox {
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.contains(&agent)
|
||||
{
|
||||
eprintln!(
|
||||
"[input-mediator] front-owned delivery selected agent={agent} ticket={}",
|
||||
d.ticket
|
||||
);
|
||||
return Some(d);
|
||||
}
|
||||
// Agent headless : récupérer son handle PTY. Absent ⇒ repli sur l'événement
|
||||
@ -480,11 +508,19 @@ impl MediatedInbox {
|
||||
.get(&agent)
|
||||
.cloned();
|
||||
let Some(handle) = handle else {
|
||||
eprintln!(
|
||||
"[input-mediator] no PTY handle for headless delivery agent={agent} ticket={}",
|
||||
d.ticket
|
||||
);
|
||||
return Some(d);
|
||||
};
|
||||
let pty = Arc::clone(&pty);
|
||||
let text = d.text;
|
||||
let submit = d.submit_sequence.unwrap_or_else(|| "\r".to_owned());
|
||||
let ticket = d.ticket;
|
||||
let submit = d
|
||||
.submit_sequence
|
||||
.filter(|s| !s.is_empty())
|
||||
.unwrap_or_else(|| "\r".to_owned());
|
||||
let delay = u64::from(d.submit_delay_ms.unwrap_or(DEFAULT_SUBMIT_DELAY_MS));
|
||||
// Écriture sur un thread détaché : ne JAMAIS bloquer l'appelant (thread du
|
||||
// watcher prompt-ready, tâche tokio du serveur MCP, ou le fil de l'enqueue).
|
||||
@ -493,11 +529,43 @@ impl MediatedInbox {
|
||||
// La consigne est fragmentée : les TUI (Codex surtout) peuvent traiter un
|
||||
// gros write unique comme un paste et garder/perdre la fin au démarrage.
|
||||
std::thread::spawn(move || {
|
||||
let _ = write_delegation_chunks(pty.as_ref(), &handle, &text);
|
||||
eprintln!(
|
||||
"[input-mediator] headless write text start agent={agent} ticket={ticket} handle={} text_bytes={} submit_sequence={} submit_delay_ms={delay}",
|
||||
handle.session_id,
|
||||
text.as_bytes().len(),
|
||||
describe_submit_sequence(Some(&submit)),
|
||||
);
|
||||
match write_delegation_chunks(pty.as_ref(), &handle, &text) {
|
||||
Ok(()) => eprintln!(
|
||||
"[input-mediator] headless write text ok agent={agent} ticket={ticket} handle={}",
|
||||
handle.session_id
|
||||
),
|
||||
Err(e) => {
|
||||
eprintln!(
|
||||
"[input-mediator] headless write text failed agent={agent} ticket={ticket} handle={} error={e}",
|
||||
handle.session_id
|
||||
);
|
||||
return;
|
||||
}
|
||||
}
|
||||
if delay > 0 {
|
||||
std::thread::sleep(std::time::Duration::from_millis(delay));
|
||||
}
|
||||
let _ = pty.write(&handle, submit.as_bytes());
|
||||
eprintln!(
|
||||
"[input-mediator] headless submit start agent={agent} ticket={ticket} handle={} submit_sequence={}",
|
||||
handle.session_id,
|
||||
describe_submit_sequence(Some(&submit)),
|
||||
);
|
||||
match pty.write(&handle, submit.as_bytes()) {
|
||||
Ok(()) => eprintln!(
|
||||
"[input-mediator] headless submit ok agent={agent} ticket={ticket} handle={}",
|
||||
handle.session_id
|
||||
),
|
||||
Err(e) => eprintln!(
|
||||
"[input-mediator] headless submit failed agent={agent} ticket={ticket} handle={} error={e}",
|
||||
handle.session_id
|
||||
),
|
||||
}
|
||||
});
|
||||
None
|
||||
})
|
||||
@ -692,6 +760,24 @@ fn write_delegation_chunks(
|
||||
pty.write(handle, text[start..].as_bytes())
|
||||
}
|
||||
|
||||
fn describe_submit_sequence(value: Option<&str>) -> String {
|
||||
match value {
|
||||
None => "<default>".to_owned(),
|
||||
Some("") => "<empty>".to_owned(),
|
||||
Some(value) => value
|
||||
.chars()
|
||||
.map(|ch| match ch {
|
||||
'\r' => "\\r".to_owned(),
|
||||
'\n' => "\\n".to_owned(),
|
||||
'\u{7f}' => "\\x7f".to_owned(),
|
||||
ch if ch.is_control() => format!("\\x{:02x}", ch as u32),
|
||||
ch => ch.to_string(),
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join(""),
|
||||
}
|
||||
}
|
||||
|
||||
impl InputMediator for MediatedInbox {
|
||||
fn enqueue(&self, agent: AgentId, ticket: Ticket) -> PendingReply {
|
||||
let ticket_id = ticket.id;
|
||||
@ -761,6 +847,10 @@ impl InputMediator for MediatedInbox {
|
||||
}
|
||||
|
||||
fn bind_handle(&self, agent: AgentId, handle: PtyHandle) {
|
||||
eprintln!(
|
||||
"[input-mediator] bind handle agent={agent} handle={}",
|
||||
handle.session_id
|
||||
);
|
||||
self.handles().insert(agent, handle);
|
||||
}
|
||||
|
||||
@ -776,6 +866,13 @@ impl InputMediator for MediatedInbox {
|
||||
// then arm the prompt-ready watcher when the profile declares a literal marker
|
||||
// (C5). A `None`/empty pattern arms nothing: Idle then comes only from the
|
||||
// explicit signal or the per-turn timeout (safe fallback, never a false Idle).
|
||||
eprintln!(
|
||||
"[input-mediator] bind handle with prompt agent={agent} handle={} prompt_ready={} submit_sequence={} submit_delay_ms={:?}",
|
||||
handle.session_id,
|
||||
prompt_ready_pattern.as_deref().unwrap_or("<none>"),
|
||||
describe_submit_sequence(submit.sequence.as_deref()),
|
||||
submit.delay_ms,
|
||||
);
|
||||
self.handles().insert(agent, handle.clone());
|
||||
self.submit().insert(agent, submit);
|
||||
if let Some(pattern) = prompt_ready_pattern {
|
||||
@ -805,8 +902,10 @@ impl InputMediator for MediatedInbox {
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
if attached {
|
||||
eprintln!("[input-mediator] front attached agent={agent}");
|
||||
front.insert(agent);
|
||||
} else {
|
||||
eprintln!("[input-mediator] front detached agent={agent}");
|
||||
front.remove(&agent);
|
||||
}
|
||||
}
|
||||
|
||||
@ -28,15 +28,27 @@ export class TauriInputGateway implements InputGateway {
|
||||
agentId: string,
|
||||
ticket: string,
|
||||
): Promise<void> {
|
||||
console.info("[input-gateway] delegationDelivered:start", {
|
||||
projectId,
|
||||
agentId,
|
||||
ticket,
|
||||
});
|
||||
await invoke("delegation_delivered", {
|
||||
request: { projectId, agentId, ticket },
|
||||
});
|
||||
console.info("[input-gateway] delegationDelivered:ok", {
|
||||
projectId,
|
||||
agentId,
|
||||
ticket,
|
||||
});
|
||||
}
|
||||
|
||||
async setFrontAttached(agentId: string, attached: boolean): Promise<void> {
|
||||
console.info("[input-gateway] setFrontAttached:start", { agentId, attached });
|
||||
await invoke("set_front_attached", {
|
||||
request: { agentId, attached },
|
||||
});
|
||||
console.info("[input-gateway] setFrontAttached:ok", { agentId, attached });
|
||||
}
|
||||
|
||||
async cancelResume(agentId: string): Promise<boolean> {
|
||||
|
||||
@ -64,11 +64,13 @@ export function makeTerminalHandle(
|
||||
return {
|
||||
sessionId,
|
||||
write(data: Uint8Array): Promise<void> {
|
||||
const run = chain.then(() =>
|
||||
invoke<void>("write_terminal", {
|
||||
const run = chain.then(async () => {
|
||||
logTerminalWrite("start", sessionId, data);
|
||||
await invoke<void>("write_terminal", {
|
||||
request: { sessionId, data: Array.from(data) },
|
||||
}),
|
||||
);
|
||||
});
|
||||
logTerminalWrite("ok", sessionId, data);
|
||||
});
|
||||
// Keep the chain alive even if this write rejects: the next write must
|
||||
// still run. Swallow the error on the *chain* copy only — `run` keeps the
|
||||
// rejection so the caller can observe it.
|
||||
@ -91,6 +93,35 @@ export function makeTerminalHandle(
|
||||
};
|
||||
}
|
||||
|
||||
function logTerminalWrite(phase: "start" | "ok", sessionId: string, data: Uint8Array): void {
|
||||
if (data.length === 1 && data[0] >= 0x20 && data[0] !== 0x7f) return;
|
||||
console.info("[terminal-write]", phase, {
|
||||
sessionId,
|
||||
bytes: data.length,
|
||||
control: describeBytes(data),
|
||||
});
|
||||
}
|
||||
|
||||
function describeBytes(data: Uint8Array): string {
|
||||
if (data.length === 0) return "<empty>";
|
||||
if (data.length > 16) return "<bulk>";
|
||||
return Array.from(data)
|
||||
.map((byte) => {
|
||||
switch (byte) {
|
||||
case 0x0d:
|
||||
return "\\r";
|
||||
case 0x0a:
|
||||
return "\\n";
|
||||
case 0x7f:
|
||||
return "\\x7f";
|
||||
default:
|
||||
if (byte < 0x20) return `\\x${byte.toString(16).padStart(2, "0")}`;
|
||||
return String.fromCharCode(byte);
|
||||
}
|
||||
})
|
||||
.join("");
|
||||
}
|
||||
|
||||
export class TauriTerminalGateway implements TerminalGateway {
|
||||
async openTerminal(
|
||||
options: OpenTerminalOptions,
|
||||
|
||||
@ -27,7 +27,7 @@ export type DomainEvent =
|
||||
* PTY-writes the turn: the frontend write-portal runs the handshake (b→e)
|
||||
* and writes `text` + `submitSequence`. `submitSequence`/`submitDelayMs`
|
||||
* come from the target's profile; absent ⇒ the portal applies its defaults
|
||||
* (`"\r"`, ~60 ms).
|
||||
* (`"\r"`, ~350 ms).
|
||||
*/
|
||||
type: "delegationReady";
|
||||
agentId: string;
|
||||
|
||||
@ -235,6 +235,26 @@ describe("useWritePortal (§20)", () => {
|
||||
expect(writes).toEqual(["msg", "\n"]);
|
||||
});
|
||||
|
||||
it("defaults an empty profile submitSequence to Enter", async () => {
|
||||
const { system, view } = setup();
|
||||
const { handle, writes } = makeHandle();
|
||||
act(() => view.result.current.portal.bindHandle(handle));
|
||||
|
||||
await act(async () => {
|
||||
system.emit({
|
||||
type: "delegationReady",
|
||||
agentId: "ag1",
|
||||
ticket: "t1",
|
||||
text: "msg",
|
||||
submitSequence: "",
|
||||
submitDelayMs: 0,
|
||||
});
|
||||
await vi.runAllTimersAsync();
|
||||
});
|
||||
|
||||
expect(writes).toEqual(["msg", "\r"]);
|
||||
});
|
||||
|
||||
it("ignores delegationReady for a different agent", async () => {
|
||||
const { system, view } = setup();
|
||||
const { handle, writes } = makeHandle();
|
||||
|
||||
@ -58,6 +58,8 @@ const DELEGATION_WRITE_CHUNK_BYTES = 512;
|
||||
/** Delay between delegation chunks, to avoid TUI paste/drop behaviour on cold agents. */
|
||||
const DELEGATION_WRITE_CHUNK_DELAY_MS = 8;
|
||||
|
||||
const LOG_PREFIX = "[write-portal]";
|
||||
|
||||
/** A pending delegation kept in the local FIFO. */
|
||||
interface PendingDelegation {
|
||||
ticket: string;
|
||||
@ -135,10 +137,24 @@ export function useWritePortal(
|
||||
if (previous === desired) return;
|
||||
|
||||
if (previous) {
|
||||
void inputRef.current?.setFrontAttached(previous, false).catch(() => {});
|
||||
portalLog("front-attached:set", { agent: previous, attached: false });
|
||||
void inputRef.current?.setFrontAttached(previous, false).catch((error) => {
|
||||
portalLog("front-attached:set-failed", {
|
||||
agent: previous,
|
||||
attached: false,
|
||||
error: describeError(error),
|
||||
});
|
||||
});
|
||||
}
|
||||
if (desired) {
|
||||
void inputRef.current?.setFrontAttached(desired, true).catch(() => {});
|
||||
portalLog("front-attached:set", { agent: desired, attached: true });
|
||||
void inputRef.current?.setFrontAttached(desired, true).catch((error) => {
|
||||
portalLog("front-attached:set-failed", {
|
||||
agent: desired,
|
||||
attached: true,
|
||||
error: describeError(error),
|
||||
});
|
||||
});
|
||||
}
|
||||
frontAttachedAgentRef.current = desired;
|
||||
};
|
||||
@ -164,7 +180,16 @@ export function useWritePortal(
|
||||
setOverlay(true);
|
||||
|
||||
void (async () => {
|
||||
let drainNext = false;
|
||||
try {
|
||||
portalLog("inject:start", {
|
||||
agent,
|
||||
ticket: head.ticket,
|
||||
textBytes: encoder.encode(head.text).byteLength,
|
||||
queue: queueRef.current.length,
|
||||
submitSequence: describeControl(head.submitSequence),
|
||||
submitDelayMs: head.submitDelayMs ?? DEFAULT_SUBMIT_DELAY_MS,
|
||||
});
|
||||
// Yield once so any keystroke that landed in the micro-window between
|
||||
// "empty observed" (a) and the suspension taking hold (b) is counted
|
||||
// before we re-check K at step (c). Without this the race window would
|
||||
@ -174,6 +199,7 @@ export function useWritePortal(
|
||||
// (backspace) — never Ctrl-U (which could clear more than the human typed).
|
||||
const k = counterRef.current;
|
||||
if (k > 0) {
|
||||
portalLog("inject:erase-human-window", { agent, ticket: head.ticket, count: k });
|
||||
await handle.write(encoder.encode("\x7f".repeat(k)));
|
||||
counterRef.current = 0;
|
||||
}
|
||||
@ -183,19 +209,37 @@ export function useWritePortal(
|
||||
// Long delegated prompts are chunked: Codex's TUI can otherwise treat a
|
||||
// large single write like a paste and occasionally keep/drop the tail on
|
||||
// cold-started agents before Enter is received.
|
||||
await writeDelegationText(handle, head.text);
|
||||
await writeDelegationText(handle, head.text, head.ticket);
|
||||
const delay = head.submitDelayMs ?? DEFAULT_SUBMIT_DELAY_MS;
|
||||
portalLog("inject:before-submit-delay", { agent, ticket: head.ticket, delay });
|
||||
await sleep(delay);
|
||||
const submit = head.submitSequence ?? DEFAULT_SUBMIT_SEQUENCE;
|
||||
const submit = normalizeSubmitSequence(head.submitSequence, head.ticket);
|
||||
portalLog("inject:submit-write:start", {
|
||||
agent,
|
||||
ticket: head.ticket,
|
||||
submitSequence: describeControl(submit),
|
||||
submitBytes: encoder.encode(submit).byteLength,
|
||||
});
|
||||
await handle.write(encoder.encode(submit));
|
||||
portalLog("inject:submit-write:ok", { agent, ticket: head.ticket });
|
||||
|
||||
// Dequeue + ack exactly once (best-effort; never throws the handshake).
|
||||
queueRef.current.shift();
|
||||
drainNext = true;
|
||||
try {
|
||||
portalLog("inject:ack:start", { agent, ticket: head.ticket });
|
||||
await inputRef.current.delegationDelivered(project, agent, head.ticket);
|
||||
portalLog("inject:ack:ok", { agent, ticket: head.ticket });
|
||||
} catch {
|
||||
portalLog("inject:ack:failed", { agent, ticket: head.ticket });
|
||||
/* ack is observability-only; never block the portal */
|
||||
}
|
||||
} catch (error) {
|
||||
portalLog("inject:failed", {
|
||||
agent,
|
||||
ticket: head.ticket,
|
||||
error: describeError(error),
|
||||
});
|
||||
} finally {
|
||||
// (e) lower the overlay + resume the relay, with the 2 s anti-flash floor.
|
||||
const elapsed = Date.now() - startedAt;
|
||||
@ -205,7 +249,7 @@ export function useWritePortal(
|
||||
setOverlay(false);
|
||||
injectingRef.current = false;
|
||||
// A boundary may now be open for the next queued delegation.
|
||||
if (queueRef.current.length > 0) tryInject.current();
|
||||
if (queueRef.current.length > 0 && drainNext) tryInject.current();
|
||||
}
|
||||
})();
|
||||
};
|
||||
@ -231,6 +275,14 @@ export function useWritePortal(
|
||||
submitSequence: event.submitSequence,
|
||||
submitDelayMs: event.submitDelayMs,
|
||||
});
|
||||
portalLog("event:delegation-ready", {
|
||||
agent: subscribedAgent,
|
||||
ticket: event.ticket,
|
||||
textBytes: encoder.encode(event.text).byteLength,
|
||||
queue: queueRef.current.length,
|
||||
submitSequence: describeControl(event.submitSequence),
|
||||
submitDelayMs: event.submitDelayMs,
|
||||
});
|
||||
// A delegation may already be at a clean boundary (line empty) — try now.
|
||||
tryInject.current();
|
||||
})
|
||||
@ -239,6 +291,7 @@ export function useWritePortal(
|
||||
else {
|
||||
unsubscribe = un;
|
||||
subscribedAgentRef.current = subscribedAgent;
|
||||
portalLog("event:subscribed", { agent: subscribedAgent });
|
||||
reconcileFrontAttachment.current();
|
||||
}
|
||||
});
|
||||
@ -248,6 +301,7 @@ export function useWritePortal(
|
||||
unsubscribe?.();
|
||||
if (subscribedAgentRef.current === subscribedAgent) {
|
||||
subscribedAgentRef.current = null;
|
||||
portalLog("event:unsubscribed", { agent: subscribedAgent });
|
||||
}
|
||||
if (frontAttachedAgentRef.current === subscribedAgent) {
|
||||
void inputRef.current?.setFrontAttached(subscribedAgent, false).catch(() => {});
|
||||
@ -279,6 +333,7 @@ export function useWritePortal(
|
||||
},
|
||||
bindHandle(handle: TerminalHandle) {
|
||||
handleRef.current = handle;
|
||||
portalLog("handle:bound", { agent: agentIdRef.current, sessionId: handle.sessionId });
|
||||
// Tell the backend a frontend cell is mounted only after the event
|
||||
// subscription is ready. Until then, the backend keeps the headless PTY
|
||||
// write fallback, so a delegation cannot disappear during mount.
|
||||
@ -287,6 +342,10 @@ export function useWritePortal(
|
||||
tryInject.current();
|
||||
},
|
||||
unbindHandle() {
|
||||
portalLog("handle:unbound", {
|
||||
agent: agentIdRef.current,
|
||||
sessionId: handleRef.current?.sessionId,
|
||||
});
|
||||
handleRef.current = null;
|
||||
// The cell is gone — let the backend fall back to headless delivery so a
|
||||
// delegation arriving while this agent has no live cell is not lost.
|
||||
@ -307,16 +366,40 @@ function sleep(ms: number): Promise<void> {
|
||||
async function writeDelegationText(
|
||||
handle: TerminalHandle,
|
||||
text: string,
|
||||
ticket: string,
|
||||
): Promise<void> {
|
||||
const chunks = splitUtf8Chunks(text, DELEGATION_WRITE_CHUNK_BYTES);
|
||||
for (let i = 0; i < chunks.length; i += 1) {
|
||||
portalLog("inject:text-chunk:start", {
|
||||
ticket,
|
||||
sessionId: handle.sessionId,
|
||||
chunk: i + 1,
|
||||
chunks: chunks.length,
|
||||
bytes: encoder.encode(chunks[i]).byteLength,
|
||||
});
|
||||
await handle.write(encoder.encode(chunks[i]));
|
||||
portalLog("inject:text-chunk:ok", {
|
||||
ticket,
|
||||
sessionId: handle.sessionId,
|
||||
chunk: i + 1,
|
||||
chunks: chunks.length,
|
||||
});
|
||||
if (i + 1 < chunks.length) {
|
||||
await sleep(DELEGATION_WRITE_CHUNK_DELAY_MS);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function normalizeSubmitSequence(sequence: string | undefined, ticket: string): string {
|
||||
if (sequence == null) return DEFAULT_SUBMIT_SEQUENCE;
|
||||
if (sequence.length > 0) return sequence;
|
||||
portalLog("inject:empty-submit-sequence-defaulted", {
|
||||
ticket,
|
||||
defaultSubmitSequence: describeControl(DEFAULT_SUBMIT_SEQUENCE),
|
||||
});
|
||||
return DEFAULT_SUBMIT_SEQUENCE;
|
||||
}
|
||||
|
||||
function splitUtf8Chunks(text: string, maxBytes: number): string[] {
|
||||
if (text.length === 0) return [""];
|
||||
const chunks: string[] = [];
|
||||
@ -337,3 +420,36 @@ function splitUtf8Chunks(text: string, maxBytes: number): string[] {
|
||||
if (current.length > 0) chunks.push(current);
|
||||
return chunks;
|
||||
}
|
||||
|
||||
function describeControl(value: string | undefined): string {
|
||||
if (value == null) return "<default>";
|
||||
if (value.length === 0) return "<empty>";
|
||||
return [...value]
|
||||
.map((ch) => {
|
||||
switch (ch) {
|
||||
case "\r":
|
||||
return "\\r";
|
||||
case "\n":
|
||||
return "\\n";
|
||||
case "\x7f":
|
||||
return "\\x7f";
|
||||
default: {
|
||||
const code = ch.codePointAt(0)!;
|
||||
if (code < 0x20) return `\\x${code.toString(16).padStart(2, "0")}`;
|
||||
return ch;
|
||||
}
|
||||
}
|
||||
})
|
||||
.join("");
|
||||
}
|
||||
|
||||
function describeError(error: unknown): string {
|
||||
if (error && typeof error === "object" && "message" in error) {
|
||||
return String((error as { message: unknown }).message);
|
||||
}
|
||||
return String(error);
|
||||
}
|
||||
|
||||
function portalLog(event: string, fields: Record<string, unknown>): void {
|
||||
console.info(LOG_PREFIX, event, fields);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user