diff --git a/apps/shared/OpenClawKit/Sources/OpenClawProtocol/GatewayModels.swift b/apps/shared/OpenClawKit/Sources/OpenClawProtocol/GatewayModels.swift index aac7b4b4a8d..502316267ea 100644 --- a/apps/shared/OpenClawKit/Sources/OpenClawProtocol/GatewayModels.swift +++ b/apps/shared/OpenClawKit/Sources/OpenClawProtocol/GatewayModels.swift @@ -7636,6 +7636,7 @@ public struct SessionsSendParams: Codable, Sendable { public let deliver: Bool? public let suppresscommandinterpretation: Bool? public let senderattribution: [String: AnyCodable]? + public let personalautomations: Bool? public let attachments: [[String: AnyCodable]]? public let timeoutms: Int? public let idempotencykey: String? @@ -7648,6 +7649,7 @@ public struct SessionsSendParams: Codable, Sendable { deliver: Bool? = nil, suppresscommandinterpretation: Bool? = nil, senderattribution: [String: AnyCodable]? = nil, + personalautomations: Bool? = nil, attachments: [[String: AnyCodable]]? = nil, timeoutms: Int? = nil, idempotencykey: String? = nil) @@ -7659,6 +7661,7 @@ public struct SessionsSendParams: Codable, Sendable { self.deliver = deliver self.suppresscommandinterpretation = suppresscommandinterpretation self.senderattribution = senderattribution + self.personalautomations = personalautomations self.attachments = attachments self.timeoutms = timeoutms self.idempotencykey = idempotencykey @@ -7672,6 +7675,7 @@ public struct SessionsSendParams: Codable, Sendable { case deliver case suppresscommandinterpretation = "suppressCommandInterpretation" case senderattribution = "senderAttribution" + case personalautomations = "personalAutomations" case attachments case timeoutms = "timeoutMs" case idempotencykey = "idempotencyKey" @@ -17686,6 +17690,7 @@ public struct ChatSendParams: Codable, Sendable { public let systemprovenancereceipt: String? public let suppresscommandinterpretation: Bool? public let senderattribution: [String: AnyCodable]? + public let personalautomations: Bool? public let expectedleafentryid: AnyCodable? public let requireexactleaf: Bool? public let expectedsessionroutingcontract: String? @@ -17714,6 +17719,7 @@ public struct ChatSendParams: Codable, Sendable { systemprovenancereceipt: String? = nil, suppresscommandinterpretation: Bool? = nil, senderattribution: [String: AnyCodable]? = nil, + personalautomations: Bool? = nil, expectedleafentryid: AnyCodable? = nil, requireexactleaf: Bool? = nil, expectedsessionroutingcontract: String? = nil, @@ -17741,6 +17747,7 @@ public struct ChatSendParams: Codable, Sendable { self.systemprovenancereceipt = systemprovenancereceipt self.suppresscommandinterpretation = suppresscommandinterpretation self.senderattribution = senderattribution + self.personalautomations = personalautomations self.expectedleafentryid = expectedleafentryid self.requireexactleaf = requireexactleaf self.expectedsessionroutingcontract = expectedsessionroutingcontract @@ -17769,6 +17776,7 @@ public struct ChatSendParams: Codable, Sendable { systemprovenancereceipt: String? = nil, suppresscommandinterpretation: Bool? = nil, senderattribution: [String: AnyCodable]? = nil, + personalautomations: Bool? = nil, expectedleafentryid: AnyCodable? = nil, requireexactleaf: Bool? = nil, expectedsessionroutingcontract: String? = nil, @@ -17797,6 +17805,7 @@ public struct ChatSendParams: Codable, Sendable { systemprovenancereceipt: systemprovenancereceipt, suppresscommandinterpretation: suppresscommandinterpretation, senderattribution: senderattribution, + personalautomations: personalautomations, expectedleafentryid: expectedleafentryid, requireexactleaf: requireexactleaf, expectedsessionroutingcontract: expectedsessionroutingcontract, @@ -17826,6 +17835,7 @@ public struct ChatSendParams: Codable, Sendable { case systemprovenancereceipt = "systemProvenanceReceipt" case suppresscommandinterpretation = "suppressCommandInterpretation" case senderattribution = "senderAttribution" + case personalautomations = "personalAutomations" case expectedleafentryid = "expectedLeafEntryId" case requireexactleaf = "requireExactLeaf" case expectedsessionroutingcontract = "expectedSessionRoutingContract" diff --git a/packages/gateway-protocol/src/schema/logs-chat.ts b/packages/gateway-protocol/src/schema/logs-chat.ts index 0e03b515f3a..638fc37f05d 100644 --- a/packages/gateway-protocol/src/schema/logs-chat.ts +++ b/packages/gateway-protocol/src/schema/logs-chat.ts @@ -150,6 +150,8 @@ export const ChatSendParamsSchema = closedObject({ systemProvenanceReceipt: Type.Optional(Type.String()), suppressCommandInterpretation: Type.Optional(Type.Boolean()), senderAttribution: Type.Optional(ChatSenderAttributionSchema), + /** Trusted relay proof for a private conversation in the attributed Agent. */ + personalAutomations: Type.Optional(Type.Literal(true)), // Client's believed active-branch leaf entry id. A mismatch with the // session's current active leaf rejects the send so stale views cannot post elsewhere. expectedLeafEntryId: Type.Optional(Type.Union([NonEmptyString, Type.Null()])), diff --git a/packages/gateway-protocol/src/schema/sessions.ts b/packages/gateway-protocol/src/schema/sessions.ts index 00f6e70935b..9fc87f290cd 100644 --- a/packages/gateway-protocol/src/schema/sessions.ts +++ b/packages/gateway-protocol/src/schema/sessions.ts @@ -445,6 +445,7 @@ export const SessionsSendParamsSchema = closedObject({ /** Trusted relays may preserve the same provenance controls as chat.send. */ suppressCommandInterpretation: Type.Optional(Type.Boolean()), senderAttribution: Type.Optional(ChatSenderAttributionSchema), + personalAutomations: Type.Optional(Type.Literal(true)), attachments: Type.Optional(ChatAttachmentsSchema), timeoutMs: Type.Optional(Type.Integer({ minimum: 0 })), idempotencyKey: Type.Optional(NonEmptyString), diff --git a/packages/platformclaw-control-plane/src/browser-gateway-assertions.ts b/packages/platformclaw-control-plane/src/browser-gateway-assertions.ts index 4a37ff17226..59bcf79d51a 100644 --- a/packages/platformclaw-control-plane/src/browser-gateway-assertions.ts +++ b/packages/platformclaw-control-plane/src/browser-gateway-assertions.ts @@ -24,7 +24,7 @@ export class BrowserGatewayAssertions { } } - ownedSessionKey(agentId: string, rawSessionKey: unknown, label: string): void { + ownedSessionKey(agentId: string, rawSessionKey: unknown, label: string): string { const sessionKey = optionalString(rawSessionKey); if (!sessionKey) { this.fail("invalid-params", `${label} is required`); @@ -32,6 +32,7 @@ export class BrowserGatewayAssertions { if (this.resolveAgentIdFromSessionKey(sessionKey) !== agentId) { this.fail("cross-agent-denied", `browser access denied for ${label}`); } + return sessionKey; } sessionKeyArray(agentId: string, value: unknown, label: string, required: boolean): void { diff --git a/packages/platformclaw-control-plane/src/browser-gateway-cron-controller.ts b/packages/platformclaw-control-plane/src/browser-gateway-cron-controller.ts index 5052ff4defe..b0ab5c5a231 100644 --- a/packages/platformclaw-control-plane/src/browser-gateway-cron-controller.ts +++ b/packages/platformclaw-control-plane/src/browser-gateway-cron-controller.ts @@ -60,7 +60,7 @@ async function assertConfiguredCronModel( } } -function assertEffectiveCronDelivery( +function prepareEffectiveCronUpdate( context: BrowserCronContext, currentJob: JsonObject, prepared: JsonObject, @@ -69,7 +69,20 @@ function assertEffectiveCronDelivery( prepared.patch && typeof prepared.patch === "object" && !Array.isArray(prepared.patch) ? (prepared.patch as JsonObject) : {}; - const delivery = patch.delivery === undefined ? currentJob.delivery : patch.delivery; + const currentDelivery = currentJob.delivery as JsonObject | undefined; + if (currentJob.sessionTarget === "current" && currentDelivery?.channel === "webchat") { + const sessionKey = optionalString(currentJob.sessionKey); + if (!sessionKey || (patch.sessionTarget !== undefined && patch.sessionTarget !== "current")) { + context.fail("method-not-allowed", "this cron job must stay in its original conversation"); + } + // The browser editor sends last for announce and omits the channel for + // none. Keep this job's exact transcript destination across both edits. + patch.sessionKey = sessionKey; + if (patch.delivery !== undefined) { + patch.delivery = { ...(patch.delivery as JsonObject), channel: "webchat" }; + } + } + const delivery = patch.delivery === undefined ? currentDelivery : patch.delivery; const sessionTarget = patch.sessionTarget === undefined ? currentJob.sessionTarget : patch.sessionTarget; if (patch.sessionTarget === "current" && currentJob.sessionTarget !== "current") { @@ -165,7 +178,7 @@ export async function preflightCronMutation( return; } if (method === "cron.update") { - assertEffectiveCronDelivery(context, job, prepared); + prepareEffectiveCronUpdate(context, job, prepared); } await assertConfiguredCronModel(context, method, prepared, job); const expectedConfigRevision = optionalString(prepared.expectedConfigRevision); diff --git a/packages/platformclaw-control-plane/src/browser-gateway-proxy.acp.test.ts b/packages/platformclaw-control-plane/src/browser-gateway-proxy.acp.test.ts index 6e1573306f2..555b2d2bedc 100644 --- a/packages/platformclaw-control-plane/src/browser-gateway-proxy.acp.test.ts +++ b/packages/platformclaw-control-plane/src/browser-gateway-proxy.acp.test.ts @@ -60,6 +60,7 @@ describe("BrowserGatewayProxy ACP commands", () => { idempotencyKey: `request-${message}`, agentId: binding.agentId, deliver: false, + personalAutomations: true, senderAttribution: { id: user.accountId, name: user.displayName, diff --git a/packages/platformclaw-control-plane/src/browser-gateway-proxy.cron.test.ts b/packages/platformclaw-control-plane/src/browser-gateway-proxy.cron.test.ts index 99d51ac8929..54180854d81 100644 --- a/packages/platformclaw-control-plane/src/browser-gateway-proxy.cron.test.ts +++ b/packages/platformclaw-control-plane/src/browser-gateway-proxy.cron.test.ts @@ -193,6 +193,56 @@ describe("BrowserGatewayProxy cron", () => { }); }); + it("keeps a private conversation job's delivery and session through browser management", async () => { + const { binding, proxy, request, token } = await setup(); + const sessionKey = `agent:${binding.agentId}:dashboard:private`; + const owner = { agentId: binding.agentId, sessionKey, accountId: "first.user" }; + let job = safeCronJob(binding.agentId, { + sessionTarget: "current", + sessionKey, + owner, + delivery: { mode: "announce", channel: "webchat" }, + }); + const jobRef = { id: job.id, expectedConfigRevision: "revision-1" }; + request.mockResolvedValueOnce({ jobs: [job], total: 1, hasMore: false }); + await expect(proxy.request(token, "cron.list", {})).resolves.toMatchObject({ jobs: [job] }); + + for (const delivery of [{ mode: "none" }, { mode: "announce", channel: "last" }]) { + const updated = { ...job, delivery: { mode: delivery.mode, channel: "webchat" } }; + request.mockResolvedValueOnce(job).mockResolvedValueOnce(updated); + await expect( + proxy.request(token, "cron.update", { ...jobRef, patch: { delivery } }), + ).resolves.toEqual(updated); + expect(request).toHaveBeenLastCalledWith("cron.update", { + ...jobRef, + patch: { agentId: binding.agentId, sessionKey, delivery: updated.delivery }, + }); + job = updated; + } + + request.mockClear(); + request.mockResolvedValueOnce(job); + await expect( + proxy.request(token, "cron.update", { ...jobRef, patch: { sessionTarget: "isolated" } }), + ).rejects.toMatchObject({ code: "method-not-allowed" }); + expect(request).toHaveBeenCalledExactlyOnceWith("cron.get", { id: job.id }); + + request.mockClear(); + await expect( + proxy.request(token, "cron.update", { + ...jobRef, + patch: { delivery: { mode: "announce", channel: "knox", to: "dm:foreign" } }, + }), + ).rejects.toMatchObject({ code: "method-not-allowed" }); + expect(request).not.toHaveBeenCalled(); + + for (const method of ["cron.run", "cron.remove"]) { + request.mockResolvedValueOnce(job).mockResolvedValueOnce({ ok: true }); + await expect(proxy.request(token, method, jobRef)).resolves.toEqual({ ok: true }); + expect(request).toHaveBeenLastCalledWith(method, jobRef); + } + }); + it("returns an empty run-history page when the owned registry has no jobs", async () => { const { proxy, request, token } = await setup(); request.mockResolvedValueOnce({ jobs: [], total: 0, hasMore: false }); diff --git a/packages/platformclaw-control-plane/src/browser-gateway-proxy.messaging.test.ts b/packages/platformclaw-control-plane/src/browser-gateway-proxy.messaging.test.ts index 4d506e3b064..865b0eba9e2 100644 --- a/packages/platformclaw-control-plane/src/browser-gateway-proxy.messaging.test.ts +++ b/packages/platformclaw-control-plane/src/browser-gateway-proxy.messaging.test.ts @@ -55,6 +55,7 @@ describe("BrowserGatewayProxy personal session messaging", () => { timeoutMs: 10_000, idempotencyKey: "run-1", deliver: false, + personalAutomations: true, suppressCommandInterpretation: true, senderAttribution: { id: user.accountId, @@ -72,7 +73,12 @@ describe("BrowserGatewayProxy personal session messaging", () => { await expect( proxy.request(token, method, { key: "agent:other:main", message: "hello" }), ).rejects.toMatchObject({ code: "cross-agent-denied" }); - for (const field of ["senderAttribution", "suppressCommandInterpretation", "deliver"]) { + for (const field of [ + "senderAttribution", + "suppressCommandInterpretation", + "deliver", + "personalAutomations", + ]) { await expect( proxy.request(token, method, { key, message: "hello", [field]: true }), ).rejects.toMatchObject({ code: "method-not-allowed" }); diff --git a/packages/platformclaw-control-plane/src/browser-gateway-proxy.model-selection.test.ts b/packages/platformclaw-control-plane/src/browser-gateway-proxy.model-selection.test.ts index 6e7ac79ca4e..28410d92bee 100644 --- a/packages/platformclaw-control-plane/src/browser-gateway-proxy.model-selection.test.ts +++ b/packages/platformclaw-control-plane/src/browser-gateway-proxy.model-selection.test.ts @@ -78,6 +78,7 @@ describe("BrowserGatewayProxy model selection", () => { message: "hello", idempotencyKey: expect.any(String), deliver: false, + personalAutomations: true, senderAttribution: expect.objectContaining({ id: user.accountId, profileId: user.id }), suppressCommandInterpretation: true, }); diff --git a/packages/platformclaw-control-plane/src/browser-gateway-proxy.sessions.test.ts b/packages/platformclaw-control-plane/src/browser-gateway-proxy.sessions.test.ts index a0b15f11c55..7d016663150 100644 --- a/packages/platformclaw-control-plane/src/browser-gateway-proxy.sessions.test.ts +++ b/packages/platformclaw-control-plane/src/browser-gateway-proxy.sessions.test.ts @@ -400,6 +400,7 @@ describe("BrowserGatewayProxy session lifecycle", () => { agentId: binding.agentId, deliver: false, suppressCommandInterpretation: true, + personalAutomations: true, senderAttribution: { id: user.accountId, name: user.displayName, diff --git a/packages/platformclaw-control-plane/src/browser-gateway-proxy.test.ts b/packages/platformclaw-control-plane/src/browser-gateway-proxy.test.ts index c7852f33796..78a1f300c9e 100644 --- a/packages/platformclaw-control-plane/src/browser-gateway-proxy.test.ts +++ b/packages/platformclaw-control-plane/src/browser-gateway-proxy.test.ts @@ -558,6 +558,7 @@ describe("BrowserGatewayProxy", () => { deliver: false, queueMode: "steer", expectedLeafEntryId: "leaf-1", + personalAutomations: true, replyToId: "message-1", senderAttribution: expect.objectContaining({ id: user.accountId, @@ -760,6 +761,7 @@ describe("BrowserGatewayProxy", () => { sessionKey: createdKey, agentId: binding.agentId, message: "hello", + personalAutomations: true, idempotencyKey: expect.any(String), deliver: false, senderAttribution: expect.objectContaining({ @@ -806,6 +808,7 @@ describe("BrowserGatewayProxy", () => { sessionKey: createdKey, agentId: binding.agentId, message: "", + personalAutomations: true, attachments: [attachment], idempotencyKey: expect.any(String), deliver: false, diff --git a/packages/platformclaw-control-plane/src/browser-gateway-proxy.ts b/packages/platformclaw-control-plane/src/browser-gateway-proxy.ts index 1a401047178..cd7f9c41036 100644 --- a/packages/platformclaw-control-plane/src/browser-gateway-proxy.ts +++ b/packages/platformclaw-control-plane/src/browser-gateway-proxy.ts @@ -637,7 +637,11 @@ export class BrowserGatewayProxy { const keyField = PLATFORMCLAW_WEB_SESSION_KEY_METHODS.get(method); if (keyField) { this.assertions.optionalAgentId(access.binding.agentId, params.agentId, method); - this.assertions.ownedSessionKey(access.binding.agentId, params[keyField], keyField); + const sessionKey = this.assertions.ownedSessionKey( + access.binding.agentId, + params[keyField], + keyField, + ); if (method === "chat.send" || method === "sessions.send" || method === "sessions.steer") { const gatewayParams = { ...params }; delete gatewayParams["__controlUiReconnectResume"]; @@ -647,6 +651,7 @@ export class BrowserGatewayProxy { deliver: false, // Browser parameters are validated before this server-owned identity is added. senderAttribution: createBrowserSenderAttribution(access), + ...(this.spaceAccess.isPersonalSession(sessionKey) ? { personalAutomations: true } : {}), }; } // Never let a browser-selected run id cross the shared Gateway client. diff --git a/packages/platformclaw-control-plane/src/browser-gateway-space-access.ts b/packages/platformclaw-control-plane/src/browser-gateway-space-access.ts index 7093bb81bc7..c640aac9690 100644 --- a/packages/platformclaw-control-plane/src/browser-gateway-space-access.ts +++ b/packages/platformclaw-control-plane/src/browser-gateway-space-access.ts @@ -117,7 +117,7 @@ export class BrowserGatewaySpaceAccess { this.options.spaceService?.conversations.assertNativeRequest(access.user.id, method, params); } - private isPersonalSession(sessionKey: string): boolean { + isPersonalSession(sessionKey: string): boolean { return ( !isSpaceConversationSession(sessionKey) && !this.options.spaceService?.spaces.registeredConversation(sessionKey) diff --git a/packages/platformclaw-control-plane/src/space-conversations.test.ts b/packages/platformclaw-control-plane/src/space-conversations.test.ts index 18829c067d7..866d19582db 100644 --- a/packages/platformclaw-control-plane/src/space-conversations.test.ts +++ b/packages/platformclaw-control-plane/src/space-conversations.test.ts @@ -35,10 +35,14 @@ describe("Space-created personal conversations", () => { expect.objectContaining({ agentId: f.alice.binding.agentId, sessionKey: conversation.sessionKey, - senderAttribution: expect.objectContaining({ profileId: f.alice.user.id }), + senderAttribution: expect.objectContaining({ + profileId: f.alice.user.id, + isOwner: false, + }), deliver: false, }), ); + expect(f.request.mock.lastCall?.[1]).not.toHaveProperty("personalAutomations"); expect(await create(f)).toEqual(conversation); expect(f.request.mock.calls.filter(([method]) => method === "sessions.create")).toHaveLength(1); await expect( diff --git a/src/agents/agent-tools.personal-workspace.test.ts b/src/agents/agent-tools.personal-workspace.test.ts index 2d43769bfbe..e736381b802 100644 --- a/src/agents/agent-tools.personal-workspace.test.ts +++ b/src/agents/agent-tools.personal-workspace.test.ts @@ -7,6 +7,7 @@ import { createOpenClawCodingTools } from "./agent-tools.js"; import { createAgentToolsSandboxContext } from "./test-helpers/agent-tools-sandbox-context.js"; import { createHostSandboxFsBridge } from "./test-helpers/host-sandbox-fs-bridge.js"; import { AGENT_WORKSPACE_TOOL_NAMES } from "./tools/agent-workspace-tools.js"; +import { AUTOMATIONS_TOOL_NAME } from "./tools/automations-tool-name.js"; import { readWorkspaceStateSnapshot } from "./workspace-state-store.js"; const roots: string[] = []; @@ -73,6 +74,34 @@ function requireTool(tools: ReturnType, name: } describe("personal Agent workspace authority", () => { + it("exposes only the scoped automations tool for a matching browser grant", async () => { + const ctx = await fixture(); + const ownerToolNames = ( + senderAgentId: string, + personalAutomations: string | undefined, + sessionKey = "agent:main:main", + ) => + createOpenClawCodingTools({ + agentId: "main", + workspaceDir: ctx.agentWorkspaceDir, + config: { tools: { profile: "full" } }, + sessionKey, + senderIsOwner: false, + senderAgentId, + toolBindings: { personalAutomations }, + wrapBeforeToolCallHook: false, + }) + .filter((tool) => GATEWAY_OWNER_ONLY_CORE_TOOLS.some((name) => name === tool.name)) + .map((tool) => tool.name); + + expect(ownerToolNames("main", "main")).toEqual([AUTOMATIONS_TOOL_NAME]); + expect(ownerToolNames("main", undefined)).toEqual([]); + expect(ownerToolNames("foreign", "main")).toEqual([]); + expect(ownerToolNames("main", "foreign")).toEqual([]); + expect(ownerToolNames("main", "main", "agent:foreign:main")).toEqual([]); + expect(ownerToolNames("main", "main", "agent:main:cron:job")).toEqual([]); + }); + it("allows the bound Agent profile and bootstrap without Gateway owner tools", async () => { const ctx = await fixture(); const configPath = path.join(ctx.root, "openclaw.json"); diff --git a/src/agents/agent-tools.ts b/src/agents/agent-tools.ts index 07145592865..692e28030ae 100644 --- a/src/agents/agent-tools.ts +++ b/src/agents/agent-tools.ts @@ -27,6 +27,7 @@ import { getPluginToolMeta } from "../plugins/tools.js"; import { isCronSessionKey, isSubagentSessionKey } from "../routing/session-key.js"; import { GATEWAY_OWNER_ONLY_CORE_TOOLS } from "../security/dangerous-tools.js"; import type { InputProvenance } from "../sessions/input-provenance.js"; +import { parseAgentSessionKey } from "../sessions/session-key-utils.js"; import type { SkillSnapshot, SkillUsagePath } from "../skills/types.js"; import type { SkillWorkshopRunOptions } from "../skills/workshop/types.js"; import { resolveGatewayMessageChannel } from "../utils/message-channel.js"; @@ -110,6 +111,7 @@ import { AGENT_WORKSPACE_TOOL_NAMES, createAgentWorkspaceTools, } from "./tools/agent-workspace-tools.js"; +import { AUTOMATIONS_TOOL_NAME } from "./tools/automations-tool-name.js"; import { replaceWithEffectiveCronCreatorToolAllowlist, type CronCreatorToolAllowlistEntry, @@ -677,10 +679,28 @@ function createOpenClawCodingToolsInternal(options?: OpenClawCodingToolsOptions) }, recordToolPrepStage: options?.recordToolPrepStage, }); + const runSessionKey = (options?.runSessionKey ?? options?.sessionKey)?.trim(); + // The browser grant restores one bounded tool without inheriting the relay's owner authority. + const personalAutomationsSessionKey = + options?.senderIsOwner === false && + includeOpenClawTools && + agentId && + options.senderAgentId === agentId && + options.toolBindings?.personalAutomations === agentId && + parseAgentSessionKey(runSessionKey)?.agentId === agentId && + !isCronSessionKey(runSessionKey) && + !isSubagentSessionKey(runSessionKey) + ? runSessionKey + : undefined; const ownerOnlyCoreToolDenylist = options?.senderIsOwner === false ? [...GATEWAY_OWNER_ONLY_CORE_TOOLS] : []; - const ownerOnlyCoreToolPolicy = - ownerOnlyCoreToolDenylist.length > 0 ? { deny: ownerOnlyCoreToolDenylist } : undefined; + const ownerOnlyCoreToolPolicy = ownerOnlyCoreToolDenylist.length + ? { + deny: personalAutomationsSessionKey + ? ownerOnlyCoreToolDenylist.filter((name) => name !== AUTOMATIONS_TOOL_NAME) + : ownerOnlyCoreToolDenylist, + } + : undefined; const pluginToolAllowlist = appendRuntimePluginToolGrant( capabilityProfile.policy.explicitToolAllowlist, runtimePluginToolGrant, @@ -839,6 +859,7 @@ function createOpenClawCodingToolsInternal(options?: OpenClawCodingToolsOptions) pluginToolAllowlist, pluginToolDenylist, cronCreatorToolAllowlist, + personalAutomationsSessionKey, currentChannelId: options?.currentChannelId, currentChatType: options?.chatType, currentMessagingTarget: options?.currentMessagingTarget, @@ -932,7 +953,7 @@ function createOpenClawCodingToolsInternal(options?: OpenClawCodingToolsOptions) }); options?.recordToolPrepStage?.("model-provider-policy"); // Sender identity is primarily command/action auth, with one Gateway parity exception: - // explicit non-owner callers never receive owner-only control-plane core tools. + // explicit non-owner callers receive only the control-plane tools scoped above. const subagentFiltered = applyToolPolicyPipeline({ tools: toolsForModelProvider, toolMeta: (tool) => getPluginToolMeta(tool), diff --git a/src/agents/embedded-agent-runner/run-state.ts b/src/agents/embedded-agent-runner/run-state.ts index cc880a2750b..cd8df447bbe 100644 --- a/src/agents/embedded-agent-runner/run-state.ts +++ b/src/agents/embedded-agent-runner/run-state.ts @@ -45,6 +45,7 @@ export type EmbeddedAgentQueueHandle = { abort: (reason?: "restart") => void; sourceReplyDeliveryMode?: SourceReplyDeliveryMode; taskSuggestionDeliveryMode?: TaskSuggestionDeliveryMode; + personalAutomationsAgentId?: string; }; export type EmbeddedAgentQueueMessageOptions = ReplyBackendQueueMessageOptions; diff --git a/src/agents/embedded-agent-runner/run/attempt-stream-prepare.ts b/src/agents/embedded-agent-runner/run/attempt-stream-prepare.ts index 8becd7bb575..2ef58fc073e 100644 --- a/src/agents/embedded-agent-runner/run/attempt-stream-prepare.ts +++ b/src/agents/embedded-agent-runner/run/attempt-stream-prepare.ts @@ -388,6 +388,7 @@ export function prepareEmbeddedAttemptStream(input: { attempt.onAttemptAbort?.(); input.abortRun(false, reason === "restart" ? createAgentRunRestartAbortError() : undefined); }; + const personalAutomationsAgentId = attempt.toolBindings?.personalAutomations; const queueHandle: AttemptStreamQueueHandle = { kind: "embedded", runId: attempt.runId, @@ -421,6 +422,7 @@ export function prepareEmbeddedAttemptStream(input: { supportsQueueMessageImages: true, sourceReplyDeliveryMode: attempt.sourceReplyDeliveryMode, taskSuggestionDeliveryMode: attempt.taskSuggestionDeliveryMode, + ...(typeof personalAutomationsAgentId === "string" ? { personalAutomationsAgentId } : {}), cancel: abortActiveRunExternally, abort: (reason) => abortActiveRunExternally(reason), }; diff --git a/src/agents/embedded-agent-runner/runs.steering-authority.test.ts b/src/agents/embedded-agent-runner/runs.steering-authority.test.ts new file mode 100644 index 00000000000..f84bd6758d8 --- /dev/null +++ b/src/agents/embedded-agent-runner/runs.steering-authority.test.ts @@ -0,0 +1,47 @@ +import { expect, it, vi } from "vitest"; +import { + clearActiveEmbeddedRun, + queueEmbeddedAgentMessageWithOutcomeAsync, + setActiveEmbeddedRun, +} from "./runs.js"; + +it.each([ + { activeScope: "alice", incomingScope: undefined, queued: false }, + { activeScope: undefined, incomingScope: "alice", queued: false }, + { activeScope: "alice", incomingScope: "bob", queued: false }, + { activeScope: "alice", incomingScope: "alice", queued: true }, + { activeScope: undefined, incomingScope: undefined, queued: true }, +])( + "steers only within the same personal automation scope ($activeScope/$incomingScope)", + async ({ activeScope, incomingScope, queued }) => { + const queueMessage = vi.fn(async () => {}); + const sessionId = "personal-automation-steering"; + const handle = { + queueMessage, + isStreaming: () => true, + isCompacting: () => false, + abort: () => {}, + personalAutomationsAgentId: activeScope, + }; + setActiveEmbeddedRun(sessionId, handle); + try { + const outcome = await queueEmbeddedAgentMessageWithOutcomeAsync( + sessionId, + "continue", + incomingScope ? { personalAutomationsAgentId: incomingScope } : undefined, + ); + if (queued) { + expect(outcome.queued).toBe(true); + expect(queueMessage).toHaveBeenCalledOnce(); + } else { + expect(outcome).toMatchObject({ + queued: false, + reason: "personal_automations_scope_mismatch", + }); + expect(queueMessage).not.toHaveBeenCalled(); + } + } finally { + clearActiveEmbeddedRun(sessionId, handle); + } + }, +); diff --git a/src/agents/embedded-agent-runner/runs.ts b/src/agents/embedded-agent-runner/runs.ts index 2b75d32d78d..08bb8aea06f 100644 --- a/src/agents/embedded-agent-runner/runs.ts +++ b/src/agents/embedded-agent-runner/runs.ts @@ -79,6 +79,7 @@ type EmbeddedAgentQueueFailureReason = | "image_input_unsupported" | "source_reply_delivery_mode_mismatch" | "task_suggestion_delivery_mode_mismatch" + | "personal_automations_scope_mismatch" | "transcript_commit_wait_unsupported" | "question_unavailable" | "runtime_rejected"; diff --git a/src/agents/openclaw-tools.ts b/src/agents/openclaw-tools.ts index 7728627b9cf..a62e32357b2 100644 --- a/src/agents/openclaw-tools.ts +++ b/src/agents/openclaw-tools.ts @@ -363,6 +363,9 @@ export function createOpenClawTools(options?: CreateOpenClawToolsOptions): AnyAg threadId: options?.currentThreadTs ?? options?.agentThreadId, }, creatorToolAllowlist: options?.cronCreatorToolAllowlist, + ...(options?.personalAutomationsSessionKey + ? { personalSessionKey: options.personalAutomationsSessionKey } + : {}), runId: options?.runId, ...(options?.cronSelfRemoveOnlyJobId ? { selfRemoveOnlyJobId: options.cronSelfRemoveOnlyJobId } diff --git a/src/agents/openclaw-tools.types.ts b/src/agents/openclaw-tools.types.ts index 5aa16720e1a..8796dd6fb0e 100644 --- a/src/agents/openclaw-tools.types.ts +++ b/src/agents/openclaw-tools.types.ts @@ -60,6 +60,7 @@ export type CreateOpenClawToolsOptions = { pluginToolDenylist?: string[]; /** Effective caller tool surface to persist on isolated cron agentTurn jobs. */ cronCreatorToolAllowlist?: CronCreatorToolAllowlistEntry[]; + personalAutomationsSessionKey?: string; /** Current channel ID for auto-threading. */ currentChannelId?: string; /** Trusted normalized conversation kind for the active inbound turn. */ diff --git a/src/agents/prompt-surface.ts b/src/agents/prompt-surface.ts index 99950246e96..df7073591d2 100644 --- a/src/agents/prompt-surface.ts +++ b/src/agents/prompt-surface.ts @@ -26,7 +26,7 @@ export function buildOpenClawToolFallbackText(params: { "- browser: control OpenClaw's dedicated browser", "- canvas: present/eval/snapshot the Canvas", "- nodes: list/describe/notify/camera/screen on paired nodes", - `- ${AUTOMATIONS_TOOL_NAME}: manage automations (scheduled jobs) and wake events (use for reminders; when scheduling a reminder, write the systemEvent text as something that will read like a reminder when it fires, and mention that it is a reminder depending on the time gap between setting and firing; include recent context in reminder text if appropriate)`, + `- ${AUTOMATIONS_TOOL_NAME}: schedule reminders and recurring tasks using the actions in the tool schema. Write reminders to make sense when they fire, with useful context.`, "- conversations_list: list exact external conversation addresses", "- conversations_send: send directly to an external conversation", "- conversations_turn: send and wait for a correlated external reply", diff --git a/src/agents/system-prompt.ts b/src/agents/system-prompt.ts index 7c47ca73021..2de69a26e3a 100644 --- a/src/agents/system-prompt.ts +++ b/src/agents/system-prompt.ts @@ -917,7 +917,7 @@ export function buildAgentSystemPrompt(params: { canvas: "Control a paired node's Canvas; node required; file URLs are node-local", nodes: "Paired node status/control/media", [AUTOMATIONS_TOOL_NAME]: - "Schedule/wake. Reminder text must read as reminder when fired; mention reminder for delayed gaps; include useful recent context. This feature is called automations; never call it cron.", + "Schedule reminders and recurring tasks using the actions in the tool schema. Write reminders to make sense when they fire, with useful context. Call this feature automations.", message: "Message/channel actions", conversations_list: "List exact external conversation addresses", conversations_send: "Send directly to an external conversation", diff --git a/src/agents/tools/cron-tool-presentation.ts b/src/agents/tools/cron-tool-presentation.ts new file mode 100644 index 00000000000..94b5395f15d --- /dev/null +++ b/src/agents/tools/cron-tool-presentation.ts @@ -0,0 +1,41 @@ +import { isRecord } from "@openclaw/normalization-core/record-coerce"; + +export function formatCronTerminalPresentation( + params: unknown, + result: unknown, +): { text: string } | undefined { + if (!isRecord(params) || !isRecord(result) || !isRecord(result.details)) { + return undefined; + } + switch (params.action) { + case "status": { + const enabled = result.details.enabled === true ? "yes" : "no"; + return { text: `Automations scheduler status.\nEnabled: ${enabled}` }; + } + case "list": { + const total = + typeof result.details.total === "number" && + Number.isFinite(result.details.total) && + result.details.total >= 0 + ? Math.floor(result.details.total) + : undefined; + const count = + total ?? (Array.isArray(result.details.jobs) ? result.details.jobs.length : undefined); + return count === undefined + ? { text: "Automations listed." } + : { text: `Automations listed.\nCount: ${count}` }; + } + case "get": + return { text: "Automation loaded." }; + case "runs": { + const entries = Array.isArray(result.details.entries) + ? result.details.entries.length + : undefined; + return entries === undefined + ? { text: "Automation run history loaded." } + : { text: `Automation run history loaded.\nCount: ${entries}` }; + } + default: + return undefined; + } +} diff --git a/src/agents/tools/cron-tool-schema.ts b/src/agents/tools/cron-tool-schema.ts index b7cc7917afe..8140bb468e0 100644 --- a/src/agents/tools/cron-tool-schema.ts +++ b/src/agents/tools/cron-tool-schema.ts @@ -31,7 +31,8 @@ const CRON_ACTIONS = [ "wake", ] as const; -const CRON_SCHEDULE_KINDS = ["at", "every", "cron", "stream"] as const; +const TIMED_CRON_SCHEDULE_KINDS = ["at", "every", "cron"] as const; +const CRON_SCHEDULE_KINDS = [...TIMED_CRON_SCHEDULE_KINDS, "stream"] as const; const CRON_WAKE_MODES = ["now", "next-heartbeat"] as const; const CRON_PAYLOAD_KINDS = ["systemEvent", "agentTurn", "script"] as const; const CRON_DELIVERY_MODES = ["none", "announce", "webhook"] as const; @@ -94,29 +95,31 @@ function cronPayloadObjectSchema(params: { ); } +const timedCronScheduleProperties = { + at: Type.Optional(Type.String({ description: "ISO-8601 time (kind=at)" })), + everyMs: optionalPositiveIntegerSchema({ description: "Interval ms (kind=every)" }), + anchorMs: optionalNonNegativeIntegerSchema({ description: "Start anchor ms (kind=every)" }), + expr: Type.Optional( + Type.String({ + description: + 'Cron wall-time expr; never UTC-convert. Missing tz=Gateway local. Example "0 18 * * *", "Asia/Shanghai".', + }), + ), + tz: Type.Optional( + Type.String({ + description: + 'IANA timezone for wall-clock fields; missing=Gateway host local timezone. Example "Asia/Shanghai".', + }), + ), + staggerMs: optionalNonNegativeIntegerSchema({ description: "Jitter ms (kind=cron)" }), +}; + function createCronScheduleSchema(): TSchema { return Type.Optional( Type.Object( { kind: optionalStringEnum(CRON_SCHEDULE_KINDS, { description: "Schedule kind" }), - at: Type.Optional(Type.String({ description: "ISO-8601 time (kind=at)" })), - everyMs: optionalPositiveIntegerSchema({ description: "Interval ms (kind=every)" }), - anchorMs: optionalNonNegativeIntegerSchema({ - description: "Start anchor ms (kind=every)", - }), - expr: Type.Optional( - Type.String({ - description: - 'Cron wall-time expr; never UTC-convert. Missing tz=Gateway local. Example "0 18 * * *", "Asia/Shanghai".', - }), - ), - tz: Type.Optional( - Type.String({ - description: - 'IANA timezone for wall-clock fields; missing=Gateway host local timezone. Example "Asia/Shanghai".', - }), - ), - staggerMs: optionalNonNegativeIntegerSchema({ description: "Jitter ms (kind=cron)" }), + ...timedCronScheduleProperties, command: Type.Optional( Type.Array(Type.String({ minLength: 1 }), { minItems: 1, @@ -134,6 +137,28 @@ function createCronScheduleSchema(): TSchema { ); } +export const personalCronToolSchema = Type.Object( + { + action: stringEnum(["add"]), + job: Type.Object( + { + name: Type.Optional(Type.String()), + schedule: Type.Object( + { kind: stringEnum(TIMED_CRON_SCHEDULE_KINDS), ...timedCronScheduleProperties }, + { additionalProperties: false }, + ), + payload: Type.Object( + { kind: stringEnum(["agentTurn"]), message: Type.String({ minLength: 1 }) }, + { additionalProperties: false }, + ), + deleteAfterRun: Type.Optional(Type.Boolean()), + }, + { additionalProperties: false }, + ), + }, + { additionalProperties: false }, +); + function createCronPacingSchema(params: { nullableClears: boolean }): TSchema { const pacing = Type.Object( { diff --git a/src/agents/tools/cron-tool.test.ts b/src/agents/tools/cron-tool.test.ts index 5e6a0080830..edbbd369c4c 100644 --- a/src/agents/tools/cron-tool.test.ts +++ b/src/agents/tools/cron-tool.test.ts @@ -192,6 +192,76 @@ describe("cron tool", () => { extractDeliveryInfoMock.mockReturnValue({ deliveryContext: undefined, threadId: undefined }); }); + describe("personal automations", () => { + const sessionKey = "agent:personal:main"; + const job = { + name: "reminder", + schedule: { kind: "at", at: new Date(123).toISOString() }, + payload: { kind: "agentTurn", message: "Remind me about the report." }, + }; + + it("creates a signed current-session agent turn with a bounded tool cap", async () => { + const callGatewayTool = vi.fn().mockImplementation(async () => { + expect(getGatewayToolCallerIdentity()).toMatchObject({ + agentId: "personal", + sessionKey, + }); + return { ok: true }; + }); + const tool = createCronTool( + { + agentSessionKey: sessionKey, + personalSessionKey: sessionKey, + creatorToolAllowlist: ["read", "automations", "message"], + currentDeliveryContext: { channel: "knox", to: "knox-recipient" }, + }, + { callGatewayTool }, + ); + + await tool.execute("personal-add", { action: "add", job }); + + expect(callGatewayTool).toHaveBeenCalledExactlyOnceWith( + "cron.add", + expect.anything(), + expect.objectContaining({ + agentId: "personal", + sessionTarget: "current", + sessionKey, + delivery: { mode: "announce", channel: "webchat" }, + failureAlert: false, + payload: { + ...job.payload, + toolsAllow: ["read"], + toolsAllowIsDefault: true, + }, + }), + { requireAgentRuntimeIdentity: true }, + ); + }); + + it.each([ + { action: "wake", text: "Wake now." }, + { action: "run", jobId: "existing" }, + { action: "add", job, gatewayToken: "different-credential" }, + { action: "add", job, gatewayUrl: "ws://127.0.0.1:18789" }, + { action: "add", job: { ...job, sessionKey: "agent:personal:other" } }, + { action: "add", job: { ...job, delivery: { mode: "announce", channel: "knox" } } }, + { action: "add", job: { ...job, failureAlert: { to: "https://example.com" } } }, + { action: "add", job: { ...job, trigger: { script: "return true" } } }, + { action: "add", job: { ...job, schedule: { kind: "stream" } } }, + { action: "add", job: { ...job, payload: { kind: "systemEvent", text: "hello" } } }, + ])("rejects tool input outside the personal scheduling schema (%j)", async (args) => { + const callGatewayTool = vi.fn(); + const tool = createCronTool( + { agentSessionKey: sessionKey, personalSessionKey: sessionKey }, + { callGatewayTool }, + ); + + await expect(tool.execute("personal-add", args)).rejects.toThrow("Personal automations"); + expect(callGatewayTool).not.toHaveBeenCalled(); + }); + }); + it("allows scoped isolated cron runs to remove the current job", async () => { // Self-removal scope lets a cron-triggered run clean up its own schedule // without granting broad cron mutation access. diff --git a/src/agents/tools/cron-tool.ts b/src/agents/tools/cron-tool.ts index a0ea4435b13..3d66298e6dd 100644 --- a/src/agents/tools/cron-tool.ts +++ b/src/agents/tools/cron-tool.ts @@ -4,6 +4,7 @@ * Manages scheduled jobs, wake/run actions, delivery context, and reminder-style payload normalization. */ import { normalizeLowercaseStringOrEmpty } from "@openclaw/normalization-core/string-coerce"; +import { Check } from "typebox/value"; import { parseDurationMs } from "../../cli/parse-duration.js"; import { getRuntimeConfig, type OpenClawConfig } from "../../config/config.js"; import { resolveCronCreationDelivery } from "../../cron/delivery-context.js"; @@ -40,10 +41,12 @@ import { stripExistingContext, } from "./cron-tool-context.js"; import { capCronJobToolsAllowOnCreate } from "./cron-tool-creator-cap.js"; +import { formatCronTerminalPresentation } from "./cron-tool-presentation.js"; import { assertCronPacingInput, createCronToolSchema, CRON_TOOL_LIST_MAX_LIMIT, + personalCronToolSchema, } from "./cron-tool-schema.js"; import { assertNoCronShellExecution, updateCronJobFromAgentTool } from "./cron-tool-write.js"; import type { @@ -217,46 +220,6 @@ function filterCronStatusResultForSelfScope(result: unknown): unknown { return { enabled: isRecord(result) && result.enabled === true }; } -function formatCronTerminalPresentation( - params: unknown, - result: unknown, -): { text: string } | undefined { - if (!isRecord(params) || !isRecord(result) || !isRecord(result.details)) { - return undefined; - } - switch (params.action) { - case "status": { - const enabled = result.details.enabled === true ? "yes" : "no"; - return { text: `Automations scheduler status.\nEnabled: ${enabled}` }; - } - case "list": { - const total = - typeof result.details.total === "number" && - Number.isFinite(result.details.total) && - result.details.total >= 0 - ? Math.floor(result.details.total) - : undefined; - const count = - total ?? (Array.isArray(result.details.jobs) ? result.details.jobs.length : undefined); - return count === undefined - ? { text: "Automations listed." } - : { text: `Automations listed.\nCount: ${count}` }; - } - case "get": - return { text: "Automation loaded." }; - case "runs": { - const entries = Array.isArray(result.details.entries) - ? result.details.entries.length - : undefined; - return entries === undefined - ? { text: "Automation run history loaded." } - : { text: `Automation run history loaded.\nCount: ${entries}` }; - } - default: - return undefined; - } -} - function cronListResultHasJob(result: unknown, jobId: string): boolean { return ( isRecord(result) && @@ -284,11 +247,16 @@ function isOlderGatewayWithoutCompactCronList(error: unknown): boolean { export function createCronTool(opts?: CronToolOptions, deps?: CronToolDeps): AnyAgentTool { const callGateway = deps?.callGatewayTool ?? callGatewayTool; + const personalSessionKey = opts?.personalSessionKey; const tool: AnyAgentTool = { label: "Automations", name: AUTOMATIONS_TOOL_NAME, - displaySummary: CRON_TOOL_DISPLAY_SUMMARY, - description: `Gateway scheduler: reminders, delayed self-wakeups, loops, recurring work, event watchers. Never exec sleep/poll as timer. + displaySummary: personalSessionKey + ? "Schedule reminders and recurring work in this conversation." + : CRON_TOOL_DISPLAY_SUMMARY, + description: personalSessionKey + ? "Schedule a reminder or recurring agent task in this conversation. Use add with an at, every, or cron schedule and an agentTurn message. Results appear in this conversation." + : `Gateway scheduler: reminders, delayed self-wakeups, loops, recurring work, event watchers. Never exec sleep/poll as timer. ACTIONS: status | list [includeDisabled,limit?,offset?] (use nextOffset for the next page) | get jobId | add job | update jobId patch | remove jobId | run jobId (runMode "force"=now) | runs jobId = history | next_check in:"30m" (own paced run only) | wake text mode?:"now"|"next-heartbeat"(default) nudges a caller-owned lane (sessionKey/agentId to pick another). @@ -315,8 +283,16 @@ TRIGGER (condition watcher on every/cron): {script,once?}; needs cron.triggers.e DELIVERY {mode:"none"|"announce"|"webhook",channel?,to?,threadId?,bestEffort?}: where detached run output goes. Omitted=announce (current=>canonical session commit, plus one normal channel send for external chats; isolated=>last route; set channel/to for a specific chat — no messaging tool inside the run). A current announce succeeds only after its history commit; WebChat observes that commit live and after reconnect without another user message. Silent watcher=>mode:"none". webhook posts finished-run event to URL in \`to\`. Job wakeMode (main jobs): "now"(default)|"next-heartbeat". Restricted automation-run sessions: self status/list/get/runs/remove + own next_check only. failureAlert {...}|false disables. jobId canonical (id=compat). contextMessages 0-10 embeds recent chat lines into reminder text.`, - parameters: createCronToolSchema(), + parameters: personalSessionKey ? personalCronToolSchema : createCronToolSchema(), execute: async (_toolCallId, args) => { + if (personalSessionKey && personalSessionKey !== opts?.agentSessionKey?.trim()) { + throw new Error("Personal automations require the active conversation."); + } + if (personalSessionKey && !Check(personalCronToolSchema, args)) { + throw new Error( + "Personal automations accept only add with an at, every, or cron schedule and an agentTurn message in this conversation.", + ); + } const params = args as Record; const action = readStringParam(params, "action", { required: true }); assertCronSelfRemoveScope(opts, action, params); @@ -440,6 +416,12 @@ Job wakeMode (main jobs): "now"(default)|"next-heartbeat". Restricted automation throw new Error("job required"); } const canonicalJob = canonicalizeCronToolObject(params.job as Record); + if (personalSessionKey) { + canonicalJob.sessionTarget = "current"; + canonicalJob.sessionKey = personalSessionKey; + canonicalJob.delivery = { mode: "announce", channel: "webchat" }; + canonicalJob.failureAlert = false; + } assertNoCronShellExecution(canonicalJob); assertCronDeliveryInputNonBlankFields(canonicalJob.delivery); assertCronPacingInput(canonicalJob.pacing, { nullableClears: false }); @@ -467,7 +449,14 @@ Job wakeMode (main jobs): "now"(default)|"next-heartbeat". Restricted automation ) { delete job.enabled; } - capCronJobToolsAllowOnCreate(job, opts?.creatorToolAllowlist); + // Detached personal jobs must not recover delivery or scheduling tools by name. + const creatorToolAllowlist = personalSessionKey + ? (opts?.creatorToolAllowlist ?? []).filter((entry) => { + const name = typeof entry === "string" ? entry : entry.name; + return name !== AUTOMATIONS_TOOL_NAME && name !== "message"; + }) + : opts?.creatorToolAllowlist; + capCronJobToolsAllowOnCreate(job, creatorToolAllowlist); if (job && typeof job === "object") { const { mainKey, alias } = resolveMainSessionAlias(runtimeConfig); const resolvedSessionKey = opts?.agentSessionKey @@ -574,9 +563,11 @@ Job wakeMode (main jobs): "now"(default)|"next-heartbeat". Restricted automation } } return jsonResult( - await callGateway("cron.add", gatewayOpts, { - ...job, - }), + personalSessionKey + ? await callGateway("cron.add", gatewayOpts, job, { + requireAgentRuntimeIdentity: true, + }) + : await callGateway("cron.add", gatewayOpts, { ...job }), ); } case "update": { diff --git a/src/agents/tools/cron-tool.types.ts b/src/agents/tools/cron-tool.types.ts index 647b540efa5..2e180f857d4 100644 --- a/src/agents/tools/cron-tool.types.ts +++ b/src/agents/tools/cron-tool.types.ts @@ -20,6 +20,8 @@ export type CronToolOptions = { * need this cap persisted before the original session policy is lost. */ creatorToolAllowlist?: CronCreatorToolAllowlistEntry[]; + /** Host-authorized source session for add-only personal automations. */ + personalSessionKey?: string; selfRemoveOnlyJobId?: string; runId?: string; }; diff --git a/src/auto-reply/reply/agent-runner-run.ts b/src/auto-reply/reply/agent-runner-run.ts index 87df72e8e64..e0dc06628f1 100644 --- a/src/auto-reply/reply/agent-runner-run.ts +++ b/src/auto-reply/reply/agent-runner-run.ts @@ -254,6 +254,7 @@ export async function runReplyAgent( const steerText = opts?.questionAnswerBinding ? (followupRun.transcriptPrompt ?? followupRun.prompt) : followupRun.prompt; + const personalAutomationsAgentId = followupRun.run.toolBindings?.personalAutomations; const steerOutcome = await queueEmbeddedAgentMessageWithOutcomeAsync( steerSessionId, steerText, @@ -272,6 +273,7 @@ export async function runReplyAgent( ? { sourceReplyDeliveryMode: followupRun.run.sourceReplyDeliveryMode } : {}), taskSuggestionDeliveryMode: followupRun.run.taskSuggestionDeliveryMode, + ...(typeof personalAutomationsAgentId === "string" ? { personalAutomationsAgentId } : {}), ...(followupRun.userTurnTranscriptRecorder ? { userTurnTranscriptRecorder: followupRun.userTurnTranscriptRecorder } : {}), diff --git a/src/auto-reply/reply/agent-runner.runreplyagent.e2e.test.ts b/src/auto-reply/reply/agent-runner.runreplyagent.e2e.test.ts index fcb7deafa8c..14b0913f2f7 100644 --- a/src/auto-reply/reply/agent-runner.runreplyagent.e2e.test.ts +++ b/src/auto-reply/reply/agent-runner.runreplyagent.e2e.test.ts @@ -709,6 +709,7 @@ describe("runReplyAgent active steering", () => { "image_input_unsupported", "source_reply_delivery_mode_mismatch", "task_suggestion_delivery_mode_mismatch", + "personal_automations_scope_mismatch", "transcript_commit_wait_unsupported", "runtime_rejected", ] as const)("queues a follow-up when active steering fails with %s", async (reason) => { diff --git a/src/auto-reply/reply/reply-run-registry.ts b/src/auto-reply/reply/reply-run-registry.ts index 009d669d1aa..eb60a7158d9 100644 --- a/src/auto-reply/reply/reply-run-registry.ts +++ b/src/auto-reply/reply/reply-run-registry.ts @@ -51,6 +51,7 @@ export type ReplyBackendQueueMessageOptions = { waitForTranscriptCommit?: boolean; sourceReplyDeliveryMode?: SourceReplyDeliveryMode; taskSuggestionDeliveryMode?: TaskSuggestionDeliveryMode; + personalAutomationsAgentId?: string; /** Prepared channel turn to merge only at transcript persistence. */ userTurnTranscriptRecorder?: UserTurnTranscriptRecorder; }; @@ -65,6 +66,7 @@ export type ReplyBackendHandle = { readonly kind: ReplyBackendKind; readonly sourceReplyDeliveryMode?: SourceReplyDeliveryMode; readonly taskSuggestionDeliveryMode?: TaskSuggestionDeliveryMode; + readonly personalAutomationsAgentId?: string; /** True only when queueMessage preserves images supplied in its options. */ readonly supportsQueueMessageImages?: boolean; cancel(reason?: ReplyBackendCancelReason): void; @@ -85,16 +87,25 @@ export type ReplyBackendHandle = { type ReplyBackendQueueMessageMismatch = | "image_input_unsupported" | "source_reply_delivery_mode_mismatch" - | "task_suggestion_delivery_mode_mismatch"; + | "task_suggestion_delivery_mode_mismatch" + | "personal_automations_scope_mismatch"; /** Prevents steering a turn into a run that cannot preserve its model-facing input. */ export function resolveReplyBackendQueueMessageMismatch( backend: Pick< ReplyBackendHandle, - "sourceReplyDeliveryMode" | "supportsQueueMessageImages" | "taskSuggestionDeliveryMode" + | "sourceReplyDeliveryMode" + | "supportsQueueMessageImages" + | "taskSuggestionDeliveryMode" + | "personalAutomationsAgentId" >, options?: ReplyBackendQueueMessageOptions, ): ReplyBackendQueueMessageMismatch | undefined { + // Live steering uses the active run's tools. A different grant needs its own + // queued turn, even when both inputs address the same conversation. + if (options?.personalAutomationsAgentId !== backend.personalAutomationsAgentId) { + return "personal_automations_scope_mismatch"; + } if (options?.images?.length && backend.supportsQueueMessageImages !== true) { return "image_input_unsupported"; } diff --git a/src/cron/delivery-channel-validation.ts b/src/cron/delivery-channel-validation.ts index 4f9a971e74e..010dac215cd 100644 --- a/src/cron/delivery-channel-validation.ts +++ b/src/cron/delivery-channel-validation.ts @@ -8,6 +8,7 @@ import { import { normalizeAccountId } from "../routing/account-id.js"; import { resolveNormalizedAccountEntry } from "../routing/account-lookup.js"; import { isDeliverableMessageChannel, normalizeMessageChannel } from "../utils/message-channel.js"; +import { isCronTranscriptDelivery } from "./delivery-plan.js"; import { resolveFailureAlert } from "./service/failure-alerts.js"; import type { CronDelivery, CronFailureAlert, CronJobCreate } from "./types.js"; @@ -132,7 +133,11 @@ export async function assertValidCronAnnounceDelivery(params: { cfg: OpenClawConfig; delivery?: CronDelivery; }) { - if (params.delivery && (params.delivery.mode ?? "announce") === "announce") { + if ( + params.delivery && + (params.delivery.mode ?? "announce") === "announce" && + !isCronTranscriptDelivery(params.delivery) + ) { assertCompatibleAnnounceTarget({ channel: params.delivery.channel, to: params.delivery.to, diff --git a/src/cron/delivery-plan.ts b/src/cron/delivery-plan.ts index 5a075bf64ff..85d54833731 100644 --- a/src/cron/delivery-plan.ts +++ b/src/cron/delivery-plan.ts @@ -7,9 +7,14 @@ import { } from "@openclaw/normalization-core/string-coerce"; import type { CronFailureDestinationConfig } from "../config/types.cron.js"; import { resolveTargetPrefixedChannel } from "../infra/outbound/channel-target-prefix.js"; +import { INTERNAL_MESSAGE_CHANNEL } from "../utils/message-channel-constants.js"; import { shouldDefaultCronDeliveryToAnnounce } from "./delivery-defaults.js"; import type { CronDelivery, CronDeliveryMode, CronJob, CronMessageChannel } from "./types.js"; +export function isCronTranscriptDelivery(delivery?: CronDelivery): boolean { + return delivery?.channel === INTERNAL_MESSAGE_CHANNEL && delivery.mode !== "webhook"; +} + /** Normalized routing plan for a cron job's primary delivery behavior. */ export type CronDeliveryPlan = { mode: CronDeliveryMode; @@ -95,7 +100,11 @@ export function resolveCronDeliveryPlan(job: CronJob): CronDeliveryPlan { : deliveryChannel; return { mode: resolvedMode, - channel: resolvedMode === "webhook" ? undefined : channel, + channel: + resolvedMode === "webhook" || + (resolvedMode === "none" && isCronTranscriptDelivery(delivery)) + ? undefined + : channel, to, threadId: resolvedMode === "webhook" ? undefined : deliveryThreadId, accountId: deliveryAccountId, @@ -154,6 +163,10 @@ export function resolveFailureDestination( globalConfig?: CronFailureDestinationConfig, ): CronFailureDeliveryPlan | null { const delivery = job.delivery; + // Transcript-only jobs do not inherit an external failure destination. + if (isCronTranscriptDelivery(delivery)) { + return null; + } const jobFailureDest = delivery?.failureDestination as CronFailureDestinationInput | undefined; const hasJobFailureDest = jobFailureDest && typeof jobFailureDest === "object"; diff --git a/src/cron/isolated-agent/delivery-dispatch.double-announce.test.ts b/src/cron/isolated-agent/delivery-dispatch.double-announce.test.ts index 6de6863c157..b6c014c8301 100644 --- a/src/cron/isolated-agent/delivery-dispatch.double-announce.test.ts +++ b/src/cron/isolated-agent/delivery-dispatch.double-announce.test.ts @@ -172,11 +172,12 @@ import { } from "../../infra/outbound/outbound-session.js"; import { buildOutboundSessionContext } from "../../infra/outbound/session-context.js"; import { enqueueSystemEvent } from "../../infra/system-events.js"; +import { resolveCronDeliveryPlan, resolveFailureDestination } from "../delivery-plan.js"; import { dispatchCronDelivery, queueCronMessageToolDeliveryAwareness, } from "./delivery-dispatch.js"; -import type { DeliveryTargetResolution } from "./delivery-target.js"; +import { resolveDeliveryTarget, type DeliveryTargetResolution } from "./delivery-target.js"; import type { RunCronAgentTurnResult } from "./run.types.js"; import { expectsSubagentFollowup, isLikelyInterimCronMessage } from "./subagent-followup-hints.js"; import { @@ -2946,15 +2947,13 @@ describe("dispatchCronDelivery — double-announce guard", () => { sessionTarget: "current", runStartedAt: 1_000, }); - params.resolvedDelivery = { - ok: false, - channel: "webchat", - to: undefined, - accountId: undefined, - threadId: undefined, - mode: "implicit", - error: new Error("webchat has no outbound adapter"), - }; + const channel = "webchat"; + params.job.delivery = { mode: "announce", channel }; + params.resolvedDelivery = await resolveDeliveryTarget(params.cfg, params.agentId, { + channel, + sessionKey: params.sourceSessionKey, + }); + expect(params.resolvedDelivery).toMatchObject({ ok: false, channel, mode: "explicit" }); const state = await dispatchCronDelivery(params); @@ -2970,6 +2969,15 @@ describe("dispatchCronDelivery — double-announce guard", () => { signal: undefined, }); expect(deliverOutboundPayloads).not.toHaveBeenCalled(); + + const failureDestination = { mode: "webhook" as const, to: "https://example.invalid" }; + expect(resolveFailureDestination(params.job, failureDestination)).toBeNull(); + params.job.delivery = { mode: "none", channel }; + expect(resolveFailureDestination(params.job, failureDestination)).toBeNull(); + expect(resolveCronDeliveryPlan(params.job)).toMatchObject({ + requested: false, + channel: undefined, + }); }); it("commits a dashboard current-target completion without an external route", async () => { diff --git a/src/cron/isolated-agent/delivery-target.ts b/src/cron/isolated-agent/delivery-target.ts index 94335817e7b..49bf9d18898 100644 --- a/src/cron/isolated-agent/delivery-target.ts +++ b/src/cron/isolated-agent/delivery-target.ts @@ -17,6 +17,7 @@ import type { OutboundChannel } from "../../infra/outbound/targets.js"; import { normalizeAccountId } from "../../routing/session-key.js"; import { createLazyImportLoader } from "../../shared/lazy-promise.js"; import { normalizeSessionDeliveryState } from "../../utils/delivery-context.shared.js"; +import { INTERNAL_MESSAGE_CHANNEL } from "../../utils/message-channel-constants.js"; import { resolveCronStoredDeliveryContext } from "../delivery-context.js"; import { resolveCronAgentSessionKey } from "./session-key.js"; @@ -146,6 +147,16 @@ export async function resolveDeliveryTarget( options?: { dryRun?: boolean; inheritSessionThread?: boolean }, ): Promise { const requestedChannel = typeof jobPayload.channel === "string" ? jobPayload.channel : "last"; + if (requestedChannel === INTERNAL_MESSAGE_CHANNEL) { + // WebChat completion uses the bound transcript. Looking up a route here can + // otherwise inherit an external recipient from the agent's main session. + return { + ok: false, + channel: INTERNAL_MESSAGE_CHANNEL, + mode: "explicit", + error: new Error("WebChat delivery uses the owning session transcript"), + }; + } const explicitTo = typeof jobPayload.to === "string" ? jobPayload.to : undefined; const allowMismatchedLastTo = requestedChannel === "last"; const deliveryTargetRuntime = await loadDeliveryTargetRuntime(); diff --git a/src/cron/service/jobs-validation.ts b/src/cron/service/jobs-validation.ts index cdf8e7bd73a..c920f015e97 100644 --- a/src/cron/service/jobs-validation.ts +++ b/src/cron/service/jobs-validation.ts @@ -2,9 +2,9 @@ import { parseCodeModeScriptSyntax } from "../../agents/code-mode-script-syntax.js"; import { resolveCronTriggerMinIntervalMs } from "../../config/cron-limits.js"; import type { CronConfig } from "../../config/types.cron.js"; -import { normalizeAgentId } from "../../routing/session-key.js"; +import { normalizeAgentId, parseAgentSessionKey } from "../../routing/session-key.js"; import { compileSafeRegexDetailed } from "../../security/safe-regex.js"; -import { resolveCronDeliveryPlan } from "../delivery-plan.js"; +import { isCronTranscriptDelivery, resolveCronDeliveryPlan } from "../delivery-plan.js"; import { parseCronPacingBounds } from "../pacing.js"; import { assertSafeCronSessionTargetId } from "../session-target.js"; import type { CronDelivery, CronJob, CronJobPatch } from "../types.js"; @@ -194,10 +194,36 @@ export function assertMainSessionAgentId( } } -export function assertDeliverySupport(job: Pick) { +export function assertDeliverySupport(job: CronJob) { if (!job.delivery) { return; } + if (isCronTranscriptDelivery(job.delivery)) { + const sessionAgentId = job.sessionKey + ? parseAgentSessionKey(job.sessionKey)?.agentId + : undefined; + // The scheduler stamps this policy from signed caller identity. The RPC's + // public owner fields alone cannot authorize a transcript destination. + if ( + job.sessionTarget !== "current" || + job.payload.kind !== "agentTurn" || + !sessionAgentId || + job.agentId !== sessionAgentId || + job.owner?.agentId !== sessionAgentId || + job.scheduledToolPolicy?.mode !== "account" || + job.sessionKey !== job.scheduledToolPolicy.ownerSessionKey || + job.failureAlert !== false || + job.delivery.to !== undefined || + job.delivery.accountId !== undefined || + job.delivery.threadId !== undefined || + job.delivery.completionDestination !== undefined || + job.delivery.failureDestination !== undefined + ) { + throw new TypeError( + "delivery.channel webchat requires the authenticated current session without outbound delivery fields", + ); + } + } // No primary delivery and no completion webhook -- nothing to validate. if (job.delivery.mode === "none" && !job.delivery.completionDestination) { return; diff --git a/src/gateway/server-methods/chat-send-admission.ts b/src/gateway/server-methods/chat-send-admission.ts index edb8286f2fe..0430b034c0a 100644 --- a/src/gateway/server-methods/chat-send-admission.ts +++ b/src/gateway/server-methods/chat-send-admission.ts @@ -61,6 +61,7 @@ export async function admitChatSend(params: { agentId: session.agentId, sessionKey: session.sessionKey, senderAttribution: request.senderAttribution, + personalAutomationsAgentId: session.personalAutomationsAgentId, }) ) { return { ok: false as const }; diff --git a/src/gateway/server-methods/chat-send-pre-admission.ts b/src/gateway/server-methods/chat-send-pre-admission.ts index 094bb5593d5..2cbc5542f3c 100644 --- a/src/gateway/server-methods/chat-send-pre-admission.ts +++ b/src/gateway/server-methods/chat-send-pre-admission.ts @@ -124,6 +124,7 @@ export async function runChatSendPreAdmission(params: { agentId: session.agentId, sessionKey, senderAttribution: request.senderAttribution, + personalAutomationsAgentId: session.personalAutomationsAgentId, }) ) { return false; diff --git a/src/gateway/server-methods/chat-send-request.test.ts b/src/gateway/server-methods/chat-send-request.test.ts index 03bf0f57c35..aa20a95fabb 100644 --- a/src/gateway/server-methods/chat-send-request.test.ts +++ b/src/gateway/server-methods/chat-send-request.test.ts @@ -203,6 +203,45 @@ describe("normalizeChatSendRequest", () => { ).toMatchObject({ ok: true, value: { p: { toolBindings } } }); }); + it("requires admin scope and explicit restricted attribution for personal automations", () => { + const client = adminClient(); + client.internal = { + syntheticClient: true, + senderAttribution: { id: "internal.user", agentId: "main", isOwner: false }, + }; + const personalAutomations = true; + const senderAttribution = { id: "browser.user", agentId: " main ", isOwner: false }; + expect( + normalizeChatSendRequest({ params: validParams({ personalAutomations }), client }), + ).toEqual({ + ok: false, + error: "personal automations require restricted sender attribution with an agent ID", + }); + const params = validParams({ personalAutomations, senderAttribution }); + expect(normalizeChatSendRequest({ params, client: null })).toEqual({ + ok: false, + error: "sender attribution requires admin scope", + }); + expect(normalizeChatSendRequest({ params, client })).toMatchObject({ + ok: true, + value: { p: { personalAutomations }, senderAttribution: { agentId: "main", isOwner: false } }, + }); + }); + + it("rejects a paired copilot's attempt to set the reserved personal automations binding", () => { + expect( + normalizeChatSendRequest({ + params: validParams({ + toolBindings: { + browser: { kind: "tab", tabId: 1, targetId: "target" }, + personalAutomations: "main", + }, + }), + client: copilotClient(["run-tool-bindings"]), + }), + ).toEqual({ ok: false, error: "personal automations tool binding is reserved" }); + }); + it("accepts tool bindings only from a server-paired copilot identity", () => { const toolBindings = { browser: { kind: "tab", tabId: 1, targetId: "target" } }; const unpaired = copilotClient(["run-tool-bindings"]); diff --git a/src/gateway/server-methods/chat-send-request.ts b/src/gateway/server-methods/chat-send-request.ts index 8553b7ad53f..8420362fa50 100644 --- a/src/gateway/server-methods/chat-send-request.ts +++ b/src/gateway/server-methods/chat-send-request.ts @@ -60,6 +60,7 @@ type ChatSendRequestParams = { systemProvenanceReceipt?: string; suppressCommandInterpretation?: boolean; senderAttribution?: ChatSenderAttribution; + personalAutomations?: true; expectedLeafEntryId?: string | null; requireExactLeaf?: boolean; expectedSessionRoutingContract?: string; @@ -124,7 +125,10 @@ export function normalizeChatSendRequest(params: { p.queueMode = "followup"; } const suppressCommandInterpretation = p.suppressCommandInterpretation === true; - const requestedSenderResult = normalizeRequestedGatewaySenderAttribution(p.senderAttribution); + const requestedSenderResult = normalizeRequestedGatewaySenderAttribution( + p.senderAttribution, + p.personalAutomations, + ); if (!requestedSenderResult.ok) { return requestedSenderResult; } @@ -172,6 +176,9 @@ export function normalizeChatSendRequest(params: { const senderAttribution = resolveGatewaySenderAttribution(client, requestedSenderAttribution); const stopCommand = !suppressCommandInterpretation && isChatStopCommandText(inboundMessage); if (p.toolBindings) { + if (Object.hasOwn(p.toolBindings, "personalAutomations")) { + return { ok: false, error: "personal automations tool binding is reserved" }; + } if ( !client || !isBrowserCopilotClient(clientInfo) || diff --git a/src/gateway/server-methods/chat-send-scope.test.ts b/src/gateway/server-methods/chat-send-scope.test.ts index 051b876d0cb..73ac5234d9b 100644 --- a/src/gateway/server-methods/chat-send-scope.test.ts +++ b/src/gateway/server-methods/chat-send-scope.test.ts @@ -6,7 +6,7 @@ import { registerChatAbortController } from "../chat-abort.js"; import { createDirectChatContext } from "../server-chat.agent-events.test-helpers.js"; import { chatSendScopeDedupeKey, pendingChatSendDedupeKey } from "../server-shared.js"; import { setGatewayDedupeEntry } from "./agent-job.js"; -import { requireChatSendScope } from "./chat-send-scope.js"; +import { requireChatSendScope, resolvePersonalAutomationsAgentId } from "./chat-send-scope.js"; import { prepareAndAdmitChatSend } from "./chat-send-setup.js"; import type { GatewayClient, GatewayRequestContext } from "./types.js"; @@ -75,6 +75,46 @@ describe("chat send scope admission", () => { scopeMocks.resolveDurableChatClaim.mockReset().mockResolvedValue({ kind: "continue" }); }); + it("binds personal automations to the relay-verified key and separates retry authority", () => { + const sessionKey = "agent:alice:main"; + const senderAttribution = { id: "alice", agentId: "alice", isOwner: false as const }; + const automationScope = { + personalAutomations: true as const, + senderAttribution, + requestedKey: ` ${sessionKey} `, + sessionKey, + agentId: "alice", + }; + const personalAutomationsAgentId = resolvePersonalAutomationsAgentId(automationScope); + expect(personalAutomationsAgentId).toBe("alice"); + expect( + resolvePersonalAutomationsAgentId({ ...automationScope, requestedKey: "main" }), + ).toBeUndefined(); + expect( + resolvePersonalAutomationsAgentId({ ...automationScope, chatType: "group" }), + ).toBeUndefined(); + const channelKey = "agent:alice:discord:channel:123"; + expect( + resolvePersonalAutomationsAgentId({ + ...automationScope, + requestedKey: channelKey, + sessionKey: channelKey, + }), + ).toBeUndefined(); + const sendScope = { + context: createDirectChatContext(), + client: null, + respond: vi.fn(), + runId: "same-human-automation-scope", + sessionKey, + agentId: "alice", + senderAttribution, + }; + expect(requireChatSendScope({ ...sendScope, personalAutomationsAgentId })).toBeDefined(); + expect(requireChatSendScope(sendScope)).toBeUndefined(); + expectCollision(sendScope.respond); + }); + it.each(["operator.admin", "operator.write"])( "does not replay a legacy %s sender's result to the same restricted human", (scope) => { diff --git a/src/gateway/server-methods/chat-send-scope.ts b/src/gateway/server-methods/chat-send-scope.ts index 055a43ce893..1ab347f4fbf 100644 --- a/src/gateway/server-methods/chat-send-scope.ts +++ b/src/gateway/server-methods/chat-send-scope.ts @@ -1,6 +1,8 @@ import { isRecord } from "@openclaw/normalization-core/record-coerce"; import { ErrorCodes, errorShape } from "../../../packages/gateway-protocol/src/index.js"; import type { ChatSenderAttribution } from "../../../packages/gateway-protocol/src/schema/logs-chat.js"; +import type { SessionEntry } from "../../config/sessions.js"; +import { parseAgentSessionKey, parseSessionDeliveryRoute } from "../../routing/session-key.js"; import { chatSendScopeDedupeKey, pendingChatSendDedupeKey } from "../server-shared.js"; import { gatewayClientSenderFields, @@ -8,6 +10,31 @@ import { } from "./gateway-client-identity.js"; import type { GatewayRequestHandlerOptions } from "./types.js"; +export function resolvePersonalAutomationsAgentId(params: { + personalAutomations?: true; + senderAttribution?: ChatSenderAttribution; + requestedKey: string; + sessionKey: string; + agentId: string; + chatType?: SessionEntry["chatType"]; +}): string | undefined { + // The relay checked the requested key against its Space registry. A canonical + // route change must not carry that proof over to another conversation. + if ( + !params.personalAutomations || + params.senderAttribution?.isOwner !== false || + params.senderAttribution.agentId !== params.agentId || + params.requestedKey.trim() !== params.sessionKey || + parseAgentSessionKey(params.sessionKey)?.agentId !== params.agentId || + params.chatType === "group" || + params.chatType === "channel" + ) { + return undefined; + } + const peerKind = parseSessionDeliveryRoute(params.sessionKey)?.peerKind; + return peerKind === "group" || peerKind === "channel" ? undefined : params.agentId; +} + /** Bind globally indexed run IDs before any replay, await, or steer interruption. */ export function requireChatSendScope(params: { context: GatewayRequestHandlerOptions["context"]; @@ -17,6 +44,7 @@ export function requireChatSendScope(params: { agentId: string; sessionKey: string; senderAttribution?: ChatSenderAttribution; + personalAutomationsAgentId?: string; }): { requestIdentity: string } | undefined { const { context, runId } = params; const sender = gatewayClientSenderFields(params.client, params.senderAttribution).sender; @@ -33,6 +61,7 @@ export function requireChatSendScope(params: { owner, gatewayClientSenderIsOwner(params.client, params.senderAttribution), sender?.agentId ?? null, + ...(params.personalAutomationsAgentId ? [params.personalAutomationsAgentId] : []), ]); const scopeKey = chatSendScopeDedupeKey(runId); const prior = context.dedupe.get(scopeKey); diff --git a/src/gateway/server-methods/chat-send-session.ts b/src/gateway/server-methods/chat-send-session.ts index 19a07382b87..47e4cebf430 100644 --- a/src/gateway/server-methods/chat-send-session.ts +++ b/src/gateway/server-methods/chat-send-session.ts @@ -23,6 +23,7 @@ import { } from "./chat-origin-routing.js"; import { createRestartSafeChatRequest } from "./chat-restart-recovery.js"; import type { NormalizedChatSendRequest } from "./chat-send-request.js"; +import { resolvePersonalAutomationsAgentId } from "./chat-send-scope.js"; import { roundedChatSendTimingMs } from "./chat-server-timing.js"; import { normalizeOptionalChatText } from "./chat-text-normalization.js"; import type { GatewayRequestHandlerOptions } from "./types.js"; @@ -172,6 +173,14 @@ export function prepareChatSendSession(params: { requestedSessionId, backingSessionId, agentId, + personalAutomationsAgentId: resolvePersonalAutomationsAgentId({ + personalAutomations: p.personalAutomations, + senderAttribution: request.senderAttribution, + requestedKey: rawSessionKey, + sessionKey, + agentId, + chatType: entry?.chatType, + }), activeRunScopeKey, resolvedSessionModel, resolvedSessionAuthProvider, diff --git a/src/gateway/server-methods/chat-send-user-turn.ts b/src/gateway/server-methods/chat-send-user-turn.ts index 494a8ac777f..44f8de1d72b 100644 --- a/src/gateway/server-methods/chat-send-user-turn.ts +++ b/src/gateway/server-methods/chat-send-user-turn.ts @@ -279,7 +279,8 @@ export function prepareChatSendUserTurn(params: { | "systemProvenanceReceipt" | "toolBindings" >; - session: Pick; + session: Pick & + Partial>; admission: Pick; attachments: PreparedChatSendAttachments; client: GatewayRequestHandlerOptions["client"]; @@ -344,7 +345,9 @@ export function prepareChatSendUserTurn(params: { suppressCommandInterpretation: request.suppressCommandInterpretation, systemInputProvenance: request.systemInputProvenance, systemProvenanceReceipt: request.systemProvenanceReceipt, - toolBindings: request.toolBindings, + toolBindings: session.personalAutomationsAgentId + ? { ...request.toolBindings, personalAutomations: session.personalAutomationsAgentId } + : request.toolBindings, }); const mediaPathOffloadsIncludeImages = attachments.mediaPathOffloadTypes.some((type) => type.startsWith("image/"), diff --git a/src/gateway/server-methods/gateway-client-identity.ts b/src/gateway/server-methods/gateway-client-identity.ts index d3da3b8fb7c..f2dec5cd9ad 100644 --- a/src/gateway/server-methods/gateway-client-identity.ts +++ b/src/gateway/server-methods/gateway-client-identity.ts @@ -8,7 +8,14 @@ type GatewayClientSender = ChatSenderAttribution; /** Normalize wire attribution before any send scope or session lifecycle is acquired. */ export function normalizeRequestedGatewaySenderAttribution( sender: GatewayClientSender | undefined, + personalAutomations?: true, ): { ok: true; value: GatewayClientSender | undefined } | { ok: false; error: string } { + if (personalAutomations && (sender?.isOwner !== false || !sender.agentId?.trim())) { + return { + ok: false, + error: "personal automations require restricted sender attribution with an agent ID", + }; + } if (!sender) { return { ok: true, value: undefined }; } diff --git a/src/gateway/server-methods/sessions-messaging.ts b/src/gateway/server-methods/sessions-messaging.ts index 9f142753e34..3f1dd62077b 100644 --- a/src/gateway/server-methods/sessions-messaging.ts +++ b/src/gateway/server-methods/sessions-messaging.ts @@ -30,7 +30,7 @@ import { formatForLog } from "../ws-log.js"; import { handleChatAbortRequestWithLifecycle } from "./chat-abort-handler.js"; import { hasGatewayAdminScope, resolveChatSendSessionLoadKey } from "./chat-origin-routing.js"; import { handleChatSend } from "./chat-send-handler.js"; -import { requireChatSendScope } from "./chat-send-scope.js"; +import { requireChatSendScope, resolvePersonalAutomationsAgentId } from "./chat-send-scope.js"; import { chatHandlers } from "./chat.js"; import { normalizeRequestedGatewaySenderAttribution } from "./gateway-client-identity.js"; import { resolveGatewayInflightRequest, type GatewayInflightResult } from "./inflight.js"; @@ -328,7 +328,9 @@ async function handleSessionSend(params: { const p = params.params; // Relayed provenance must be authorized before creating or interrupting a session. if ( - (p.suppressCommandInterpretation === true || p.senderAttribution !== undefined) && + (p.suppressCommandInterpretation === true || + p.senderAttribution !== undefined || + p.personalAutomations === true) && !hasGatewayAdminScope(params.client) ) { params.respond( @@ -341,7 +343,10 @@ async function handleSessionSend(params: { ); return; } - const requestedSenderResult = normalizeRequestedGatewaySenderAttribution(p.senderAttribution); + const requestedSenderResult = normalizeRequestedGatewaySenderAttribution( + p.senderAttribution, + p.personalAutomations, + ); if (!requestedSenderResult.ok) { params.respond( false, @@ -395,15 +400,25 @@ async function handleSessionSend(params: { ? rawIdempotencyKey.trim() : undefined; const idempotencyKey = explicitIdempotencyKey ?? randomUUID(); + const agentId = + parseAgentSessionKey(canonicalKey)?.agentId ?? requestedAgentId ?? resolveDefaultAgentId(cfg); + const personalAutomationsAgentId = resolvePersonalAutomationsAgentId({ + personalAutomations: p.personalAutomations, + senderAttribution, + requestedKey, + sessionKey: canonicalKey, + agentId, + chatType: entry?.chatType, + }); const sendScope = requireChatSendScope({ context: params.context, client: params.client, respond: params.respond, runId: idempotencyKey, - agentId: - parseAgentSessionKey(canonicalKey)?.agentId ?? requestedAgentId ?? resolveDefaultAgentId(cfg), + agentId, sessionKey: canonicalKey, senderAttribution, + personalAutomationsAgentId, }); if (!sendScope) { return; @@ -441,6 +456,7 @@ async function handleSessionSend(params: { ? { suppressCommandInterpretation: p.suppressCommandInterpretation } : {}), ...(senderAttribution !== undefined ? { senderAttribution } : {}), + ...(personalAutomationsAgentId ? { personalAutomations: true } : {}), attachments: (p as { attachments?: unknown[] }).attachments, timeoutMs: (p as { timeoutMs?: number }).timeoutMs, idempotencyKey, diff --git a/src/gateway/server.cron.test.ts b/src/gateway/server.cron.test.ts index 90f3155ccec..59ba0526dc0 100644 --- a/src/gateway/server.cron.test.ts +++ b/src/gateway/server.cron.test.ts @@ -13,6 +13,7 @@ import type { GuardedFetchOptions } from "../infra/net/fetch-guard.js"; import { peekSystemEvents } from "../infra/system-events.js"; import { getGatewayProcessInstanceId } from "./process-instance.js"; import type { GatewayCronState } from "./server-cron.js"; +import type { GatewayClient } from "./server-methods/types.js"; import { connectOk, cronIsolatedRun, @@ -251,6 +252,7 @@ async function directCronReq( cronState: DirectCronState, method: string, params: Record, + client: GatewayClient | null = null, ): Promise { const { cronHandlers } = await import("./server-methods/cron.js"); let result: DirectCronResponse | undefined; @@ -283,7 +285,7 @@ async function directCronReq( }, getRuntimeConfig: cronState.getRuntimeConfig, } as never, - client: null, + client, isWebchatConnect: () => false, }); } catch (err) { @@ -498,6 +500,95 @@ describe("gateway server cron", () => { } }); + test("schedules a WebChat transcript completion only for the signed current session", async () => { + const { prevSkipCron } = await setupCronTestRun({ + tempPrefix: "openclaw-gw-cron-current-webchat-", + cronEnabled: false, + }); + const cronEvents = createCronEventCollector(); + const cronState = await createDirectCronState({ + broadcast: (event, payload) => cronEvents.broadcast(event, payload), + }); + const sessionKey = "agent:main:main"; + const client: GatewayClient = { + connect: {} as GatewayClient["connect"], + internal: { agentRuntimeIdentity: { kind: "agentRuntime", agentId: "main", sessionKey } }, + }; + const params = { + name: "private conversation reminder", + schedule: { kind: "every", everyMs: 60_000 }, + sessionTarget: "current", + sessionKey, + payload: { kind: "agentTurn", message: "remember this", toolsAllow: [] }, + delivery: { mode: "announce", channel: "webchat" }, + failureAlert: false, + }; + try { + const forged = await directCronReq(cronState, "cron.add", { + ...params, + owner: { agentId: "main", sessionKey, accountId: "default" }, + }); + expect(forged).toMatchObject({ ok: false, error: { code: "INVALID_REQUEST" } }); + const sibling = await directCronReq( + cronState, + "cron.add", + { ...params, sessionKey: "agent:main:dashboard:sibling" }, + client, + ); + expect(sibling).toMatchObject({ ok: false, error: { code: "INVALID_REQUEST" } }); + const outbound = await directCronReq( + cronState, + "cron.add", + { ...params, delivery: { ...params.delivery, to: "knox:stale-room" } }, + client, + ); + expect(outbound).toMatchObject({ ok: false, error: { code: "INVALID_REQUEST" } }); + + const added = await directCronReq(cronState, "cron.add", params, client); + const jobId = expectCronJobIdFromResponse(added); + const scheduledToolPolicy = { + mode: "account", + ownerSessionKey: sessionKey, + ownerAccountId: "default", + }; + expect(await cronState.cron.readJob(jobId)).toMatchObject({ + owner: { agentId: "main", sessionKey, accountId: "default" }, + sessionKey, + sessionTarget: "current", + delivery: params.delivery, + scheduledToolPolicy, + }); + let configRevision = (added.payload as { configRevision: string }).configRevision; + for (const mode of ["none", "announce"]) { + const delivery = { mode, channel: "webchat" }; + expect(configRevision).toEqual(expect.any(String)); + const updated = await directCronReq(cronState, "cron.update", { + id: jobId, + expectedConfigRevision: configRevision, + patch: { sessionKey, delivery }, + }); + expect(updated).toMatchObject({ ok: true, payload: { sessionKey, delivery } }); + expect(await cronState.cron.readJob(jobId)).toMatchObject({ scheduledToolPolicy }); + configRevision = (updated.payload as { configRevision: string }).configRevision; + } + const finished = cronEvents.wait( + (payload) => payload.jobId === jobId && payload.action === "finished", + ); + cronIsolatedRun.mockResolvedValueOnce({ status: "ok", summary: "private reminder" }); + const run = await directCronReq(cronState, "cron.run", { id: jobId, mode: "force" }, client); + expect(run.ok).toBe(true); + expectEnqueuedRunPayload(run.payload); + expect(await finished).toMatchObject({ status: "ok", summary: "private reminder" }); + expect(cronIsolatedRun).toHaveBeenCalledWith( + expect.objectContaining({ + job: expect.objectContaining({ sessionKey, delivery: params.delivery }), + }), + ); + } finally { + await cleanupCronTestRun({ cronState, prevSkipCron }); + } + }); + test("handles cron CRUD, normalization, and patch semantics", { timeout: 45_000 }, async () => { const { prevSkipCron } = await setupCronTestRun({ tempPrefix: "openclaw-gw-cron-", diff --git a/src/gateway/sessions-messaging.sender-attribution.test.ts b/src/gateway/sessions-messaging.sender-attribution.test.ts index b9694aff238..8df6bc037e8 100644 --- a/src/gateway/sessions-messaging.sender-attribution.test.ts +++ b/src/gateway/sessions-messaging.sender-attribution.test.ts @@ -66,9 +66,16 @@ async function setup(existingSession = true) { method: SendMethod, runId: string, senderAttribution: ChatSenderAttribution, + personalAutomations?: true, ) => { const handler = expectDefined(sessionMessagingHandlers[method], "session messaging handler"); - const params = { key: sessionKey, message: "hello", idempotencyKey: runId, senderAttribution }; + const params = { + key: sessionKey, + message: "hello", + idempotencyKey: runId, + senderAttribution, + ...(personalAutomations ? { personalAutomations } : {}), + }; const respond = vi.fn(); await handler({ req: { type: "req", id: runId, method, params }, @@ -130,6 +137,23 @@ it.each( }, ); +it.each( + (["sessions.send", "sessions.steer"] as const).flatMap((method) => [ + { method, agentId: " main ", expectedBindings: { personalAutomations: "main" } }, + { method, agentId: "foreign", expectedBindings: undefined }, + ]), +)( + "$method scopes personal automations to the canonical run Agent ($agentId)", + async ({ method, agentId, expectedBindings }) => { + const { context, invoke } = await setup(); + const runId = `${method}-personal-automations`; + await invoke(method, runId, { id: "browser.user", agentId, isOwner: false }, true); + const ctx = await expectDispatched(context, runId); + expect(ctx).toMatchObject({ SenderIsOwner: false, GatewayClientScopes: [] }); + expect(ctx.GatewayRunToolBindings).toEqual(expectedBindings); + }, +); + it.each(["sessions.send", "sessions.steer"] as const)( "%s rejects blank sender ID before lifecycle work and permits a corrected same-key retry", async (method) => {