@hywkp/test-openclaw-sider 1.0.2

package/src/config.ts

@@ -0,0 +1,29 @@
+export const SIDER_PLUGIN_ID = "test-openclaw-sider";
+export const SIDER_CHANNEL_ID = SIDER_PLUGIN_ID;
+
+export const SIDER_PLUGIN_NAME = "Chrome channel for Openclaw by Sider";
+export const SIDER_PLUGIN_DESCRIPTION = "Official Chrome channel plugin for connecting OpenClaw in Sider Chrome extension";
+
+export const SIDER_CHANNEL_LABEL = "Chrome channel for Openclaw by Sider";
+export const SIDER_CHANNEL_SELECTION_LABEL = "Chrome channel for Openclaw by Sider";
+export const SIDER_CHANNEL_DOCS_PATH = "/channels/sider";
+export const SIDER_CHANNEL_DOCS_LABEL = "sider";
+export const SIDER_CHANNEL_BLURB = "Command your OpenClaw from Chrome Sidebar directly."
+export const SIDER_CHANNEL_ALIASES = ["sider"] as const;
+
+export const SIDER_DEFAULT_BASE_URL = "https://selfclaw.apps.wisebox.ai";
+export const SIDER_SETUP_TOKEN_ENV = "SIDER_SETUP_TOKEN";
+export const SIDER_BASE_URL_ENV = "SIDER_BASE_URL";
+export const SIDER_REMOTE_BROWSER_ENABLE_ENV = "SIDER_ENABLE_REMOTE_BROWSER_MCP";
+
+export function readSiderBaseUrlEnv(): string | undefined {
+  return process.env.SIDER_BASE_URL;
+}
+
+export function readDefaultSiderSetupTokenEnv(): string | undefined {
+  return process.env.SIDER_SETUP_TOKEN;
+}
+
+export function readSiderRemoteBrowserEnableEnv(): string | undefined {
+  return process.env.SIDER_ENABLE_REMOTE_BROWSER_MCP;
+}

package/src/inbound-media.ts

@@ -0,0 +1,196 @@
+import { type OpenClawConfig, type PluginRuntime } from "openclaw/plugin-sdk";
+import { buildAgentMediaPayload } from "openclaw/plugin-sdk/media-runtime";
+import { formatAuthorizationHeader } from "./auth.js";
+import { SIDER_CHANNEL_ID } from "./config.js";
+import { SIDER_USER_AGENT } from "./user-agent.js";
+
+export type SiderInboundMediaItem = {
+  url?: string;
+  mimeType?: string;
+  fileName?: string;
+  objectKey?: string;
+  fileId?: string;
+};
+
+type ResolveInboundMediaParams = {
+  runtime: PluginRuntime;
+  cfg: OpenClawConfig;
+  accountId: string;
+  mediaItems: SiderInboundMediaItem[];
+  maxBytes?: number;
+  gatewayUrl?: string;
+  token?: string;
+  requestTimeoutMs?: number;
+  logger?: {
+    debug?: (message: string, data?: Record<string, unknown>) => void;
+    warn?: (message: string, data?: Record<string, unknown>) => void;
+  };
+};
+
+export type ResolveInboundMediaResult = {
+  mediaPayload: ReturnType<typeof buildAgentMediaPayload>;
+  unresolvedMedia: SiderInboundMediaItem[];
+};
+
+const DEFAULT_INBOUND_MEDIA_MAX_BYTES = 30 * 1024 * 1024;
+const DEFAULT_DOWNLOAD_URL_TIMEOUT_MS = 8_000;
+
+function resolveInboundMediaMaxBytes(params: {
+  cfg: OpenClawConfig;
+  maxBytes?: number;
+}): number {
+  if (typeof params.maxBytes === "number" && Number.isFinite(params.maxBytes) && params.maxBytes > 0) {
+    return Math.floor(params.maxBytes);
+  }
+  const channelCfg = (params.cfg.channels?.[SIDER_CHANNEL_ID] ?? {}) as Record<string, unknown>;
+  const configuredMb = channelCfg.mediaMaxMb;
+  if (
+    typeof configuredMb === "number" &&
+    Number.isFinite(configuredMb) &&
+    configuredMb > 0
+  ) {
+    return Math.floor(configuredMb * 1024 * 1024);
+  }
+  return DEFAULT_INBOUND_MEDIA_MAX_BYTES;
+}
+
+function resolveGatewayApiUrl(gatewayUrl: string, apiPath: string): string {
+  const url = new URL(gatewayUrl);
+  const basePath = url.pathname.replace(/\/+$/, "");
+  const normalizedPath = apiPath.startsWith("/") ? apiPath : `/${apiPath}`;
+  url.pathname = `${basePath}${normalizedPath}`;
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+
+async function resolveSiderDownloadUrl(params: {
+  gatewayUrl: string;
+  objectKey: string;
+  token?: string;
+  timeoutMs?: number;
+}): Promise<string> {
+  const url = new URL(resolveGatewayApiUrl(params.gatewayUrl, "/v1/files/download-url"));
+  url.searchParams.set("object_key", params.objectKey);
+  const headers: Record<string, string> = {
+    "User-Agent": SIDER_USER_AGENT,
+  };
+  if (params.token?.trim()) {
+    headers.Authorization = formatAuthorizationHeader(params.token);
+  }
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers,
+    signal: AbortSignal.timeout(
+      Math.max(1_000, Math.floor(params.timeoutMs ?? DEFAULT_DOWNLOAD_URL_TIMEOUT_MS)),
+    ),
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    const detail = text.trim();
+    const suffix = detail ? `: ${detail.slice(0, 300)}` : "";
+    throw new Error(`HTTP ${response.status} ${response.statusText}${suffix}`);
+  }
+  let parsed: unknown;
+  try {
+    parsed = text.trim() ? (JSON.parse(text) as unknown) : {};
+  } catch (error) {
+    throw new Error(`invalid JSON from /v1/files/download-url: ${String(error)}`);
+  }
+  const record =
+    parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null;
+  const downloadUrl = typeof record?.url === "string" ? record.url.trim() : "";
+  if (!downloadUrl) {
+    throw new Error("/v1/files/download-url response missing url");
+  }
+  return downloadUrl;
+}
+
+export async function resolveInboundSiderMedia(
+  params: ResolveInboundMediaParams,
+): Promise<ResolveInboundMediaResult> {
+  const maxBytes = resolveInboundMediaMaxBytes({
+    cfg: params.cfg,
+    maxBytes: params.maxBytes,
+  });
+  const downloaded: Array<{ path: string; contentType?: string | null }> = [];
+  const unresolvedMedia: SiderInboundMediaItem[] = [];
+
+  for (const media of params.mediaItems) {
+    let sourceUrl = media.url?.trim();
+    if (!sourceUrl && media.objectKey?.trim() && params.gatewayUrl?.trim()) {
+      try {
+        sourceUrl = await resolveSiderDownloadUrl({
+          gatewayUrl: params.gatewayUrl,
+          objectKey: media.objectKey,
+          token: params.token,
+          timeoutMs: params.requestTimeoutMs,
+        });
+        params.logger?.debug?.("sider inbound media resolved download url from object_key", {
+          accountId: params.accountId,
+          objectKey: media.objectKey,
+          fileId: media.fileId,
+        });
+      } catch (error) {
+        params.logger?.warn?.("sider inbound media failed to resolve download url from object_key", {
+          accountId: params.accountId,
+          objectKey: media.objectKey,
+          fileId: media.fileId,
+          error: String(error),
+        });
+      }
+    }
+    if (!sourceUrl) {
+      unresolvedMedia.push(media);
+      params.logger?.warn?.("sider inbound media missing source url", {
+        accountId: params.accountId,
+        fileId: media.fileId,
+        objectKey: media.objectKey,
+        hasGatewayUrl: Boolean(params.gatewayUrl?.trim()),
+      });
+      continue;
+    }
+    try {
+      const fetched = await params.runtime.channel.media.fetchRemoteMedia({
+        url: sourceUrl,
+        maxBytes,
+      });
+      const saveResult = await params.runtime.channel.media.saveMediaBuffer(
+        fetched.buffer,
+        fetched.contentType ?? media.mimeType,
+        "inbound",
+        maxBytes,
+        media.fileName ?? fetched.fileName,
+      );
+      downloaded.push({
+        path: saveResult.path,
+        contentType: saveResult.contentType,
+      });
+      params.logger?.debug?.("sider inbound media saved", {
+        accountId: params.accountId,
+        sourceUrl,
+        savedPath: saveResult.path,
+        contentType: saveResult.contentType,
+        objectKey: media.objectKey,
+        fileId: media.fileId,
+      });
+    } catch (error) {
+      unresolvedMedia.push(media);
+      params.logger?.warn?.("sider inbound media download failed", {
+        accountId: params.accountId,
+        sourceUrl,
+        mimeType: media.mimeType,
+        objectKey: media.objectKey,
+        fileId: media.fileId,
+        error: String(error),
+      });
+    }
+  }
+
+  return {
+    mediaPayload: buildAgentMediaPayload(downloaded),
+    unresolvedMedia,
+  };
+}