var statusText: String?

}

private struct ExecApprovalGatewayEventPayload: Decodable {

var id: String

}

/// Ensures notification requests return promptly even if the system prompt blocks.

private final class NotificationInvokeLatch<T: Sendable>: @unchecked Sendable {

private let lock = NSLock()

for await evt in stream {

if Task.isCancelled { return }

guard let payload = evt.payload else { continue }

switch evt.event {

case "voicewake.changed":

struct Payload: Decodable { var triggers: [String] }

guard let decoded = try? GatewayPayloadDecoding.decode(payload, as: Payload.self) else { continue }

let triggers = VoiceWakePreferences.sanitizeTriggerWords(decoded.triggers)

VoiceWakePreferences.saveTriggerWords(triggers)

case "talk.mode":

struct Payload: Decodable {

var enabled: Bool

var phase: String?

}

guard let decoded = try? GatewayPayloadDecoding.decode(payload, as: Payload.self) else { continue }

self.applyTalkModeSync(enabled: decoded.enabled, phase: decoded.phase)

default:

continue

}

await self.handleOperatorGatewayServerEvent(evt)

}

}

}

private func handleOperatorGatewayServerEvent(_ evt: EventFrame) async {

guard let payload = evt.payload else { return }

switch evt.event {

case "voicewake.changed":

struct Payload: Decodable { var triggers: [String] }

guard let decoded = try? GatewayPayloadDecoding.decode(payload, as: Payload.self) else { return }

let triggers = VoiceWakePreferences.sanitizeTriggerWords(decoded.triggers)

VoiceWakePreferences.saveTriggerWords(triggers)

case "talk.mode":

struct Payload: Decodable {

var enabled: Bool

var phase: String?

}

guard let decoded = try? GatewayPayloadDecoding.decode(payload, as: Payload.self) else { return }

self.applyTalkModeSync(enabled: decoded.enabled, phase: decoded.phase)

case ExecApprovalNotificationBridge.requestedKind:

guard let approvalId = Self.execApprovalEventID(from: payload) else { return }

await self.presentExecApprovalNotificationPrompt(

ExecApprovalNotificationPrompt(approvalId: approvalId))

case ExecApprovalNotificationBridge.resolvedKind:

guard let approvalId = Self.execApprovalEventID(from: payload) else { return }

await self.handleExecApprovalResolvedRemotePush(approvalId: approvalId)

default:

return

}

}

private nonisolated static func execApprovalEventID(from payload: AnyCodable) -> String? {

guard let decoded = try? GatewayPayloadDecoding.decode(

payload,

as: ExecApprovalGatewayEventPayload.self)

else {

return nil

}

let approvalId = decoded.id.trimmingCharacters(in: .whitespacesAndNewlines)

return approvalId.isEmpty ? nil : approvalId

}

private func applyTalkModeSync(enabled: Bool, phase: String?) {

_ = phase

guard self.talkMode.isEnabled != enabled else { return }

isBackgrounded: isBackgrounded)

}

nonisolated static func _test_execApprovalEventID(from payload: AnyCodable) -> String? {

self.execApprovalEventID(from: payload)

}

func _test_handleOperatorGatewayServerEvent(_ event: EventFrame) async {

await self.handleOperatorGatewayServerEvent(event)

}

nonisolated static func _test_watchExecApprovalIDsNeedingFetch(

candidateIDs: [String],

cachedApprovalIDs: [String]) -> [String]

isBackgrounded: false))

}

@Test func execApprovalEventIDDecodesGatewayPayload() {

#expect(NodeAppModel._test_execApprovalEventID(from: AnyCodable(["id": " approval-1 "])) == "approval-1")

#expect(NodeAppModel._test_execApprovalEventID(from: AnyCodable(["id": " "])) == nil)

#expect(NodeAppModel._test_execApprovalEventID(from: AnyCodable(["other": "approval-1"])) == nil)

}

@Test @MainActor func operatorGatewayResolvedEventClearsPendingApprovalPrompt() async throws {

let appModel = NodeAppModel()

try appModel._test_presentExecApprovalPrompt(

#require(

NodeAppModel._test_makeExecApprovalPrompt(

id: "approval-event-resolved",

commandText: "echo clear",

allowedDecisions: ["allow-once", "deny"],

host: "gateway",

nodeId: nil,

agentId: nil,

expiresAtMs: Int(Date().timeIntervalSince1970 * 1000) + 60000)))

await appModel._test_handleOperatorGatewayServerEvent(EventFrame(

type: "event",

event: ExecApprovalNotificationBridge.resolvedKind,

payload: AnyCodable(["id": "approval-event-resolved"]),

seq: nil,

stateversion: nil))

#expect(appModel._test_pendingExecApprovalPrompt() == nil)

}

@Test func watchExecApprovalHydrateFetchesOnlyMissingIDs() {

let idsToFetch = NodeAppModel._test_watchExecApprovalIDsNeedingFetch(

candidateIDs: ["cached", "pending", "cached", "other", "", " pending "],

});

});

it("passes the approval reviewer device into Codex dynamic tools", async () => {

const sessionFile = path.join(tempDir, "session.jsonl");

const workspaceDir = path.join(tempDir, "workspace");

const params = createParams(sessionFile, workspaceDir);

params.disableTools = false;

params.approvalReviewerDeviceId = "device-ios-reviewer";

params.runtimePlan = createCodexRuntimePlanFixture();

const factoryOptions: unknown[] = [];

setOpenClawCodingToolsFactoryForTests((options) => {

factoryOptions.push(options);

return [];

});

await buildDynamicToolsForTest(params, workspaceDir, { sandbox: null as never });

expect(factoryOptions[0]).toMatchObject({

approvalReviewerDeviceId: "device-ios-reviewer",

});

});

it("forwards tool outcome ordering into Codex dynamic tools", async () => {

const sessionFile = path.join(tempDir, "session.jsonl");

const workspaceDir = path.join(tempDir, "workspace");

} from "openclaw/plugin-sdk/agent-harness-runtime";

import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";

import { isToolAllowed } from "openclaw/plugin-sdk/sandbox";

import {

readCodexPluginConfig,

type CodexPluginConfig,

} from "./config.js";

import { readCodexPluginConfig, type CodexPluginConfig } from "./config.js";

import {

filterCodexDynamicTools,

isForcedPrivateQaCodexRuntime,

...sessionKeys,

sessionId: params.sessionId,

runId: params.runId,

approvalReviewerDeviceId: params.approvalReviewerDeviceId,

agentDir,

cwd: input.effectiveCwd ?? input.effectiveWorkspace,

workspaceDir: input.effectiveWorkspace,

nativeToolSurfaceEnabled: boolean;

remoteWorkspaceRoot?: string;

}): string {

const cwd = params.environment && params.nativeToolSurfaceEnabled

? params.environment.cwd

: params.effectiveCwd;

const cwd =

params.environment && params.nativeToolSurfaceEnabled

? params.environment.cwd

: params.effectiveCwd;

return mapCodexAppServerRemoteWorkspacePath({

value: cwd,

localWorkspaceRoot: params.localWorkspaceRoot,

turnSourceTo: Type.Optional(Type.Union([Type.String(), Type.Null()])),

turnSourceAccountId: Type.Optional(Type.Union([Type.String(), Type.Null()])),

turnSourceThreadId: Type.Optional(Type.Union([Type.String(), Type.Number(), Type.Null()])),

approvalReviewerDeviceIds: Type.Optional(

Type.Array(NonEmptyString, {

description:

"Trusted approval-runtime metadata naming operator devices that may review this approval; ordinary Gateway clients may send the field, but the Gateway only binds it for internal approval-runtime requests.",

}),

),

requireDeliveryRoute: Type.Optional(Type.Boolean()),

suppressDelivery: Type.Optional(Type.Boolean()),

timeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),

oneShotCliRun?: boolean;

/** Stable run identifier for this agent invocation. */

runId?: string;

/** Device-scoped operator session allowed to review approvals initiated by this run. */

approvalReviewerDeviceId?: string;

/** Diagnostic trace context for hook/log correlation during this run. */

trace?: DiagnosticTraceContext;

/** What initiated this run (for trigger-specific tool restrictions). */

currentChannelId: options?.currentChannelId,

currentThreadTs: options?.currentThreadTs,

accountId: options?.agentAccountId,

approvalReviewerDeviceId: options?.approvalReviewerDeviceId,

backgroundMs: options?.exec?.backgroundMs ?? execConfig.backgroundMs,

timeoutSec: options?.exec?.timeoutSec ?? execConfig.timeoutSec,

approvalRunningNoticeMs:

}

type ApprovalRequestPayload = {

approvalReviewerDeviceIds?: string[];

commandSpans?: Array<{ startIndex: number; endIndex: number }>;

};

]);

});

it("passes approval reviewer devices into host approval registration payloads", async () => {

vi.mocked(callGatewayTool).mockResolvedValue({ id: "approval-id", expiresAtMs: 1234 });

await registerExecApprovalRequestForHost({

approvalId: "approval-id",

command: "echo hi",

approvalReviewerDeviceIds: ["device-ios-reviewer"],

workdir: "/tmp/project",

host: "node",

security: "allowlist",

ask: "always",

});

const payload = requireApprovalRequestPayload(0);

expect(payload?.approvalReviewerDeviceIds).toEqual(["device-ios-reviewer"]);

});

it("does not generate command spans by default", async () => {

vi.mocked(callGatewayTool).mockResolvedValue({ id: "approval-id", expiresAtMs: 1234 });

turnSourceTo?: string;

turnSourceAccountId?: string;

turnSourceThreadId?: string | number;

approvalReviewerDeviceIds?: string[];

requireDeliveryRoute?: boolean;

suppressDelivery?: boolean;

};

turnSourceTo: params.turnSourceTo,

turnSourceAccountId: params.turnSourceAccountId,

turnSourceThreadId: params.turnSourceThreadId,

approvalReviewerDeviceIds: params.approvalReviewerDeviceIds,

requireDeliveryRoute: params.requireDeliveryRoute,

suppressDelivery: params.suppressDelivery,

timeoutMs: DEFAULT_APPROVAL_TIMEOUT_MS,

turnSourceTo?: string;

turnSourceAccountId?: string;

turnSourceThreadId?: string | number;

approvalReviewerDeviceIds?: string[];

requireDeliveryRoute?: boolean;

suppressDelivery?: boolean;

};

resolvedPath: params.resolvedPath,

requireDeliveryRoute: params.requireDeliveryRoute,

suppressDelivery: params.suppressDelivery,

approvalReviewerDeviceIds: params.approvalReviewerDeviceIds,

...buildExecApprovalTurnSourceContext(params),

};

}

/** Session-store template, so the direct/denied followup can detect a rebind. */

sessionStore?: string;

bashElevated?: ExecElevatedDefaults;

approvalReviewerDeviceId?: string;

turnSourceChannel?: string;

turnSourceTo?: string;

turnSourceAccountId?: string;

agentId: params.agentId,

sessionKey: params.sessionKey,

}),

approvalReviewerDeviceIds: params.approvalReviewerDeviceId

? [params.approvalReviewerDeviceId]

: undefined,

resolvedPath: resolveApprovalAuditTrustPath(

allowlistEval.segments[0]?.resolution ?? null,

params.workdir,

agentId: prepared.agentId,

sessionKey: prepared.sessionKey,

}),

approvalReviewerDeviceIds: params.approvalReviewerDeviceId

? [params.approvalReviewerDeviceId]

: undefined,

...(options.requireDeliveryRoute !== undefined

? { requireDeliveryRoute: options.requireDeliveryRoute }

: {}),