r2-relay-channel 0.3.5

package/dist/inbound.js

@@ -0,0 +1,440 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createChannelReplyPipeline } from "openclaw/plugin-sdk/channel-reply-pipeline";
+import { buildChannelInboundMediaPayload, toInboundMediaFacts, } from "openclaw/plugin-sdk/channel-inbound";
+import { getRelayRuntime } from "./runtime.js";
+import { rememberConversationTarget } from "./conversation-targets.js";
+import { emitRelayDebug, touchRuntime } from "./lifecycle.js";
+import { sendRelayPayloadMessage } from "./outbound.js";
+import { formatAttachmentContext, normalizeAttachmentContentType, resolveInboundAttachmentBestEffortMaxBytes, resolveInboundAttachmentMaxBytes, resolveRelayPayloadMediaUrls, } from "./media.js";
+import { agentIdFromSessionKey, readPublishedConversationEntry, schedulePublishedIdentityRefresh, } from "./session-publication.js";
+export async function dispatchInboundMessage(params) {
+    const core = getRelayRuntime();
+    const resolvedRoute = core.channel.routing.resolveAgentRoute({
+        cfg: params.cfg,
+        channel: "r2-relay-channel",
+        accountId: params.account.accountId,
+        peer: {
+            kind: "direct",
+            id: params.senderId,
+        },
+    });
+    const conversationId = (params.route.conversation_id ?? "").trim();
+    const route = conversationId
+        ? {
+            ...resolvedRoute,
+            agentId: params.route.agent_id?.trim() || agentIdFromSessionKey(conversationId),
+            sessionKey: conversationId,
+        }
+        : resolvedRoute;
+    const storePath = core.channel.session.resolveStorePath(params.cfg.session?.store, {
+        agentId: route.agentId,
+    });
+    const attachmentContext = formatAttachmentContext(params.attachments);
+    const agentText = attachmentContext
+        ? `${params.text}\n\n${attachmentContext}`
+        : params.text;
+    const inboundMedia = [];
+    if (params.attachments) {
+        const logger = getRelayRuntime().logging.getChildLogger();
+        for (const att of params.attachments) {
+            if (!att.key) {
+                continue;
+            }
+            const maxBytes = resolveInboundAttachmentMaxBytes(att);
+            const bestEffortMaxBytes = resolveInboundAttachmentBestEffortMaxBytes(att, maxBytes);
+            try {
+                logger.info(`[${params.account.accountId}] staging inbound relay attachment key=${att.key} name=${att.file_name ?? ""} type=${att.content_type ?? ""} kind=${att.kind ?? "unknown"} declaredSize=${att.size ?? -1} maxBytes=${maxBytes} bestEffortMaxBytes=${bestEffortMaxBytes}`);
+                logger.info(`[${params.account.accountId}] inbound relay attachment fetching object key=${att.key}`);
+                const fetchedObject = await params.service.getAttachmentObject(att.key);
+                if (!fetchedObject?.Body) {
+                    throw new Error(`AttachmentNotFound: key=${att.key}`);
+                }
+                const chunks = [];
+                let total = 0;
+                let nextProgressBytes = 1024 * 1024;
+                for await (const chunk of fetchedObject.Body) {
+                    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                    chunks.push(buf);
+                    total += buf.length;
+                    if (total >= nextProgressBytes) {
+                        logger.info(`[${params.account.accountId}] inbound relay attachment streaming progress key=${att.key} downloadedBytes=${total} declaredSize=${att.size ?? -1}`);
+                        nextProgressBytes += 1024 * 1024;
+                    }
+                    if (total > bestEffortMaxBytes) {
+                        throw new Error(`AttachmentTooLarge: streamedSize>${bestEffortMaxBytes}`);
+                    }
+                }
+                const buffer = Buffer.concat(chunks);
+                logger.info(`[${params.account.accountId}] inbound relay attachment fetched object key=${att.key} bytes=${buffer.length}`);
+                const contentType = normalizeAttachmentContentType(fetchedObject.ContentType, att.content_type, att.file_name);
+                const saved = await core.channel.media.saveMediaBuffer(buffer, contentType, "inbound", bestEffortMaxBytes, att.file_name ?? undefined);
+                const workspaceMediaPath = stageInboundMediaForAgentWorkspace({
+                    workspaceDir: resolveAgentWorkspaceDirFromConfig(params.cfg, route.agentId),
+                    sourcePath: saved.path,
+                    originalFileName: att.file_name,
+                    buffer,
+                });
+                inboundMedia.push({
+                    path: workspaceMediaPath,
+                    contentType: saved.contentType ?? contentType ?? att.content_type ?? "application/octet-stream",
+                    kind: att.kind === "file" ? "document" : att.kind,
+                    messageId: params.messageId,
+                });
+                logger.info(`[${params.account.accountId}] staged inbound relay attachment key=${att.key} savedPath=${saved.path} workspacePath=${workspaceMediaPath} savedType=${saved.contentType ?? contentType ?? att.content_type ?? "application/octet-stream"} bytes=${buffer.length}`);
+            }
+            catch (err) {
+                getRelayRuntime().logging.getChildLogger().error(`[${params.account.accountId}] failed to stage inbound relay attachment ${att.key}: ${String(err)}`);
+            }
+        }
+    }
+    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(params.cfg);
+    const previousTimestamp = core.channel.session.readSessionUpdatedAt({
+        storePath,
+        sessionKey: route.sessionKey,
+    });
+    const body = core.channel.reply.formatAgentEnvelope({
+        channel: "R2 Relay",
+        from: params.senderId,
+        timestamp: params.timestamp,
+        previousTimestamp,
+        envelope: envelopeOptions,
+        body: agentText,
+    });
+    const mediaPayload = buildChannelInboundMediaPayload(toInboundMediaFacts(inboundMedia, { messageId: params.messageId }));
+    const ctxPayload = core.channel.reply.finalizeInboundContext({
+        Body: body,
+        BodyForAgent: agentText,
+        RawBody: params.text,
+        CommandBody: params.text,
+        CommandAuthorized: true,
+        From: `r2-relay-channel:${params.senderId}`,
+        To: `r2-relay-channel:${params.account.serverId}`,
+        SessionKey: route.sessionKey,
+        AccountId: route.accountId,
+        ChatType: "direct",
+        ConversationLabel: params.senderId,
+        SenderId: params.senderId,
+        Provider: "r2-relay-channel",
+        Surface: "r2-relay-channel",
+        MessageSid: params.messageId,
+        Timestamp: params.timestamp,
+        OriginatingChannel: "r2-relay-channel",
+        OriginatingTo: `r2-relay-channel:${params.account.serverId}`,
+        ...mediaPayload,
+    });
+    rememberConversationTarget({
+        channel: "r2-relay-channel",
+        accountId: params.account.accountId,
+        conversationId: ctxPayload.From,
+        threadId: null,
+        peer: params.senderId,
+        relayConversationId: route.sessionKey,
+    });
+    const conversationEntry = await readPublishedConversationEntry(route.sessionKey);
+    const outboundMeta = {
+        route: conversationEntry?.route ?? {
+            agent_id: route.agentId,
+            conversation_id: route.sessionKey,
+            instance_id: null,
+        },
+    };
+    const createStreamId = () => `stream-${params.messageId}-${Date.now()}`;
+    const streamState = {
+        streamId: createStreamId(),
+        seq: 0,
+        lastText: "",
+        lastEmitAt: 0,
+        active: false,
+    };
+    const partialIntervalMs = 2000;
+    const partialMinGrowthChars = 120;
+    const resetStream = () => {
+        streamState.streamId = createStreamId();
+        streamState.seq = 0;
+        streamState.lastText = "";
+        streamState.lastEmitAt = 0;
+        streamState.active = false;
+    };
+    const normalizeStreamText = (text) => text.replace(/\r\n/g, "\n");
+    const emitPartialSnapshot = async (text) => {
+        const normalized = normalizeStreamText(text);
+        if (!normalized.trim()) {
+            return;
+        }
+        if (streamState.active && normalized === streamState.lastText) {
+            return;
+        }
+        if (streamState.active && streamState.lastText && !normalized.startsWith(streamState.lastText)) {
+            return;
+        }
+        if (!streamState.active) {
+            streamState.streamId = createStreamId();
+            streamState.seq = 0;
+            streamState.lastText = "";
+            streamState.lastEmitAt = 0;
+            streamState.active = true;
+        }
+        streamState.seq += 1;
+        streamState.lastText = normalized;
+        streamState.lastEmitAt = Date.now();
+        try {
+            await params.service.sendMessage(params.senderId, {
+                route: outboundMeta.route,
+                content: { type: "text", text: normalized },
+                delivery: {
+                    stream: {
+                        stream_id: streamState.streamId,
+                        seq: streamState.seq,
+                        state: "partial",
+                    },
+                },
+            });
+            emitRelayDebug(params.log, `[${params.account.accountId}] sent relay partial reply snapshot`, {
+                senderId: params.senderId,
+                route: outboundMeta.route,
+                streamId: streamState.streamId,
+                streamSeq: streamState.seq,
+                textLength: normalized.length,
+            });
+            touchRuntime(params.account.accountId, {
+                lastOutboundAt: Date.now(),
+                lastError: null,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            params.log?.error?.(`[${params.account.accountId}] failed to send relay partial reply snapshot: ${message}`, {
+                senderId: params.senderId,
+                route: outboundMeta.route,
+                streamId: streamState.streamId,
+                streamSeq: streamState.seq,
+                textLength: normalized.length,
+            });
+            throw err;
+        }
+    };
+    await core.channel.session.recordInboundSession({
+        storePath,
+        sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+        ctx: ctxPayload,
+        onRecordError: () => { },
+    });
+    schedulePublishedIdentityRefresh(params.service, params.account);
+    if (params.messageId && params.senderId) {
+        try {
+            await sendProcessedConfirmation({
+                account: params.account,
+                service: params.service,
+                targetPeer: params.senderId,
+                targetMessageId: params.messageId,
+                route: outboundMeta.route,
+                log: params.log,
+            });
+        }
+        catch (confirmErr) {
+            params.log?.warn?.(`[${params.account.accountId}] failed to send processed confirmation: ${confirmErr instanceof Error ? confirmErr.message : String(confirmErr)}`, {
+                senderId: params.senderId,
+                messageId: params.messageId,
+                route: outboundMeta.route,
+            });
+        }
+    }
+    const { onModelSelected, ...replyPipeline } = createChannelReplyPipeline({
+        cfg: params.cfg,
+        agentId: route.agentId,
+        channel: "r2-relay-channel",
+        accountId: params.account.accountId,
+    });
+    await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx: ctxPayload,
+        cfg: params.cfg,
+        dispatcherOptions: {
+            ...replyPipeline,
+            deliver: async (payload) => {
+                const text = normalizeStreamText(payload.text ?? "");
+                const mediaUrls = resolveRelayPayloadMediaUrls(payload);
+                emitRelayDebug(params.log, `[${params.account.accountId}] relay final payload received`, {
+                    senderId: params.senderId,
+                    route: outboundMeta.route,
+                    hasText: Boolean(text.trim()),
+                    mediaUrl: payload.mediaUrl ?? null,
+                    mediaUrls,
+                    rawMediaUrls: payload.mediaUrls ?? null,
+                    textHasMediaDirective: text.includes("MEDIA:"),
+                });
+                if (streamState.active && text.trim().length > 0) {
+                    if (streamState.lastText && !text.startsWith(streamState.lastText)) {
+                        return;
+                    }
+                    streamState.lastText = text;
+                    streamState.lastEmitAt = Date.now();
+                }
+                try {
+                    await sendRelayPayloadMessage({
+                        cfg: params.cfg,
+                        to: params.senderId,
+                        payload: {
+                            ...payload,
+                            text,
+                            mediaUrls,
+                            mediaUrl: mediaUrls[0],
+                            channelData: payload.channelData,
+                        },
+                        accountId: params.account.accountId,
+                        log: params.log,
+                        source: "replyPipeline.final",
+                        meta: {
+                            route: outboundMeta.route,
+                            workspaceDir: resolveAgentWorkspaceDirFromConfig(params.cfg, route.agentId),
+                        },
+                    });
+                    emitRelayDebug(params.log, `[${params.account.accountId}] sent relay final reply`, {
+                        senderId: params.senderId,
+                        route: outboundMeta.route,
+                        textLength: text.length,
+                        hasChannelData: Boolean(payload.channelData && Object.keys(payload.channelData).length > 0),
+                        mediaCount: mediaUrls.length,
+                    });
+                    resetStream();
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    params.log?.error?.(`[${params.account.accountId}] failed to send relay final reply: ${message}`, {
+                        senderId: params.senderId,
+                        route: outboundMeta.route,
+                        textLength: text.length,
+                        hasChannelData: Boolean(payload.channelData && Object.keys(payload.channelData).length > 0),
+                        mediaCount: mediaUrls.length,
+                    });
+                    throw err;
+                }
+            },
+            onError: (err) => {
+                throw err instanceof Error ? err : new Error(String(err));
+            },
+        },
+        replyOptions: {
+            onModelSelected,
+            onAssistantMessageStart: async () => { },
+            onReasoningEnd: async () => { },
+            onPartialReply: async (payload) => {
+                const text = payload.text ?? "";
+                const normalized = normalizeStreamText(text);
+                if (!normalized.trim()) {
+                    return;
+                }
+                if (streamState.active && normalized === streamState.lastText) {
+                    return;
+                }
+                const now = Date.now();
+                const growth = normalized.length - streamState.lastText.length;
+                const enoughTimePassed = now - streamState.lastEmitAt >= partialIntervalMs;
+                const enoughGrowth = growth >= partialMinGrowthChars;
+                if (!enoughTimePassed && !enoughGrowth) {
+                    return;
+                }
+                await emitPartialSnapshot(normalized);
+            },
+        },
+    });
+}
+export function formatInboundRelayBody(msg) {
+    const content = msg.content ?? {};
+    const contentType = content.type ?? "text";
+    if (contentType === "reaction") {
+        const emoji = content.emoji ?? "";
+        const target = content.target_msg_id ?? "unknown";
+        return content.remove
+            ? `Reaction removed: ${emoji || "(cleared)"} on msg ${target}`
+            : `Reaction added: ${emoji || "(empty)"} on msg ${target}`;
+    }
+    if (contentType === "approval_response") {
+        const approvalId = content.approval_id?.trim();
+        const decision = content.decision?.trim();
+        return approvalId && decision ? `/approve ${approvalId} ${decision}` : "";
+    }
+    const body = (contentType === "text" ? content.text : null)?.trim() ?? "";
+    if (body)
+        return body;
+    const atts = contentType === "text" ? content.attachments : null;
+    if (atts && atts.length > 0) {
+        if (atts.length === 1) {
+            const att = atts[0];
+            const label = att.file_name ?? (att.kind && att.kind !== "unknown" ? att.kind : "attachment");
+            return `[Sent ${label}]`;
+        }
+        return `[Sent ${atts.length} attachments]`;
+    }
+    return body;
+}
+export function classifyInboundRelayMessageFailure(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("AttachmentTooLarge")) {
+        return "error";
+    }
+    if (message.includes("AttachmentNotFound")) {
+        return "error";
+    }
+    return "error";
+}
+export function resolvePublishedServerLimits(limits) {
+    return {
+        inbound_attachment_max_bytes: {
+            image: limits.maxImageBytes,
+            video: limits.maxVideoBytes,
+            audio: limits.maxAudioBytes,
+            file: limits.maxDocumentBytes,
+        },
+        oversize_attachment_behavior: "reject",
+    };
+}
+async function sendProcessedConfirmation(params) {
+    emitRelayDebug(params.log, `[${params.account.accountId}] sending processed confirmation`, {
+        targetPeer: params.targetPeer,
+        targetMessageId: params.targetMessageId,
+        route: params.route,
+    });
+    const result = await params.service.sendMessage(params.targetPeer, {
+        route: params.route,
+        content: {
+            type: "reaction",
+            target_msg_id: params.targetMessageId,
+            emoji: "✅",
+            remove: false,
+        },
+    });
+    emitRelayDebug(params.log, `[${params.account.accountId}] processed confirmation sent`, {
+        targetPeer: params.targetPeer,
+        targetMessageId: params.targetMessageId,
+        confirmationKey: result.key,
+        confirmationMessageId: result.messageId,
+        route: params.route,
+    });
+}
+function resolveAgentWorkspaceDirFromConfig(cfg, agentId) {
+    const agents = (cfg.agents ?? {});
+    const normalizedAgentId = agentId?.trim() || "main";
+    const matched = agents.list?.find((entry) => entry?.id === normalizedAgentId)?.workspace?.trim();
+    if (matched) {
+        return path.resolve(matched);
+    }
+    const fallback = agents.defaults?.workspace?.trim();
+    if (fallback) {
+        return path.resolve(fallback);
+    }
+    return path.join(process.env.HOME ?? process.cwd(), ".openclaw", `workspace${normalizedAgentId === "main" ? "" : `-${normalizedAgentId}`}`);
+}
+function stageInboundMediaForAgentWorkspace(params) {
+    const sourceBase = path.basename(params.sourcePath);
+    const originalBase = params.originalFileName ? sanitizeWorkspaceMediaFileName(params.originalFileName) : "";
+    const fileName = sourceBase || originalBase || `relay-inbound-${Date.now()}`;
+    const mediaDir = path.join(params.workspaceDir, "media", "inbound");
+    const workspacePath = path.join(mediaDir, fileName);
+    fs.mkdirSync(mediaDir, { recursive: true });
+    fs.writeFileSync(workspacePath, params.buffer, { mode: 0o600 });
+    return workspacePath;
+}
+function sanitizeWorkspaceMediaFileName(value) {
+    return path.basename(value).replace(/[^\p{L}\p{N}._-]+/gu, "_").replace(/^_+|_+$/g, "").slice(0, 100);
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
+import { r2RelayPlugin } from "./channel.js";
+declare const r2RelayEntry: ReturnType<typeof defineChannelPluginEntry<typeof r2RelayPlugin>>;
+export default r2RelayEntry;

package/dist/index.js

@@ -0,0 +1,26 @@
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
+import { r2RelayPlugin } from "./channel.js";
+import { setRelayConfig, setRelayRuntime, setRelayStateDir } from "./runtime.js";
+import { registerRelayWebhookRoute } from "./webhook.js";
+import { registerRelayCommands } from "./commands.js";
+const r2RelayEntry = defineChannelPluginEntry({
+    id: "r2-relay-channel",
+    name: "R2 Relay",
+    description: "Cloudflare R2 relay channel plugin for OpenClaw",
+    plugin: r2RelayPlugin,
+    setRuntime(runtime) {
+        setRelayRuntime(runtime);
+    },
+    registerFull(api) {
+        setRelayConfig(api.config);
+        registerRelayWebhookRoute(api);
+        registerRelayCommands(api);
+        api.registerService({
+            id: "r2-relay-channel-state",
+            start(ctx) {
+                setRelayStateDir(ctx.stateDir);
+            },
+        });
+    },
+});
+export default r2RelayEntry;

package/dist/lifecycle.d.ts

@@ -0,0 +1,64 @@
+import { createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
+import { type RelayCheckpointState } from "./checkpoint-store.js";
+import type { ResolvedR2RelayAccount } from "./config.js";
+import type { AttachmentRef, RelayMessage } from "./protocol.js";
+import { Service } from "./service.js";
+export type RelayRuntimeState = Omit<ReturnType<typeof createDefaultChannelRuntimeState>, "running" | "lastStartAt" | "lastStopAt" | "lastError"> & {
+    running: boolean;
+    lastStartAt: number | null;
+    lastStopAt: number | null;
+    lastError: string | null;
+    serverId: string | null;
+    endpoint: string | null;
+    bucket: string | null;
+    lastPollAt: number | null;
+    checkpointHeadKey: string | null;
+    lastInboundAt: number | null;
+    lastOutboundAt: number | null;
+};
+export type RelayPollLog = {
+    info?: (message: string, meta?: Record<string, unknown>) => void;
+    debug?: (message: string, meta?: Record<string, unknown>) => void;
+    warn?: (message: string, meta?: Record<string, unknown>) => void;
+    error?: (message: string, meta?: Record<string, unknown>) => void;
+};
+export interface DispatchInboundMessageParams {
+    cfg: Record<string, unknown>;
+    account: ResolvedR2RelayAccount;
+    service: Service;
+    log?: RelayPollLog;
+    senderId: string;
+    text: string;
+    timestamp: number;
+    messageId: string;
+    route: RelayMessage["route"];
+    attachments?: AttachmentRef[];
+}
+export interface PollRelayInboxParams {
+    cfg: Record<string, unknown>;
+    account: ResolvedR2RelayAccount;
+    service: Service;
+    abortSignal?: AbortSignal;
+    log?: RelayPollLog;
+    setStatus: (patch: unknown) => void;
+    state: RelayCheckpointState;
+    syncPublishedIdentity: (service: Service, account: ResolvedR2RelayAccount, force?: boolean) => Promise<void>;
+    dispatchInboundMessage: (params: DispatchInboundMessageParams) => Promise<void>;
+    formatInboundRelayBody: (msg: RelayMessage) => string;
+    classifyInboundRelayMessageFailure: (err: unknown) => "error";
+}
+export declare function createDefaultRuntimeState(accountId: string): RelayRuntimeState;
+export declare function getRuntimeSnapshot(accountId: string): RelayRuntimeState | undefined;
+export declare function setRuntimeSnapshot(accountId: string, snapshot: RelayRuntimeState): void;
+export declare function touchRuntime(accountId: string, patch: Partial<RelayRuntimeState>): void;
+export declare function getOrCreateService(account: ResolvedR2RelayAccount): Service;
+export declare function clearService(accountId: string): void;
+export declare function redactEndpoint(endpoint: string): string;
+export declare function emitRelayDebug(log: RelayPollLog | undefined, message: string, meta?: Record<string, unknown>): void;
+export declare function pollRelayInbox(params: PollRelayInboxParams): Promise<void>;
+export declare function runSweeperLoop(params: {
+    account: ResolvedR2RelayAccount;
+    service: Service;
+    abortSignal?: AbortSignal;
+    log?: RelayPollLog;
+}): Promise<void>;