r2-relay-channel 0.3.5

package/dist/commands.js

@@ -0,0 +1,54 @@
+import { buildCronTarget, buildWebhookPath, buildWebhookUrl, resolveCommandConversationTarget, } from "./conversation-targets.js";
+export function registerRelayCommands(api) {
+    api.registerCommand({
+        name: "session-target",
+        description: "Show cron and webhook targets for the current R2 Relay conversation.",
+        acceptsArgs: false,
+        requireAuth: true,
+        handler: async (ctx) => await handleRelayCommand(ctx),
+    });
+}
+async function handleRelayCommand(ctx) {
+    const target = resolveCommandConversationTarget(ctx);
+    if (!target) {
+        return {
+            text: [
+                "I couldn't determine the current R2 Relay conversation target yet.",
+                "Send at least one message through the relay in this conversation, then run /session-target again.",
+            ].join("\n"),
+        };
+    }
+    const cronTo = buildCronTarget(target.peer, target.relayConversationId);
+    const sendSnippet = `openclaw message send --channel r2-relay-channel --target '${cronTo}' --message "hello"`;
+    const cronSnippet = `--announce --channel r2-relay-channel --to '${cronTo}'`;
+    const webhook = buildWebhookUrl(ctx.config, target.peer, target.relayConversationId) ?? buildWebhookPath(target.peer, target.relayConversationId);
+    const curlSnippet = [
+        `curl -X POST '${webhook}'`,
+        "  -H 'Authorization: Bearer <cron.webhookToken>'",
+        "  -H 'Content-Type: application/json'",
+        "  --data '{\"text\":\"hello from curl\"}'",
+    ].join(" \\\n");
+    return {
+        text: [
+            "To send a message to this session directly, use:",
+            "```TEXT",
+            sendSnippet,
+            "```",
+            "",
+            "To send cron output to this session, use:",
+            "```TEXT",
+            cronSnippet,
+            "```",
+            "",
+            "To send webhook payloads to this session, use:",
+            "```TEXT",
+            webhook,
+            "```",
+            "",
+            "To test it locally with curl, use:",
+            "```TEXT",
+            curlSnippet,
+            "```",
+        ].join("\n"),
+    };
+}

package/dist/config.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import type { ChannelPlugin, OpenClawConfig } from "openclaw/plugin-sdk/core";
+export declare const DEFAULT_POLL_INTERVAL_MS = 5000;
+export declare const DEFAULT_BACKOFF_MAX_MS = 40000;
+export declare const DEFAULT_TTL_DAYS = 7;
+export declare const DEFAULT_IDENTITY_TTL_DAYS = 1;
+export declare const DEFAULT_HEAD_TTL_DAYS = 30;
+export declare const DEFAULT_REGION = "auto";
+export declare const DEFAULT_FORCE_PATH_STYLE = true;
+export declare const CHANNEL_ID = "r2-relay-channel";
+export declare const PLUGIN_ID = "r2-relay-channel";
+export declare const R2RelaySidecarConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    endpoint: z.ZodString;
+    bucket: z.ZodString;
+    accessKeyId: z.ZodString;
+    secretAccessKey: z.ZodString;
+    serverId: z.ZodOptional<z.ZodString>;
+    pollIntervalMs: z.ZodOptional<z.ZodNumber>;
+    backoffMaxMs: z.ZodOptional<z.ZodNumber>;
+    defaultTtlDays: z.ZodOptional<z.ZodNumber>;
+    ttl: z.ZodOptional<z.ZodObject<{
+        msg: z.ZodOptional<z.ZodNumber>;
+        att: z.ZodOptional<z.ZodNumber>;
+        identity: z.ZodOptional<z.ZodNumber>;
+        head: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const r2RelayChannelConfigSchema: NonNullable<ChannelPlugin["configSchema"]>;
+export interface RelayTtlConfig {
+    msg?: number;
+    att?: number;
+    identity?: number;
+    head?: number;
+}
+export interface R2RelayAccountConfig {
+    enabled?: boolean;
+    configFile?: string;
+    endpoint?: string;
+    bucket?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    serverId?: string;
+    pollIntervalMs?: number;
+    backoffMaxMs?: number;
+    defaultTtlDays?: number;
+    ttl?: RelayTtlConfig;
+}
+export interface ResolvedR2RelayAccount {
+    accountId: string;
+    enabled: boolean;
+    configured: boolean;
+    configFile: string;
+    endpoint: string;
+    bucket: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    serverId: string;
+    region: string;
+    forcePathStyle: boolean;
+    pollIntervalMs: number;
+    backoffMaxMs: number;
+    defaultTtlDays: number;
+    ttl: Required<RelayTtlConfig>;
+    config: R2RelayAccountConfig;
+}
+export declare function getR2RelayConfig(cfg: OpenClawConfig): R2RelayAccountConfig | undefined;
+export declare function listR2RelayAccountIds(cfg: OpenClawConfig): string[];
+export declare function resolveDefaultServerId(_cfg: OpenClawConfig): string;
+export declare function normalizeServerId(value?: string | null): string | null;
+export declare function resolveRelayConfigFilePath(configFile?: string | null): string;
+export declare function loadR2RelaySidecarConfig(configFile: string): R2RelayAccountConfig;
+export declare function resolveR2RelayAccount(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+}): ResolvedR2RelayAccount;

package/dist/config.js

@@ -0,0 +1,123 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { buildJsonChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
+import { getPersistedRelayServerId } from "./runtime.js";
+export const DEFAULT_POLL_INTERVAL_MS = 5_000;
+export const DEFAULT_BACKOFF_MAX_MS = 40_000;
+export const DEFAULT_TTL_DAYS = 7;
+export const DEFAULT_IDENTITY_TTL_DAYS = 1;
+export const DEFAULT_HEAD_TTL_DAYS = 30;
+export const DEFAULT_REGION = "auto";
+export const DEFAULT_FORCE_PATH_STYLE = true;
+export const CHANNEL_ID = "r2-relay-channel";
+export const PLUGIN_ID = "r2-relay-channel";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export const R2RelaySidecarConfigSchema = z.object({
+    enabled: z.boolean().optional(),
+    endpoint: z.string().url().min(1),
+    bucket: z.string().min(1),
+    accessKeyId: z.string().min(1),
+    secretAccessKey: z.string().min(1),
+    serverId: z.string().trim().min(1).optional(),
+    pollIntervalMs: z.number().int().positive().optional(),
+    backoffMaxMs: z.number().int().positive().optional(),
+    defaultTtlDays: z.number().positive().optional(),
+    ttl: z.object({
+        msg: z.number().positive().optional(),
+        att: z.number().positive().optional(),
+        identity: z.number().positive().optional(),
+        head: z.number().positive().optional(),
+    }).optional(),
+});
+export const r2RelayChannelConfigSchema = buildJsonChannelConfigSchema({
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        enabled: { type: "boolean" },
+        configFile: { type: "string", minLength: 1 },
+    },
+});
+export function getR2RelayConfig(cfg) {
+    return cfg.channels?.[CHANNEL_ID];
+}
+export function listR2RelayAccountIds(cfg) {
+    const relayCfg = getR2RelayConfig(cfg);
+    if (!relayCfg) {
+        return [];
+    }
+    return [DEFAULT_ACCOUNT_ID];
+}
+export function resolveDefaultServerId(_cfg) {
+    return getPersistedRelayServerId();
+}
+export function normalizeServerId(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const normalized = trimmed.replace(/\s+/g, "-").replace(/[^a-zA-Z0-9._-]/g, "-");
+    const collapsed = normalized.replace(/-+/g, "-").replace(/^[-_.]+|[-_.]+$/g, "");
+    return collapsed || null;
+}
+export function resolveRelayConfigFilePath(configFile) {
+    const trimmed = configFile?.trim();
+    if (trimmed) {
+        return path.resolve(trimmed);
+    }
+    return path.resolve(__dirname, "..", "r2relay.config.json");
+}
+export function loadR2RelaySidecarConfig(configFile) {
+    try {
+        const raw = fs.readFileSync(configFile, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function resolveR2RelayAccount(params) {
+    const relayCfg = getR2RelayConfig(params.cfg) ?? {};
+    const configFile = resolveRelayConfigFilePath(relayCfg.configFile);
+    const rawFileCfg = loadR2RelaySidecarConfig(configFile);
+    const parsedFileCfg = R2RelaySidecarConfigSchema.safeParse(rawFileCfg);
+    const fileCfg = parsedFileCfg.success ? parsedFileCfg.data : {};
+    const mergedCfg = {
+        ...fileCfg,
+        enabled: relayCfg.enabled ?? fileCfg.enabled,
+        configFile,
+    };
+    const endpoint = mergedCfg.endpoint?.trim() ?? "";
+    const bucket = mergedCfg.bucket?.trim() ?? "";
+    const accessKeyId = mergedCfg.accessKeyId?.trim() ?? "";
+    const secretAccessKey = mergedCfg.secretAccessKey?.trim() ?? "";
+    const configured = Boolean(endpoint && bucket && accessKeyId && secretAccessKey);
+    const ttl = {
+        msg: mergedCfg.ttl?.msg ?? mergedCfg.defaultTtlDays ?? DEFAULT_TTL_DAYS,
+        att: mergedCfg.ttl?.att ?? mergedCfg.defaultTtlDays ?? DEFAULT_TTL_DAYS,
+        identity: mergedCfg.ttl?.identity ?? DEFAULT_IDENTITY_TTL_DAYS,
+        head: mergedCfg.ttl?.head ?? DEFAULT_HEAD_TTL_DAYS,
+    };
+    return {
+        accountId: DEFAULT_ACCOUNT_ID,
+        enabled: mergedCfg.enabled !== false,
+        configured,
+        configFile,
+        endpoint,
+        bucket,
+        accessKeyId,
+        secretAccessKey,
+        serverId: normalizeServerId(mergedCfg.serverId) ?? resolveDefaultServerId(params.cfg),
+        region: DEFAULT_REGION,
+        forcePathStyle: DEFAULT_FORCE_PATH_STYLE,
+        pollIntervalMs: mergedCfg.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
+        backoffMaxMs: mergedCfg.backoffMaxMs ?? DEFAULT_BACKOFF_MAX_MS,
+        defaultTtlDays: mergedCfg.defaultTtlDays ?? DEFAULT_TTL_DAYS,
+        ttl,
+        config: mergedCfg,
+    };
+}

package/dist/conversation-targets.d.ts

@@ -0,0 +1,32 @@
+import type { PluginCommandContext } from "openclaw/plugin-sdk/core";
+export interface ConversationTargetRecord {
+    channel: string;
+    accountId: string;
+    conversationId: string;
+    threadId?: string | number | null;
+    peer: string;
+    relayConversationId: string;
+    updatedAt: number;
+}
+export declare function rememberConversationTarget(params: {
+    channel: string;
+    accountId: string;
+    conversationId: string;
+    threadId?: string | number | null;
+    peer: string;
+    relayConversationId: string;
+}): void;
+export declare function resolveCommandConversationTarget(ctx: PluginCommandContext): ConversationTargetRecord | null;
+export declare function buildCronTarget(peer: string, conversationId: string): string;
+export declare function buildWebhookPath(peer: string, conversationId: string): string;
+export declare function buildWebhookUrl(cfg: {
+    gateway?: {
+        publicBaseUrl?: string | null;
+        externalUrl?: string | null;
+        bindUrl?: string | null;
+        port?: number | null;
+        remote?: {
+            url?: string | null;
+        } | null;
+    };
+}, peer: string, conversationId: string): string | null;

package/dist/conversation-targets.js

@@ -0,0 +1,120 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolvePluginStateDir } from "./runtime.js";
+const STORE_FILE = "conversation-targets.json";
+export function rememberConversationTarget(params) {
+    const store = loadStore();
+    const key = buildStoreKey({
+        channel: params.channel,
+        accountId: params.accountId,
+        conversationId: params.conversationId,
+        threadId: params.threadId,
+    });
+    store[key] = {
+        channel: params.channel,
+        accountId: params.accountId,
+        conversationId: params.conversationId,
+        threadId: params.threadId ?? null,
+        peer: params.peer,
+        relayConversationId: params.relayConversationId,
+        updatedAt: Date.now(),
+    };
+    saveStore(store);
+}
+export function resolveCommandConversationTarget(ctx) {
+    const store = loadStore();
+    const conversationId = resolveCanonicalCommandConversationId(ctx);
+    if (!conversationId) {
+        return null;
+    }
+    const directKey = buildStoreKey({
+        channel: ctx.channel,
+        accountId: ctx.accountId,
+        conversationId,
+        threadId: ctx.messageThreadId,
+    });
+    const fallbackKey = buildStoreKey({
+        channel: ctx.channel,
+        accountId: ctx.accountId,
+        conversationId,
+        threadId: null,
+    });
+    return store[directKey] ?? store[fallbackKey] ?? null;
+}
+export function buildCronTarget(peer, conversationId) {
+    return `peer=${peer},conversation=${conversationId}`;
+}
+export function buildWebhookPath(peer, conversationId) {
+    return `/r2-relay-channel/webhook/${encodeURIComponent(peer)}/${encodeURIComponent(conversationId)}`;
+}
+export function buildWebhookUrl(cfg, peer, conversationId) {
+    const pathPart = buildWebhookPath(peer, conversationId);
+    const localBase = resolveLocalGatewayBaseUrl(cfg);
+    const base = localBase ||
+        cfg.gateway?.publicBaseUrl?.trim() ||
+        cfg.gateway?.externalUrl?.trim() ||
+        cfg.gateway?.remote?.url?.trim() ||
+        cfg.gateway?.bindUrl?.trim() ||
+        "";
+    if (!base) {
+        return null;
+    }
+    try {
+        const normalizedBase = normalizeWebhookBaseUrl(base);
+        return new URL(pathPart, ensureTrailingSlash(normalizedBase)).toString();
+    }
+    catch {
+        return null;
+    }
+}
+function ensureTrailingSlash(value) {
+    return value.endsWith("/") ? value : `${value}/`;
+}
+function resolveLocalGatewayBaseUrl(cfg) {
+    const port = cfg.gateway?.port;
+    if (typeof port === "number" && Number.isFinite(port) && port > 0) {
+        return `http://127.0.0.1:${port}`;
+    }
+    return null;
+}
+function normalizeWebhookBaseUrl(value) {
+    const url = new URL(value);
+    if (url.protocol === "ws:") {
+        url.protocol = "http:";
+    }
+    else if (url.protocol === "wss:") {
+        url.protocol = "https:";
+    }
+    return url.toString();
+}
+function resolveCanonicalCommandConversationId(ctx) {
+    const from = ctx.from?.trim();
+    return from || null;
+}
+function buildStoreKey(params) {
+    return [
+        params.channel,
+        params.accountId?.trim() || "default",
+        params.conversationId,
+        params.threadId == null ? "-" : String(params.threadId),
+    ].join("::");
+}
+function loadStore() {
+    const file = resolveStoreFile();
+    try {
+        const raw = fs.readFileSync(file, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function saveStore(store) {
+    const file = resolveStoreFile();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(store, null, 2)}\n`, "utf8");
+}
+function resolveStoreFile() {
+    return path.join(resolvePluginStateDir(), STORE_FILE);
+}

package/dist/inbound.d.ts

@@ -0,0 +1,38 @@
+import type { ResolvedR2RelayAccount } from "./config.js";
+import type { AttachmentRef, RelayRoute, ServerLimits } from "./protocol.js";
+import type { Service } from "./service.js";
+import { type RelayPollLog } from "./lifecycle.js";
+export declare function dispatchInboundMessage(params: {
+    cfg: Record<string, unknown>;
+    account: ResolvedR2RelayAccount;
+    service: Service;
+    log?: RelayPollLog;
+    senderId: string;
+    text: string;
+    timestamp: number;
+    messageId: string;
+    route: RelayRoute;
+    attachments?: AttachmentRef[];
+}): Promise<void>;
+export declare function formatInboundRelayBody(msg: {
+    content?: {
+        type?: string | null;
+        text?: string | null;
+        attachments?: {
+            file_name?: string | null;
+            kind?: string | null;
+        }[] | null;
+        emoji?: string | null;
+        target_msg_id?: string | null;
+        remove?: boolean | null;
+        approval_id?: string | null;
+        decision?: string | null;
+    } | null;
+}): string;
+export declare function classifyInboundRelayMessageFailure(err: unknown): "error";
+export declare function resolvePublishedServerLimits(limits: {
+    maxImageBytes: number;
+    maxVideoBytes: number;
+    maxAudioBytes: number;
+    maxDocumentBytes: number;
+}): ServerLimits;