@sider-ai/chrome-openclaw-sider 1.0.31

package/dist/src/channel.setup.d.ts

@@ -0,0 +1,10 @@
+import { ChannelPlugin } from 'openclaw/plugin-sdk';
+import { R as ResolvedSiderAccount } from '../account-cW9SLuNu.js';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk/plugin-entry';
+import 'openclaw/plugin-sdk/config-runtime';
+
+declare const siderSetupPlugin: ChannelPlugin<ResolvedSiderAccount>;
+
+export { siderSetupPlugin };

package/dist/src/channel.setup.js

@@ -0,0 +1,9 @@
+import { siderChannelPluginCommon } from "./channel-shared.js";
+import { SIDER_CHANNEL_ID } from "./config.js";
+const siderSetupPlugin = {
+  id: SIDER_CHANNEL_ID,
+  ...siderChannelPluginCommon
+};
+export {
+  siderSetupPlugin
+};

package/dist/src/config.d.ts

@@ -0,0 +1,18 @@
+declare const SIDER_PLUGIN_ID = "chrome-openclaw-sider";
+declare const SIDER_CHANNEL_ID = "chrome-openclaw-sider";
+declare const SIDER_SERVICE_ID = "sider-auth-setup";
+declare const SIDER_PLUGIN_NAME = "Chrome channel for Openclaw by Sider";
+declare const SIDER_PLUGIN_DESCRIPTION = "Official Chrome channel plugin for connecting OpenClaw in Sider Chrome extension";
+declare const SIDER_CHANNEL_LABEL = "Chrome channel for Openclaw by Sider";
+declare const SIDER_CHANNEL_SELECTION_LABEL = "Chrome channel for Openclaw by Sider";
+declare const SIDER_CHANNEL_DOCS_PATH = "/channels/sider";
+declare const SIDER_CHANNEL_DOCS_LABEL = "sider";
+declare const SIDER_CHANNEL_BLURB = "Command your OpenClaw from Chrome Sidebar directly.";
+declare const SIDER_CHANNEL_ALIASES: readonly ["sider"];
+declare const SIDER_DEFAULT_BASE_URL = "https://sider.ai/api/claw/self";
+declare const SIDER_PUSH_TOOL_ERROR_WARNINGS = true;
+declare const SIDER_TOOL_ERROR_WARNING_TEXT_RE: RegExp;
+declare function readSiderBaseUrlEnv(): string | undefined;
+declare function readDefaultSiderSetupTokenEnv(): string | undefined;
+
+export { SIDER_CHANNEL_ALIASES, SIDER_CHANNEL_BLURB, SIDER_CHANNEL_DOCS_LABEL, SIDER_CHANNEL_DOCS_PATH, SIDER_CHANNEL_ID, SIDER_CHANNEL_LABEL, SIDER_CHANNEL_SELECTION_LABEL, SIDER_DEFAULT_BASE_URL, SIDER_PLUGIN_DESCRIPTION, SIDER_PLUGIN_ID, SIDER_PLUGIN_NAME, SIDER_PUSH_TOOL_ERROR_WARNINGS, SIDER_SERVICE_ID, SIDER_TOOL_ERROR_WARNING_TEXT_RE, readDefaultSiderSetupTokenEnv, readSiderBaseUrlEnv };

package/dist/src/config.js

@@ -0,0 +1,38 @@
+const SIDER_PLUGIN_ID = "chrome-openclaw-sider";
+const SIDER_CHANNEL_ID = SIDER_PLUGIN_ID;
+const SIDER_SERVICE_ID = "sider-auth-setup";
+const SIDER_PLUGIN_NAME = "Chrome channel for Openclaw by Sider";
+const SIDER_PLUGIN_DESCRIPTION = "Official Chrome channel plugin for connecting OpenClaw in Sider Chrome extension";
+const SIDER_CHANNEL_LABEL = "Chrome channel for Openclaw by Sider";
+const SIDER_CHANNEL_SELECTION_LABEL = "Chrome channel for Openclaw by Sider";
+const SIDER_CHANNEL_DOCS_PATH = "/channels/sider";
+const SIDER_CHANNEL_DOCS_LABEL = "sider";
+const SIDER_CHANNEL_BLURB = "Command your OpenClaw from Chrome Sidebar directly.";
+const SIDER_CHANNEL_ALIASES = ["sider"];
+const SIDER_DEFAULT_BASE_URL = "https://sider.ai/api/claw/self";
+const SIDER_PUSH_TOOL_ERROR_WARNINGS = true;
+const SIDER_TOOL_ERROR_WARNING_TEXT_RE = /^⚠️ [^\n]+ failed(?:: [^\n]+)?$/u;
+function readSiderBaseUrlEnv() {
+  return process.env.SIDER_GATEWAY_URL;
+}
+function readDefaultSiderSetupTokenEnv() {
+  return process.env.SIDER_SETUP_TOKEN;
+}
+export {
+  SIDER_CHANNEL_ALIASES,
+  SIDER_CHANNEL_BLURB,
+  SIDER_CHANNEL_DOCS_LABEL,
+  SIDER_CHANNEL_DOCS_PATH,
+  SIDER_CHANNEL_ID,
+  SIDER_CHANNEL_LABEL,
+  SIDER_CHANNEL_SELECTION_LABEL,
+  SIDER_DEFAULT_BASE_URL,
+  SIDER_PLUGIN_DESCRIPTION,
+  SIDER_PLUGIN_ID,
+  SIDER_PLUGIN_NAME,
+  SIDER_PUSH_TOOL_ERROR_WARNINGS,
+  SIDER_SERVICE_ID,
+  SIDER_TOOL_ERROR_WARNING_TEXT_RE,
+  readDefaultSiderSetupTokenEnv,
+  readSiderBaseUrlEnv
+};

package/dist/src/inbound-media.d.ts

@@ -0,0 +1,37 @@
+import { PluginRuntime, OpenClawConfig } from 'openclaw/plugin-sdk';
+import { buildAgentMediaPayload } from 'openclaw/plugin-sdk/media-runtime';
+
+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;
+    };
+};
+type ResolveInboundMediaResult = {
+    mediaPayload: ReturnType<typeof buildAgentMediaPayload>;
+    unresolvedMedia: SiderInboundMediaItem[];
+};
+declare function resolveSiderDownloadUrl(params: {
+    gatewayUrl: string;
+    objectKey: string;
+    token?: string;
+    timeoutMs?: number;
+}): Promise<string>;
+declare function resolveInboundSiderMedia(params: ResolveInboundMediaParams): Promise<ResolveInboundMediaResult>;
+
+export { type ResolveInboundMediaResult, type SiderInboundMediaItem, resolveInboundSiderMedia, resolveSiderDownloadUrl };

package/dist/src/inbound-media.js

@@ -0,0 +1,148 @@
+import { buildAgentMediaPayload } from "openclaw/plugin-sdk/media-runtime";
+import { formatAuthorizationHeader } from "./auth.js";
+import { DEFAULT_MEDIA_SAVE_MAX_BYTES } from "./channel-types.js";
+import { SIDER_CHANNEL_ID } from "./config.js";
+import { SIDER_USER_AGENT } from "./user-agent.js";
+const DEFAULT_INBOUND_MEDIA_MAX_BYTES = DEFAULT_MEDIA_SAVE_MAX_BYTES;
+const DEFAULT_DOWNLOAD_URL_TIMEOUT_MS = 8e3;
+function resolveInboundMediaMaxBytes(params) {
+  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] ?? {};
+  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, apiPath) {
+  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) {
+  const url = new URL(resolveGatewayApiUrl(params.gatewayUrl, "/v1/files/download-url"));
+  url.searchParams.set("object_key", params.objectKey);
+  const headers = {
+    "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(1e3, 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;
+  try {
+    parsed = text.trim() ? JSON.parse(text) : {};
+  } catch (error) {
+    throw new Error(`invalid JSON from /v1/files/download-url: ${String(error)}`);
+  }
+  const record = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  const downloadUrl = typeof record?.url === "string" ? record.url.trim() : "";
+  if (!downloadUrl) {
+    throw new Error("/v1/files/download-url response missing url");
+  }
+  return downloadUrl;
+}
+async function resolveInboundSiderMedia(params) {
+  const maxBytes = resolveInboundMediaMaxBytes({
+    cfg: params.cfg,
+    maxBytes: params.maxBytes
+  });
+  const downloaded = [];
+  const unresolvedMedia = [];
+  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
+  };
+}
+export {
+  resolveInboundSiderMedia,
+  resolveSiderDownloadUrl
+};

package/dist/src/media-upload.d.ts

@@ -0,0 +1,87 @@
+type SiderUploadAccount = {
+    accountId: string;
+    gatewayUrl: string;
+    sendTimeoutMs: number;
+    token?: string;
+};
+type SiderPart = {
+    id?: string;
+    type: string;
+    spec_version?: number;
+    payload?: unknown;
+    meta?: unknown;
+};
+type SiderReplyLike = {
+    text?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    isError?: boolean;
+};
+type SiderUploadLogger = {
+    debug?: (message: string, data?: Record<string, unknown>) => void;
+    warn?: (message: string, data?: Record<string, unknown>) => void;
+};
+type BuildSiderPartsParams = {
+    account: SiderUploadAccount;
+    sessionId: string;
+    payload: SiderReplyLike;
+    mediaLocalRoots?: readonly string[];
+    deferUploads?: boolean;
+};
+type DeferredSiderUpload = {
+    fileName: string;
+    size: number;
+    source?: string;
+    upload: () => Promise<void>;
+};
+type OptimisticSiderPartResult = {
+    part: SiderPart;
+    deferredUpload?: DeferredSiderUpload;
+};
+type OptimisticSiderPartsResult = {
+    parts: SiderPart[];
+    deferredUploads: DeferredSiderUpload[];
+};
+declare function inferSourceMeta(sourceRef?: string): Record<string, unknown> | undefined;
+declare function startDeferredSiderUploads(params: {
+    account: SiderUploadAccount;
+    sessionId: string;
+    uploads: readonly DeferredSiderUpload[];
+    context: string;
+}): void;
+declare function uploadMediaToSider(params: {
+    account: SiderUploadAccount;
+    sessionId: string;
+    loadUrl: string;
+    source?: string;
+    meta?: Record<string, unknown>;
+    mediaLocalRoots?: readonly string[];
+    logger?: SiderUploadLogger;
+    deferUpload?: boolean;
+}): Promise<OptimisticSiderPartResult>;
+declare function resolveOutboundMediaLoadUrl(params: {
+    source: string;
+    mediaLocalRoots?: readonly string[];
+}): Promise<string | undefined>;
+declare function buildSiderPartFromInlineAttachment(params: {
+    account: SiderUploadAccount;
+    sessionId: string;
+    buffer: Buffer;
+    contentType?: string;
+    fileName?: string;
+    mediaKind?: "image" | "file";
+    source?: string;
+    logger?: SiderUploadLogger;
+}): Promise<SiderPart>;
+declare function buildOptimisticSiderPartFromInlineAttachment(params: {
+    account: SiderUploadAccount;
+    sessionId: string;
+    buffer: Buffer;
+    contentType?: string;
+    fileName: string;
+    mediaKind?: string;
+    source?: string;
+}): Promise<OptimisticSiderPartResult>;
+declare function buildSiderPartsFromReplyPayload(params: BuildSiderPartsParams): Promise<OptimisticSiderPartsResult>;
+
+export { type DeferredSiderUpload, type OptimisticSiderPartsResult, type SiderPart, type SiderUploadAccount, buildOptimisticSiderPartFromInlineAttachment, buildSiderPartFromInlineAttachment, buildSiderPartsFromReplyPayload, inferSourceMeta, resolveOutboundMediaLoadUrl, startDeferredSiderUploads, uploadMediaToSider };