@sider-ai/chrome-openclaw-sider 1.0.31

package/dist/src/channel-runtime.js

@@ -0,0 +1,138 @@
+import { createSubsystemLogger } from "openclaw/plugin-sdk/core";
+import { WebSocket } from "ws";
+import { SIDER_CHANNEL_ID } from "./config.js";
+import { SIDER_USER_AGENT } from "./user-agent.js";
+let runtimeRef = null;
+const siderSessionBindings = /* @__PURE__ */ new Map();
+const siderRunStates = /* @__PURE__ */ new Map();
+const siderRelaySockets = /* @__PURE__ */ new Map();
+const siderRelayMonitors = /* @__PURE__ */ new Map();
+const subsystemLog = createSubsystemLogger(`gateway/channels/${SIDER_CHANNEL_ID}`);
+function createSiderWebSocket(url) {
+  return new WebSocket(url, {
+    headers: {
+      "User-Agent": SIDER_USER_AGENT
+    }
+  });
+}
+function setSiderRuntime(runtime) {
+  runtimeRef = runtime;
+}
+function getSiderRuntime() {
+  if (!runtimeRef) {
+    throw new Error("sider runtime not initialized");
+  }
+  return runtimeRef;
+}
+function isLogRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Error);
+}
+function normalizeStructuredLogValue(value) {
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      stack: value.stack
+    };
+  }
+  return value;
+}
+function formatLogPart(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Error) {
+    return value.stack ?? `${value.name}: ${value.message}`;
+  }
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function formatLogMessage(...args) {
+  if (args.length === 0) {
+    return "";
+  }
+  return args.map((arg) => formatLogPart(arg)).filter((part) => part.length > 0).join(" ");
+}
+function buildStructuredLogData(args) {
+  if (args.length === 0) {
+    return void 0;
+  }
+  if (args.length === 1 && isLogRecord(args[0])) {
+    return args[0];
+  }
+  return {
+    args: args.map((arg) => normalizeStructuredLogValue(arg))
+  };
+}
+function normalizeLogEntry(args) {
+  if (args.length === 0) {
+    return { message: "", consoleMessage: "" };
+  }
+  const [first, ...rest] = args;
+  const message = typeof first === "string" ? first : formatLogPart(first);
+  const data = buildStructuredLogData(rest);
+  const consoleMessage = formatLogMessage(...args);
+  return { message, data, consoleMessage };
+}
+function emitLog(level, ...args) {
+  const { message, data, consoleMessage } = normalizeLogEntry(args);
+  if (data && Object.keys(data).length > 0) {
+    subsystemLog[level](message, { ...data, consoleMessage });
+    return;
+  }
+  subsystemLog[level](message);
+}
+function logDebug(...args) {
+  emitLog("debug", ...args);
+}
+function logInfo(...args) {
+  emitLog("info", ...args);
+}
+function logWarn(...args) {
+  emitLog("warn", ...args);
+}
+function logError(...args) {
+  emitLog("error", ...args);
+}
+function createMonitorLogger(log) {
+  const emit = (level, ...args) => {
+    if (log) {
+      log[level](formatLogMessage(...args));
+      return;
+    }
+    if (level === "info") {
+      logInfo(...args);
+      return;
+    }
+    logWarn(...args);
+  };
+  return {
+    info: (...args) => emit("info", ...args),
+    warn: (...args) => emit("warn", ...args)
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const siderOutboundLogger = { debug: logDebug, warn: logWarn };
+export {
+  createMonitorLogger,
+  createSiderWebSocket,
+  getSiderRuntime,
+  logDebug,
+  logError,
+  logInfo,
+  logWarn,
+  runtimeRef,
+  setSiderRuntime,
+  siderOutboundLogger,
+  siderRelayMonitors,
+  siderRelaySockets,
+  siderRunStates,
+  siderSessionBindings,
+  sleep
+};

package/dist/src/channel-send-result.d.ts

@@ -0,0 +1,19 @@
+import { R as ResolvedSiderAccount } from '../account-cW9SLuNu.js';
+import { SiderPart } from './channel-types.js';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk';
+import 'openclaw/plugin-sdk/plugin-entry';
+import 'openclaw/plugin-sdk/config-runtime';
+import 'ws';
+
+declare function buildSendMediaResult(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    part: SiderPart;
+    source?: string;
+    path?: string;
+    resolveDownloadUrls?: boolean;
+}): Promise<Record<string, unknown>>;
+
+export { buildSendMediaResult };

package/dist/src/channel-send-result.js

@@ -0,0 +1,126 @@
+import { buildSourceFields } from "./channel-builders.js";
+import { logWarn } from "./channel-runtime.js";
+import { resolveSiderDownloadUrl } from "./inbound-media.js";
+async function resolveDownloadUrlBestEffort(params) {
+  try {
+    return await resolveSiderDownloadUrl({
+      gatewayUrl: params.account.gatewayUrl,
+      objectKey: params.objectKey,
+      token: params.account.token,
+      timeoutMs: params.account.sendTimeoutMs
+    });
+  } catch (err) {
+    logWarn("sider failed to resolve download url for outbound file", {
+      accountId: params.account.accountId,
+      sessionId: params.sessionId,
+      objectKey: params.objectKey,
+      error: String(err)
+    });
+    return void 0;
+  }
+}
+function readStringField(record, key) {
+  const value = record[key];
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function buildResultSourceFields(source) {
+  const fields = buildSourceFields(source);
+  const sourcePath = typeof fields.source_path === "string" ? fields.source_path : void 0;
+  const sourceUrl = typeof fields.source_url === "string" ? fields.source_url : void 0;
+  return {
+    ...fields,
+    ...sourcePath ? { sourcePath } : {},
+    ...sourceUrl ? { sourceUrl } : {}
+  };
+}
+function summarizeSiderFilePart(part) {
+  if (part.type !== "core.file" && part.type !== "core.media") {
+    return void 0;
+  }
+  const payload = part.payload && typeof part.payload === "object" && !Array.isArray(part.payload) ? part.payload : void 0;
+  const summary = {};
+  if (payload) {
+    summary.fileId = readStringField(payload, "file_id") ?? readStringField(payload, "fileId");
+    summary.objectKey = readStringField(payload, "object_key") ?? readStringField(payload, "objectKey");
+    summary.filename = readStringField(payload, "name") ?? readStringField(payload, "file_name") ?? readStringField(payload, "fileName");
+    summary.contentType = readStringField(payload, "mime") ?? readStringField(payload, "mime_type") ?? readStringField(payload, "mimeType") ?? readStringField(payload, "content_type") ?? readStringField(payload, "contentType");
+    const sizeValue = payload.size;
+    if (typeof sizeValue === "number" && Number.isFinite(sizeValue)) {
+      summary.size = sizeValue;
+    }
+    summary.sha256 = readStringField(payload, "sha256");
+    summary.uploadStatus = readStringField(payload, "upload_status") ?? readStringField(payload, "uploadStatus");
+    summary.downloadUrl = readStringField(payload, "download_url") ?? readStringField(payload, "downloadUrl");
+  }
+  const meta = part.meta && typeof part.meta === "object" && !Array.isArray(part.meta) ? part.meta : void 0;
+  if (meta) {
+    summary.mediaKind = readStringField(meta, "media_kind") ?? summary.mediaKind;
+  }
+  return summary;
+}
+async function buildSendMediaResult(params) {
+  const summary = summarizeSiderFilePart(params.part);
+  const result = {};
+  if (!summary) {
+    if (params.path) {
+      result.path = params.path;
+    }
+    if (params.source) {
+      Object.assign(result, buildResultSourceFields(params.source));
+    }
+    return result;
+  }
+  if (params.resolveDownloadUrls !== false && !summary.downloadUrl && summary.objectKey) {
+    const downloadUrl = await resolveDownloadUrlBestEffort({
+      account: params.account,
+      sessionId: params.sessionId,
+      objectKey: summary.objectKey
+    });
+    if (downloadUrl) {
+      summary.downloadUrl = downloadUrl;
+    }
+  }
+  if (params.path) {
+    result.path = params.path;
+  }
+  if (params.source) {
+    Object.assign(result, buildResultSourceFields(params.source));
+  }
+  if (summary.contentType) {
+    result.contentType = summary.contentType;
+  }
+  if (summary.filename) {
+    result.filename = summary.filename;
+  }
+  if (summary.fileId) {
+    result.fileId = summary.fileId;
+    result.file_id = summary.fileId;
+  }
+  if (summary.objectKey) {
+    result.objectKey = summary.objectKey;
+    result.object_key = summary.objectKey;
+  }
+  if (summary.downloadUrl) {
+    result.downloadUrl = summary.downloadUrl;
+    result.download_url = summary.downloadUrl;
+  }
+  if (typeof summary.size === "number") {
+    result.size = summary.size;
+  }
+  if (summary.sha256) {
+    result.sha256 = summary.sha256;
+  }
+  if (summary.uploadStatus) {
+  }
+  if (summary.mediaKind) {
+    result.mediaKind = summary.mediaKind;
+  }
+  return result;
+}
+export {
+  buildSendMediaResult
+};

package/dist/src/channel-send.d.ts

@@ -0,0 +1,73 @@
+import { OpenClawConfig } from 'openclaw/plugin-sdk';
+import { R as ResolvedSiderAccount } from '../account-cW9SLuNu.js';
+import { SiderPart } from './channel-types.js';
+import { DeferredSiderUpload } from './media-upload.js';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk/plugin-entry';
+import 'openclaw/plugin-sdk/config-runtime';
+import 'ws';
+
+type PreparedSiderSend = {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    parts: SiderPart[];
+    deferredUploads: DeferredSiderUpload[];
+    attachments: string[];
+};
+type NormalizedSiderAttachment = {
+    source: string;
+    meta: Record<string, unknown>;
+};
+type DispatchedSiderParts = {
+    kind: "merged";
+    runId: string;
+    sessionKey: string;
+} | {
+    kind: "sent";
+    messageId: string;
+    conversationId: string;
+};
+declare function readSiderSendText(params: Record<string, unknown>): string | undefined;
+declare function collectSiderSendAttachments(params: Record<string, unknown>): NormalizedSiderAttachment[];
+declare function prepareSiderSendParts(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+    to: string;
+    text?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    attachments?: NormalizedSiderAttachment[];
+    mediaLocalRoots?: readonly string[];
+    errorHint?: string;
+}): Promise<PreparedSiderSend>;
+declare function dispatchSiderParts(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    parts: SiderPart[];
+    deferredUploads?: readonly DeferredSiderUpload[];
+    allowMergeActiveRun?: boolean;
+    context: string;
+}): Promise<DispatchedSiderParts>;
+declare function handleSiderSendAction(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+    params: Record<string, unknown>;
+    mediaLocalRoots?: readonly string[];
+}): Promise<Record<string, unknown>>;
+declare function sendToSider(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+    to: string;
+    text?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    mediaLocalRoots?: readonly string[];
+    errorHint?: string;
+}): Promise<{
+    account: ResolvedSiderAccount;
+    messageId: string;
+    conversationId: string;
+}>;
+
+export { type DispatchedSiderParts, type PreparedSiderSend, collectSiderSendAttachments, dispatchSiderParts, handleSiderSendAction, prepareSiderSendParts, readSiderSendText, sendToSider };

package/dist/src/channel-send.js

@@ -0,0 +1,291 @@
+import { readStringParam } from "openclaw/plugin-sdk/agent-runtime";
+import {
+  describeSiderAccountConfigurationError,
+  resolveManagedSiderAccount,
+  resolveOutboundSessionId
+} from "./account.js";
+import { resolveOutboundMediaLoadUrl, uploadMediaToSider } from "./media-upload.js";
+import { logDebug } from "./channel-runtime.js";
+import { sendMessageToSider } from "./channel-relay.js";
+import {
+  enqueueCompletedParts,
+  getOrCreateSiderRunState,
+  resolveSiderBindingByTarget,
+  resolveSiderRunState,
+  scheduleQueuedPartFlush
+} from "./channel-state.js";
+import { buildSendMediaResult } from "./channel-send-result.js";
+import { toRecord } from "./channel-util.js";
+import {
+  startDeferredSiderUploads
+} from "./media-upload.js";
+import { buildTextPart } from "./channel-builders.js";
+const SIDER_ATTACHMENT_SOURCE_KEYS = [
+  "path",
+  "filePath",
+  "file_path",
+  "fileUrl",
+  "file_url",
+  "url",
+  "media",
+  "mediaUrl",
+  "media_url",
+  "imageUrl",
+  "image_url"
+];
+const SIDER_ATTACHMENT_SOURCE_ARRAY_KEYS = [
+  "mediaUrls",
+  "media_urls",
+  "imageUrls",
+  "image_urls"
+];
+function readSiderSendText(params) {
+  return readStringParam(params, "message", { allowEmpty: true }) ?? readStringParam(params, "text", { allowEmpty: true }) ?? readStringParam(params, "content", { allowEmpty: true });
+}
+function collectSiderSendAttachments(params) {
+  const attachments = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushSource = (value, metaKey) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    const trimmed = value.trim();
+    if (!trimmed || seen.has(trimmed)) {
+      return;
+    }
+    seen.add(trimmed);
+    attachments.push({
+      source: trimmed,
+      meta: { [metaKey]: trimmed }
+    });
+  };
+  for (const key of SIDER_ATTACHMENT_SOURCE_KEYS) {
+    pushSource(params[key], key);
+  }
+  for (const key of SIDER_ATTACHMENT_SOURCE_ARRAY_KEYS) {
+    const values = params[key];
+    if (!Array.isArray(values)) {
+      continue;
+    }
+    for (const value of values) {
+      pushSource(value, key);
+    }
+  }
+  const structuredAttachments = params.attachments;
+  if (!Array.isArray(structuredAttachments)) {
+    return attachments;
+  }
+  for (const item of structuredAttachments) {
+    const record = toRecord(item);
+    if (!record) {
+      continue;
+    }
+    for (const key of SIDER_ATTACHMENT_SOURCE_KEYS) {
+      if (typeof record[key] === "string") {
+        pushSource(record[key], key);
+        continue;
+      }
+    }
+    for (const key of SIDER_ATTACHMENT_SOURCE_ARRAY_KEYS) {
+      const values = record[key];
+      if (!Array.isArray(values)) {
+        continue;
+      }
+      for (const value of values) {
+        pushSource(value, key);
+      }
+    }
+  }
+  return attachments;
+}
+async function prepareSiderSendParts(params) {
+  const account = await resolveManagedSiderAccount({
+    cfg: params.cfg,
+    accountId: params.accountId ?? void 0
+  });
+  if (!account.configured) {
+    throw new Error(describeSiderAccountConfigurationError(account));
+  }
+  const sessionId = resolveOutboundSessionId({ account, to: params.to });
+  const attachmentItems = params.attachments?.length ? params.attachments : params.mediaUrls?.length ? params.mediaUrls.map((source) => ({ source, meta: { mediaUrls: [source] } })) : params.mediaUrl?.trim() ? [{ source: params.mediaUrl.trim(), meta: { mediaUrl: params.mediaUrl.trim() } }] : [];
+  const parts = [];
+  const deferredUploads = [];
+  if (params.text) {
+    parts.push(buildTextPart(params.text));
+  }
+  for (const attachment of attachmentItems) {
+    const loadUrl = await resolveOutboundMediaLoadUrl({
+      source: attachment.source,
+      mediaLocalRoots: params.mediaLocalRoots
+    });
+    if (!loadUrl) {
+      continue;
+    }
+    const prepared = await uploadMediaToSider({
+      account,
+      sessionId,
+      loadUrl,
+      source: attachment.source,
+      meta: attachment.meta,
+      mediaLocalRoots: params.mediaLocalRoots,
+      deferUpload: true
+    });
+    parts.push(prepared.part);
+    if (prepared.deferredUpload) {
+      deferredUploads.push(prepared.deferredUpload);
+    }
+  }
+  if (parts.length === 0) {
+    throw new Error(params.errorHint ?? "sider send requires text or media");
+  }
+  return {
+    account,
+    sessionId,
+    parts,
+    deferredUploads,
+    attachments: attachmentItems.map((item) => item.source)
+  };
+}
+function resolveActiveSiderRunTarget(params) {
+  const target = resolveSiderBindingByTarget({
+    accountId: params.account.accountId,
+    sessionId: params.sessionId
+  });
+  const runId = target?.binding.currentRunId;
+  if (!target || !runId) {
+    return void 0;
+  }
+  const runState = resolveSiderRunState(runId) ?? getOrCreateSiderRunState(runId);
+  runState.sessionKey = target.sessionKey;
+  runState.sessionId = params.sessionId;
+  runState.accountId = params.account.accountId;
+  return { sessionKey: target.sessionKey, runId };
+}
+async function dispatchSiderParts(params) {
+  if (params.allowMergeActiveRun && params.parts.length > 0) {
+    const activeRun = resolveActiveSiderRunTarget({
+      account: params.account,
+      sessionId: params.sessionId
+    });
+    if (activeRun) {
+      enqueueCompletedParts({
+        runId: activeRun.runId,
+        parts: params.parts,
+        sessionKey: activeRun.sessionKey,
+        sessionId: params.sessionId,
+        accountId: params.account.accountId
+      });
+      void scheduleQueuedPartFlush({
+        runId: activeRun.runId,
+        context: `${params.context}.merge_active_run`
+      });
+      logDebug("sider send merged parts into active run", {
+        accountId: params.account.accountId,
+        sessionId: params.sessionId,
+        runId: activeRun.runId,
+        mergedPartTypes: params.parts.map((part) => part.type),
+        context: params.context
+      });
+      if ((params.deferredUploads?.length ?? 0) > 0) {
+        startDeferredSiderUploads({
+          account: params.account,
+          sessionId: params.sessionId,
+          uploads: params.deferredUploads ?? [],
+          context: `${params.context}.merge_active_run`
+        });
+      }
+      return {
+        kind: "merged",
+        runId: activeRun.runId,
+        sessionKey: activeRun.sessionKey
+      };
+    }
+  }
+  const result = await sendMessageToSider({
+    account: params.account,
+    sessionId: params.sessionId,
+    parts: params.parts
+  });
+  if ((params.deferredUploads?.length ?? 0) > 0) {
+    startDeferredSiderUploads({
+      account: params.account,
+      sessionId: params.sessionId,
+      uploads: params.deferredUploads ?? [],
+      context: params.context
+    });
+  }
+  return {
+    kind: "sent",
+    messageId: result.messageId,
+    conversationId: result.conversationId
+  };
+}
+async function handleSiderSendAction(params) {
+  const to = readStringParam(params.params, "to", { required: true });
+  const text = readSiderSendText(params.params);
+  const attachments = collectSiderSendAttachments(params.params);
+  const prepared = await prepareSiderSendParts({
+    cfg: params.cfg,
+    accountId: params.accountId,
+    to,
+    text,
+    attachments,
+    mediaLocalRoots: params.mediaLocalRoots,
+    errorHint: "sider send requires text or attachments"
+  });
+  const mediaParts = prepared.parts.filter(
+    (part) => part.type === "core.file" || part.type === "core.media"
+  );
+  const fileResults = await Promise.all(
+    mediaParts.map(
+      async (part, index) => await buildSendMediaResult({
+        account: prepared.account,
+        sessionId: prepared.sessionId,
+        part,
+        source: prepared.attachments[index]
+      })
+    )
+  );
+  await dispatchSiderParts({
+    account: prepared.account,
+    sessionId: prepared.sessionId,
+    parts: prepared.parts,
+    deferredUploads: prepared.deferredUploads,
+    allowMergeActiveRun: true,
+    context: "action.send"
+  });
+  if (fileResults.length === 0) {
+    return { ok: true };
+  }
+  return {
+    ...fileResults[0],
+    files: fileResults,
+    fileCount: fileResults.length
+  };
+}
+async function sendToSider(params) {
+  const prepared = await prepareSiderSendParts(params);
+  const result = await dispatchSiderParts({
+    account: prepared.account,
+    sessionId: prepared.sessionId,
+    parts: prepared.parts,
+    deferredUploads: prepared.deferredUploads,
+    context: "outbound.send"
+  });
+  if (result.kind !== "sent") {
+    throw new Error("sider outbound.send unexpectedly merged into active run");
+  }
+  return {
+    account: prepared.account,
+    messageId: result.messageId,
+    conversationId: result.conversationId
+  };
+}
+export {
+  collectSiderSendAttachments,
+  dispatchSiderParts,
+  handleSiderSendAction,
+  prepareSiderSendParts,
+  readSiderSendText,
+  sendToSider
+};

package/dist/src/channel-session-model.d.ts

@@ -0,0 +1,19 @@
+import { PluginRuntime, OpenClawConfig } from 'openclaw/plugin-sdk';
+
+type SiderSessionModelResetResult = {
+    changed: false;
+    reason: string;
+} | {
+    changed: true;
+    reason: "auto-override" | "runtime-model";
+    previousModel: string;
+    defaultModel: string;
+};
+declare function maybeResetSiderSessionToCurrentDefaultModel(params: {
+    runtime: PluginRuntime;
+    cfg: OpenClawConfig;
+    agentId: string;
+    sessionKey?: string;
+}): Promise<SiderSessionModelResetResult>;
+
+export { type SiderSessionModelResetResult, maybeResetSiderSessionToCurrentDefaultModel };