@sider-ai/chrome-openclaw-sider 1.0.31

package/dist/src/setup-core.d.ts

@@ -0,0 +1,72 @@
+import { OpenClawConfig, ChannelSetupInput, ChannelSetupAdapter } from 'openclaw/plugin-sdk/setup';
+
+declare const SIDER_PAIR_REQUEST_API_PATH = "/v1/claws/pair/request";
+declare const SIDER_PAIR_STATUS_API_PATH = "/v1/claws/pair/status";
+declare const SIDER_EXTENSION_INSTALL_URL = "https://chromewebstore.google.com/detail/sider-chat-with-all-ai-gp/difoiogjjojoaoomphldepapgpbgkhkb?utm_source=openclaw";
+type SiderPairStatusResponse = {
+    status: "pending";
+} | {
+    status: "paired";
+    claw_id: string;
+    token: string;
+};
+type SiderPairingSession = {
+    pairingCode: string;
+    pairingToken: string;
+    expiresAt: number;
+    pollIntervalMs: number;
+};
+type SiderPairingResult = {
+    clawId: string;
+    token: string;
+};
+declare class SiderPairingExpiredError extends Error {
+    constructor(message?: string);
+}
+declare class SiderPairingTransientError extends Error {
+    constructor(message: string);
+}
+declare function formatSiderPairingTtl(remainingMs: number): string;
+declare function formatSiderPairingPendingMessage(params: {
+    pairingCode: string;
+    remainingMs: number;
+}): string;
+declare function formatSiderPairingRetryMessage(params: {
+    pairingCode: string;
+    remainingMs: number;
+    retryAfterMs: number;
+    detail: string;
+}): string;
+declare function createSiderPairingPendingUpdateReporter(params: {
+    pairingCode: string;
+    report: (message: string) => void | Promise<void>;
+    intervalMs?: number;
+}): (state: {
+    remainingMs: number;
+    pollIntervalMs: number;
+}) => void | Promise<void>;
+declare function applySiderSetupAccountConfig(params: {
+    cfg: OpenClawConfig;
+    accountId: string;
+    input: Pick<ChannelSetupInput, "name" | "token">;
+}): OpenClawConfig;
+declare const siderSetupAdapter: ChannelSetupAdapter;
+declare function requestSiderPairing(): Promise<SiderPairingSession>;
+declare function readSiderPairingStatus(pairingToken: string): Promise<SiderPairStatusResponse | {
+    status: "expired";
+}>;
+declare function waitForSiderPairing(params: {
+    pairing: SiderPairingSession;
+    onPending?: (state: {
+        remainingMs: number;
+        pollIntervalMs: number;
+    }) => void | Promise<void>;
+    onRetryableError?: (message: string) => void | Promise<void>;
+}): Promise<SiderPairingResult>;
+declare function formatSiderPairingInstructions(params: {
+    pairingCode: string;
+    leadLine?: string;
+}): string;
+declare function getSiderSetupChannelId(): string;
+
+export { SIDER_EXTENSION_INSTALL_URL, SIDER_PAIR_REQUEST_API_PATH, SIDER_PAIR_STATUS_API_PATH, SiderPairingExpiredError, type SiderPairingResult, type SiderPairingSession, SiderPairingTransientError, applySiderSetupAccountConfig, createSiderPairingPendingUpdateReporter, formatSiderPairingInstructions, formatSiderPairingPendingMessage, formatSiderPairingRetryMessage, formatSiderPairingTtl, getSiderSetupChannelId, readSiderPairingStatus, requestSiderPairing, siderSetupAdapter, waitForSiderPairing };

package/dist/src/setup-core.js

@@ -0,0 +1,343 @@
+import {
+  DEFAULT_ACCOUNT_ID,
+  normalizeAccountId
+} from "openclaw/plugin-sdk/setup";
+import {
+  cloneOpenClawConfig,
+  formatAuthorizationHeader,
+  resolveSiderApiUrl,
+  resolveWritableSiderAccountConfig
+} from "./auth.js";
+import { SIDER_CHANNEL_ID } from "./config.js";
+import { SIDER_USER_AGENT } from "./user-agent.js";
+const SIDER_PAIR_REQUEST_API_PATH = "/v1/claws/pair/request";
+const SIDER_PAIR_STATUS_API_PATH = "/v1/claws/pair/status";
+const SIDER_EXTENSION_INSTALL_URL = "https://chromewebstore.google.com/detail/sider-chat-with-all-ai-gp/difoiogjjojoaoomphldepapgpbgkhkb?utm_source=openclaw";
+const DEFAULT_POLL_INTERVAL_MS = 5e3;
+const DEFAULT_PENDING_UPDATE_INTERVAL_MS = 3e4;
+const ANSI_ESCAPE = "\x1B";
+const ANSI_RESET = `${ANSI_ESCAPE}[0m`;
+const ANSI_BOLD = `${ANSI_ESCAPE}[1m`;
+const ANSI_CODE_COLOR = `${ANSI_ESCAPE}[38;5;214m`;
+class SiderPairingExpiredError extends Error {
+  constructor(message = "Sider pairing code expired") {
+    super(message);
+    this.name = "SiderPairingExpiredError";
+  }
+}
+class SiderPairingTransientError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SiderPairingTransientError";
+  }
+}
+function trimMaybe(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readJsonObject(payload, errorMessage) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error(errorMessage);
+  }
+  return payload;
+}
+function parsePairRequestResponse(payload) {
+  const data = readJsonObject(payload, "selfclaw pairing response is not a JSON object");
+  const pairingCode = trimMaybe(data.pairing_code);
+  const pairingToken = trimMaybe(data.pairing_token);
+  const expiresAt = typeof data.expires_at === "number" && Number.isFinite(data.expires_at) ? data.expires_at : 0;
+  const pollInterval = typeof data.poll_interval === "number" && Number.isFinite(data.poll_interval) ? Math.floor(data.poll_interval) : void 0;
+  if (!pairingCode || !pairingToken || expiresAt <= 0) {
+    throw new Error("selfclaw pairing response missing pairing_code/pairing_token/expires_at");
+  }
+  return {
+    pairing_code: pairingCode,
+    pairing_token: pairingToken,
+    expires_at: expiresAt,
+    poll_interval: pollInterval
+  };
+}
+function parsePairStatusResponse(payload) {
+  const data = readJsonObject(payload, "selfclaw pairing status is not a JSON object");
+  const status = trimMaybe(data.status);
+  if (status === "pending") {
+    return { status: "pending" };
+  }
+  if (status === "paired") {
+    const clawId = trimMaybe(data.claw_id);
+    const token = trimMaybe(data.token);
+    if (!clawId || !token) {
+      throw new Error("selfclaw pairing status missing claw_id/token");
+    }
+    return {
+      status: "paired",
+      claw_id: clawId,
+      token
+    };
+  }
+  throw new Error("selfclaw pairing status missing valid status");
+}
+async function parseErrorDetail(response) {
+  try {
+    const text = (await response.text()).trim();
+    return text ? `: ${text}` : "";
+  } catch {
+    return "";
+  }
+}
+async function readJsonResponse(response) {
+  try {
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function describeUnknownError(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return String(error);
+}
+function isRetryableFetchError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  if (error.name === "TypeError" && /fetch failed/i.test(error.message)) {
+    return true;
+  }
+  const cause = "cause" in error ? error.cause : void 0;
+  const causeCode = cause && typeof cause === "object" && "code" in cause && typeof cause.code === "string" ? cause.code : void 0;
+  return Boolean(
+    causeCode && [
+      "ECONNRESET",
+      "ECONNREFUSED",
+      "EHOSTUNREACH",
+      "ENETUNREACH",
+      "ENOTFOUND",
+      "ETIMEDOUT",
+      "UND_ERR_CONNECT_TIMEOUT",
+      "UND_ERR_HEADERS_TIMEOUT",
+      "UND_ERR_BODY_TIMEOUT",
+      "UND_ERR_SOCKET"
+    ].includes(causeCode)
+  );
+}
+function supportsTerminalFormatting() {
+  return Boolean(process.stdout.isTTY);
+}
+function stripAnsiEscapes(value) {
+  return value.replaceAll(ANSI_ESCAPE, "");
+}
+function formatTerminalLink(url, label = url) {
+  const safeUrl = stripAnsiEscapes(url);
+  const safeLabel = stripAnsiEscapes(label);
+  if (!supportsTerminalFormatting()) {
+    return safeUrl;
+  }
+  return `\x1B]8;;${safeUrl}\x07${safeLabel}\x1B]8;;\x07`;
+}
+function formatHighlightedPairingCode(pairingCode) {
+  const safePairingCode = stripAnsiEscapes(pairingCode);
+  if (!supportsTerminalFormatting()) {
+    return safePairingCode;
+  }
+  return `${ANSI_BOLD}${ANSI_CODE_COLOR}${safePairingCode}${ANSI_RESET}`;
+}
+function formatSiderExtensionInstallLink() {
+  return formatTerminalLink(SIDER_EXTENSION_INSTALL_URL);
+}
+function formatSiderPairingTtl(remainingMs) {
+  const totalSeconds = Math.max(0, Math.ceil(remainingMs / 1e3));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+function formatSiderPairingPendingMessage(params) {
+  return `Waiting for connection... Pairing code: ${formatHighlightedPairingCode(params.pairingCode)}. Pairing code expires in ${formatSiderPairingTtl(params.remainingMs)}.`;
+}
+function formatSiderPairingRetryMessage(params) {
+  return `Temporary connection issue while checking pairing status (${params.detail}). Retrying in ${formatSiderPairingTtl(params.retryAfterMs)}. Pairing code: ${formatHighlightedPairingCode(params.pairingCode)}. Pairing code expires in ${formatSiderPairingTtl(params.remainingMs)}.`;
+}
+function createSiderPairingPendingUpdateReporter(params) {
+  const intervalMs = Math.max(1e3, Math.floor(params.intervalMs ?? DEFAULT_PENDING_UPDATE_INTERVAL_MS));
+  let lastReportedAt = Date.now();
+  let hasReported = false;
+  return async ({ remainingMs }) => {
+    const now = Date.now();
+    const shouldReport = hasReported ? now - lastReportedAt >= intervalMs : now - lastReportedAt >= intervalMs || remainingMs <= intervalMs;
+    if (!shouldReport) {
+      return;
+    }
+    hasReported = true;
+    lastReportedAt = now;
+    await params.report(
+      formatSiderPairingPendingMessage({
+        pairingCode: params.pairingCode,
+        remainingMs
+      })
+    );
+  };
+}
+function applySiderSetupAccountConfig(params) {
+  const next = cloneOpenClawConfig(params.cfg);
+  const accountCfg = resolveWritableSiderAccountConfig(next, params.accountId);
+  const token = trimMaybe(params.input.token);
+  const name = trimMaybe(params.input.name);
+  if (name) {
+    accountCfg.name = name;
+  }
+  if (token) {
+    accountCfg.token = token;
+  }
+  delete accountCfg.setupToken;
+  accountCfg.enabled = true;
+  return next;
+}
+const siderSetupAdapter = {
+  resolveAccountId: ({ accountId }) => normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID,
+  validateInput: ({ input }) => {
+    if (input.useEnv) {
+      return "Sider setup does not support --use-env.";
+    }
+    return null;
+  },
+  applyAccountConfig: ({ cfg, accountId, input }) => applySiderSetupAccountConfig({
+    cfg,
+    accountId,
+    input
+  })
+};
+async function requestSiderPairing() {
+  const url = resolveSiderApiUrl(SIDER_PAIR_REQUEST_API_PATH);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "User-Agent": SIDER_USER_AGENT
+    }
+  });
+  if (!response.ok) {
+    throw new Error(
+      `selfclaw pairing request failed (${url} ${response.status} ${response.statusText})${await parseErrorDetail(response)}`
+    );
+  }
+  const parsed = parsePairRequestResponse(await readJsonResponse(response));
+  return {
+    pairingCode: parsed.pairing_code,
+    pairingToken: parsed.pairing_token,
+    expiresAt: parsed.expires_at,
+    pollIntervalMs: parsed.poll_interval && parsed.poll_interval > 0 ? parsed.poll_interval * 1e3 : DEFAULT_POLL_INTERVAL_MS
+  };
+}
+async function readSiderPairingStatus(pairingToken) {
+  const url = resolveSiderApiUrl(SIDER_PAIR_STATUS_API_PATH);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: formatAuthorizationHeader(pairingToken),
+        "User-Agent": SIDER_USER_AGENT
+      }
+    });
+  } catch (error) {
+    if (isRetryableFetchError(error)) {
+      throw new SiderPairingTransientError(describeUnknownError(error));
+    }
+    throw error;
+  }
+  if (response.status === 410) {
+    return { status: "expired" };
+  }
+  if ([502, 503, 504].includes(response.status)) {
+    throw new SiderPairingTransientError(
+      `server returned ${response.status} ${response.statusText}${await parseErrorDetail(response)}`
+    );
+  }
+  if (!response.ok) {
+    throw new Error(
+      `selfclaw pairing status failed (${url} ${response.status} ${response.statusText})${await parseErrorDetail(response)}`
+    );
+  }
+  return parsePairStatusResponse(await readJsonResponse(response));
+}
+async function waitForSiderPairing(params) {
+  const expiresAtMs = params.pairing.expiresAt * 1e3;
+  while (true) {
+    let status;
+    try {
+      status = await readSiderPairingStatus(params.pairing.pairingToken);
+    } catch (error) {
+      const remainingMs2 = Math.max(0, expiresAtMs - Date.now());
+      if (error instanceof SiderPairingTransientError && remainingMs2 > 0) {
+        const retryAfterMs = Math.min(params.pairing.pollIntervalMs, remainingMs2);
+        await params.onRetryableError?.(
+          formatSiderPairingRetryMessage({
+            pairingCode: params.pairing.pairingCode,
+            remainingMs: remainingMs2,
+            retryAfterMs,
+            detail: error.message
+          })
+        );
+        await sleep(retryAfterMs);
+        continue;
+      }
+      throw error;
+    }
+    if (status.status === "paired") {
+      return {
+        clawId: status.claw_id,
+        token: status.token
+      };
+    }
+    const remainingMs = Math.max(0, expiresAtMs - Date.now());
+    if (status.status === "expired" || remainingMs <= 0) {
+      throw new SiderPairingExpiredError();
+    }
+    await params.onPending?.({
+      remainingMs,
+      pollIntervalMs: params.pairing.pollIntervalMs
+    });
+    await sleep(Math.min(params.pairing.pollIntervalMs, remainingMs));
+  }
+}
+function formatSiderPairingInstructions(params) {
+  return [
+    params.leadLine?.trim() || "Plugin installed. One more step to connect:",
+    "",
+    "PAIRING CODE",
+    `  ${formatHighlightedPairingCode(params.pairingCode)}`,
+    "",
+    "CHROME EXTENSION",
+    `  ${formatSiderExtensionInstallLink()}`,
+    "",
+    "1. Install the Sider Chrome extension from the link above",
+    "2. Click the Sider icon in your browser toolbar to open the side panel",
+    "3. In the right sidebar, find and click the Claw icon (the paw-shaped icon, 2nd from top)",
+    `4. Enter the pairing code "${params.pairingCode}" and click Connect`,
+    "",
+    "I'm waiting for the connection..."
+  ].join("\n");
+}
+function getSiderSetupChannelId() {
+  return SIDER_CHANNEL_ID;
+}
+export {
+  SIDER_EXTENSION_INSTALL_URL,
+  SIDER_PAIR_REQUEST_API_PATH,
+  SIDER_PAIR_STATUS_API_PATH,
+  SiderPairingExpiredError,
+  SiderPairingTransientError,
+  applySiderSetupAccountConfig,
+  createSiderPairingPendingUpdateReporter,
+  formatSiderPairingInstructions,
+  formatSiderPairingPendingMessage,
+  formatSiderPairingRetryMessage,
+  formatSiderPairingTtl,
+  getSiderSetupChannelId,
+  readSiderPairingStatus,
+  requestSiderPairing,
+  siderSetupAdapter,
+  waitForSiderPairing
+};

package/dist/src/user-agent.d.ts

@@ -0,0 +1,4 @@
+declare const SIDER_PLUGIN_VERSION: string;
+declare const SIDER_USER_AGENT: string;
+
+export { SIDER_PLUGIN_VERSION, SIDER_USER_AGENT };

package/dist/src/user-agent.js

@@ -0,0 +1,6 @@
+const SIDER_PLUGIN_VERSION = "1.0.31";
+const SIDER_USER_AGENT = `openclaw-sider/${SIDER_PLUGIN_VERSION}`;
+export {
+  SIDER_PLUGIN_VERSION,
+  SIDER_USER_AGENT
+};

package/openclaw.plugin.json

@@ -0,0 +1,96 @@
+{
+  "id": "chrome-openclaw-sider",
+  "channels": ["chrome-openclaw-sider"],
+  "channelConfigs": {
+    "chrome-openclaw-sider": {
+      "label": "Chrome channel for Openclaw by Sider",
+      "description": "Command your OpenClaw from Chrome Sidebar directly.",
+      "schema": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "enabled": { "type": "boolean" },
+          "name": { "type": "string" },
+          "setupToken": { "type": "string" },
+          "token": { "type": "string" },
+          "autoTitle": {
+            "oneOf": [
+              { "type": "boolean" },
+              {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "enabled": { "type": "boolean" },
+                  "prompt": { "type": "string" }
+                }
+              }
+            ]
+          },
+          "defaultTo": { "type": "string" },
+          "connectTimeoutMs": { "type": "number", "minimum": 1 },
+          "sendTimeoutMs": { "type": "number", "minimum": 1 },
+          "reconnectDelayMs": { "type": "number", "minimum": 1 },
+          "accounts": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "enabled": { "type": "boolean" },
+                "name": { "type": "string" },
+                "setupToken": { "type": "string" },
+                "token": { "type": "string" },
+                "autoTitle": {
+                  "oneOf": [
+                    { "type": "boolean" },
+                    {
+                      "type": "object",
+                      "additionalProperties": false,
+                      "properties": {
+                        "enabled": { "type": "boolean" },
+                        "prompt": { "type": "string" }
+                      }
+                    }
+                  ]
+                },
+                "defaultTo": { "type": "string" },
+                "connectTimeoutMs": { "type": "number", "minimum": 1 },
+                "sendTimeoutMs": { "type": "number", "minimum": 1 },
+                "reconnectDelayMs": { "type": "number", "minimum": 1 }
+              }
+            }
+          }
+        }
+      },
+      "uiHints": {
+        "setupToken": {
+          "label": "Setup token",
+          "sensitive": true
+        },
+        "token": {
+          "label": "Token",
+          "sensitive": true
+        },
+        "defaultTo": {
+          "label": "Default target",
+          "placeholder": "session:<sessionId>"
+        },
+        "connectTimeoutMs": {
+          "label": "Connect timeout (ms)"
+        },
+        "sendTimeoutMs": {
+          "label": "Send timeout (ms)"
+        },
+        "reconnectDelayMs": {
+          "label": "Reconnect delay (ms)"
+        }
+      }
+    }
+  },
+  "skills": [],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@sider-ai/chrome-openclaw-sider",
+  "private": false,
+  "version": "1.0.31",
+  "description": "Official Chrome channel plugin for connecting OpenClaw in Sider Chrome extension",
+  "type": "module",
+  "files": [
+    "dist/",
+    "README.md",
+    "openclaw.plugin.json"
+  ],
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "typecheck": "tsc -p tsconfig.build.json --noEmit",
+    "prepublishOnly": "pnpm run typecheck && pnpm run build"
+  },
+  "dependencies": {
+    "ws": "^8.20.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.13",
+    "@types/ws": "^8.18.1",
+    "openclaw": "2026.5.12",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "openclaw": {
+    "extensions": [
+      "./dist/index.js"
+    ],
+    "compat": {
+      "pluginApi": ">=2026.3.22"
+    },
+    "build": {
+      "openclawVersion": "2026.5.12"
+    },
+    "setupEntry": "./dist/setup-entry.js",
+    "channel": {
+      "id": "chrome-openclaw-sider",
+      "label": "Chrome OpenClaw Sider",
+      "selectionLabel": "Chrome OpenClaw Sider"
+    },
+    "install": {
+      "minHostVersion": ">=2026.3.22"
+    }
+  }
+}