@hywkp/test-openclaw-sider 1.0.2

package/README.md

@@ -0,0 +1,65 @@
+# Chrome Channel for OpenClaw in Sider
+
+The official Chrome channel plugin for connecting OpenClaw to the Sider Chrome extension.
+
+Once connected, you can control OpenClaw directly from the Sider Chrome sidebar.
+
+## 【【【 Quick install from the terminal 】】】
+
+Run in Terminal:
+
+================================
+```bash
+npx -y @sider-ai/chrome-openclaw-sider-cli install
+```
+================================
+
+You can also paste this command into the OpenClaw chat box and ask OpenClaw to install it for you. This will install or update the plugin and automatically start terminal pairing.
+
+## 【【【 Manual installation 】】】
+
+If the quick install does not work, follow these steps:
+
+### 【 1. Install or update the plugin 】
+
+Install in Terminal:
+
+================================
+```bash
+openclaw plugins install clawhub:chrome-openclaw-sider
+```
+================================
+
+If the plugin is already installed, update it with:
+
+================================
+```bash
+openclaw plugins update clawhub:chrome-openclaw-sider
+```
+================================
+
+You can run these commands directly in your terminal, or paste them into the OpenClaw chat box and ask OpenClaw to execute them.
+
+### 【 2. Pair the plugin with Sider’s Chrome extension using a pairing code 】
+
+Run in Terminal:
+
+================================
+```bash
+openclaw channels login --channel chrome-openclaw-sider
+```
+================================
+
+Your terminal will display a short pairing code. Enter this code in the Sider browser extension.
+
+In the Sider Chrome extension, open the **Claw** widget from the right column of the extension and enter the pairing code there. This will connect the Sider Chrome extension to your OpenClaw instance.
+
+### 【 3. Restart the gateway 】
+
+After entering the pairing code, restart the gateway in Terminal:
+
+================================
+```bash
+openclaw gateway restart
+```
+================================

package/README.zh_CN.md

@@ -0,0 +1,106 @@
+# chrome-openclaw-sider
+
+OpenClaw 官方 Sider 渠道插件，用于在 Sider 中连接 OpenClaw。
+
+它支持 OpenClaw 标准登录配对流程、一次性 setup token 换取长期 token，以及直接写入 relay token 这三种接入方式。
+
+## 兼容性
+
+- `openclaw >= 2026.3.22`
+
+## 推荐安装方式
+
+大多数用户建议直接使用配套 CLI：
+
+```bash
+npx -y @sider-ai/chrome-openclaw-sider-cli install
+```
+
+它会自动安装或更新插件，并立即进入终端配对流程。
+
+## 手动安装
+
+安装插件：
+
+```bash
+openclaw plugins install chrome-openclaw-sider
+```
+
+如果本地已经安装过，可改为更新：
+
+```bash
+openclaw plugins update chrome-openclaw-sider
+```
+
+发起配对：
+
+```bash
+openclaw channels login --channel chrome-openclaw-sider
+```
+
+终端会显示一条短期 pairing code。用户在 Sider 浏览器扩展中输入这条 code 后，插件会把长期 `token` 自动写回 `channels.chrome-openclaw-sider`。
+
+## 配置方式
+
+插件支持三种常见初始化方式。
+
+### 终端配对
+
+直接使用 OpenClaw 自带登录流程：
+
+```bash
+openclaw channels login --channel chrome-openclaw-sider
+```
+
+### Setup Token
+
+把一次性 token 写入 `channels.chrome-openclaw-sider.setupToken`：
+
+```json
+{
+  "channels": {
+    "chrome-openclaw-sider": {
+      "enabled": true,
+      "setupToken": "<one-time-token>"
+    }
+  }
+}
+```
+
+插件启动后会自动把 `setupToken` 换成长期 `token`，写回配置，并删除 `setupToken`。
+
+### 直接写入 Relay Token
+
+直接写入长期 relay token：
+
+```json
+{
+  "channels": {
+    "chrome-openclaw-sider": {
+      "enabled": true,
+      "token": "<relay-token>"
+    }
+  }
+}
+```
+
+命名账号可写在 `channels.chrome-openclaw-sider.accounts.<id>` 下。
+
+如果是手动改配置，完成后需要重启 gateway：
+
+```bash
+openclaw gateway restart
+```
+
+## 运行时选项
+
+- `SIDER_BASE_URL`：覆盖默认 API base（`https://selfclaw.apps.wisebox.ai`）
+- `SIDER_SETUP_TOKEN`：默认账号的 setup token 环境变量 fallback
+- `SIDER_SETUP_TOKEN_<ACCOUNT_ID>`：命名账号的 setup token 环境变量 fallback
+- `channels.chrome-openclaw-sider.relayId`：可选自定义 relay ID，默认是 `openclaw-<accountId>`
+- `channels.chrome-openclaw-sider.subscribeSessionIds`：可选的入站 session 过滤列表
+
+## 说明
+
+- 同一账号下不要混用 `setupToken` 和 `token`。
+- 对大多数用户来说，终端配对是最简单的初始化方式。

package/index.ts

@@ -0,0 +1,80 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-entry";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk/plugin-entry";
+import { listSiderAccountIds, readSiderAccountConfig } from "./src/account.js";
+import { createSiderAuthSetupService, setSiderAuthRuntime } from "./src/auth.js";
+import {
+  emitSiderToolHookEvent,
+  recordSiderLlmOutputUsage,
+  recordSiderPersistedAgentMessage,
+  siderPlugin,
+  setSiderRuntime,
+} from "./src/channel.js";
+import { SIDER_PLUGIN_DESCRIPTION, SIDER_PLUGIN_ID, SIDER_PLUGIN_NAME } from "./src/config.js";
+import { registerSiderRemoteBrowserSupport } from "./src/remote-browser-support.js";
+
+const plugin = {
+  id: SIDER_PLUGIN_ID,
+  name: SIDER_PLUGIN_NAME,
+  description: SIDER_PLUGIN_DESCRIPTION,
+  configSchema: emptyPluginConfigSchema(),
+  register(api: OpenClawPluginApi) {
+    setSiderRuntime(api.runtime);
+    setSiderAuthRuntime(api.runtime);
+    api.registerChannel({ plugin: siderPlugin });
+    api.registerService(
+      createSiderAuthSetupService({
+        listAccountIds: listSiderAccountIds,
+        getAccountSetupConfig: (cfg, accountId) => {
+          const account = readSiderAccountConfig(cfg, accountId);
+          return {
+            enabled: account.enabled,
+            setupToken: account.setupToken?.trim() || undefined,
+            token: account.token?.trim() || undefined,
+          };
+        },
+      }),
+    );
+    registerSiderRemoteBrowserSupport(api);
+    api.on("before_tool_call", async (event, ctx) => {
+      await emitSiderToolHookEvent({
+        sessionKey: ctx.sessionKey,
+        phase: "start",
+        toolName: event.toolName ?? ctx.toolName,
+        toolCallId: event.toolCallId ?? ctx.toolCallId,
+        runId: event.runId ?? ctx.runId,
+        params: event.params,
+      });
+    });
+    api.on("after_tool_call", async (event, ctx) => {
+      await emitSiderToolHookEvent({
+        sessionKey: ctx.sessionKey,
+        phase: event.error ? "error" : "end",
+        toolName: event.toolName ?? ctx.toolName,
+        toolCallId: event.toolCallId ?? ctx.toolCallId,
+        runId: event.runId ?? ctx.runId,
+        params: event.params,
+        result: event.result,
+        error: event.error,
+        durationMs: event.durationMs,
+      });
+    });
+    api.on("before_message_write", (event, ctx) => {
+      recordSiderPersistedAgentMessage({
+        sessionKey: ctx.sessionKey,
+        message: event.message,
+      });
+    });
+    api.on("llm_output", (event, ctx) => {
+      recordSiderLlmOutputUsage({
+        sessionKey: ctx.sessionKey,
+        runId: event.runId,
+        provider: event.provider,
+        model: event.model,
+        usage: event.usage,
+        lastAssistant: event.lastAssistant,
+      });
+    });
+  },
+};
+
+export default plugin;

package/openclaw.plugin.json

@@ -0,0 +1,10 @@
+{
+  "id": "test-openclaw-sider",
+  "channels": ["test-openclaw-sider"],
+  "skills": [],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@hywkp/test-openclaw-sider",
+  "private": false,
+  "version": "1.0.2",
+  "description": "Official Chrome channel plugin for connecting OpenClaw in Sider Chrome extension",
+  "type": "module",
+  "files": [
+    "src/",
+    "!src/**/*.test.ts",
+    "!src/**/node_modules/",
+    "index.ts",
+    "setup-entry.ts",
+    "README.md",
+    "README.zh_CN.md",
+    "openclaw.plugin.json"
+  ],
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "typecheck": "tsc -p tsconfig.build.json --noEmit"
+  },
+  "dependencies": {
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.3.22"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.13",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "compat": {
+      "pluginApi": ">=2026.3.22"
+    },
+    "build": {
+      "openclawVersion": "2026.3.22"
+    },
+    "setupEntry": "./setup-entry.ts",
+    "channel": {
+      "id": "test-openclaw-sider",
+      "label": "Test OpenClaw Sider",
+      "selectionLabel": "Test OpenClaw Sider"
+    },
+    "install": {
+      "minHostVersion": ">=2026.3.22"
+    }
+  }
+}

package/setup-entry.ts

@@ -0,0 +1,6 @@
+import { defineSetupPluginEntry } from "openclaw/plugin-sdk/core";
+import { siderPlugin } from "./src/channel.js";
+
+export { siderPlugin } from "./src/channel.js";
+
+export default defineSetupPluginEntry(siderPlugin);

package/src/account.ts

@@ -0,0 +1,350 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import {
+  createStandardChannelSetupStatus,
+  setSetupChannelEnabled,
+  type ChannelSetupWizard,
+  type OpenClawConfig,
+} from "openclaw/plugin-sdk/setup";
+import {
+  ensureSiderAccountSetup,
+  isSiderAccountSetupPending,
+  resolveSiderBaseUrl,
+  resolveSiderSetupToken,
+  type SiderSetupConfigSnapshot,
+} from "./auth.js";
+import { SIDER_CHANNEL_ID, SIDER_CHANNEL_LABEL } from "./config.js";
+import {
+  applySiderSetupAccountConfig,
+  createSiderPairingPendingUpdateReporter,
+  formatSiderPairingInstructions,
+  getSiderSetupChannelId,
+  requestSiderPairing,
+  SiderPairingExpiredError,
+  waitForSiderPairing,
+} from "./setup-core.js";
+
+const DEFAULT_CONNECT_TIMEOUT_MS = 8_000;
+const DEFAULT_SEND_TIMEOUT_MS = 12_000;
+const DEFAULT_RECONNECT_DELAY_MS = 2_000;
+
+export type SiderAccountConfig = {
+  enabled?: boolean;
+  name?: string;
+  setupToken?: string;
+  sessionId?: string;
+  subscribeSessionIds?: string[];
+  relayId?: string;
+  token?: string;
+  defaultTo?: string;
+  connectTimeoutMs?: number;
+  sendTimeoutMs?: number;
+  reconnectDelayMs?: number;
+};
+
+type SiderChannelConfig = SiderAccountConfig & {
+  accounts?: Record<string, SiderAccountConfig>;
+};
+
+export type ResolvedSiderAccount = {
+  accountId: string;
+  name: string;
+  enabled: boolean;
+  gatewayUrl: string;
+  sessionId?: string;
+  subscribeSessionIds?: string[];
+  relayId: string;
+  token?: string;
+  defaultTo?: string;
+  connectTimeoutMs: number;
+  sendTimeoutMs: number;
+  reconnectDelayMs: number;
+  configured: boolean;
+  config: SiderAccountConfig;
+};
+
+const siderEphemeralRelayIds = new Map<string, string>();
+const setupChannel = getSiderSetupChannelId();
+
+function resolveEphemeralRelayId(accountId: string): string {
+  const existing = siderEphemeralRelayIds.get(accountId);
+  if (existing) {
+    return existing;
+  }
+  const created = `openclaw-${accountId}-${crypto.randomUUID()}`;
+  siderEphemeralRelayIds.set(accountId, created);
+  return created;
+}
+
+function normalizeTimeout(raw: unknown, fallback: number): number {
+  if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) {
+    return fallback;
+  }
+  return Math.floor(raw);
+}
+
+function normalizeSessionIdList(raw: unknown): string[] | undefined {
+  if (Array.isArray(raw)) {
+    const values = Array.from(
+      new Set(raw.filter((item): item is string => typeof item === "string").map((item) => item.trim()).filter(Boolean)),
+    );
+    return values.length > 0 ? values : undefined;
+  }
+  if (typeof raw === "string" && raw.trim()) {
+    return [raw.trim()];
+  }
+  return undefined;
+}
+
+function getSiderConfig(cfg: OpenClawConfig): SiderChannelConfig {
+  return (cfg.channels?.[SIDER_CHANNEL_ID] ?? {}) as SiderChannelConfig;
+}
+
+export function readSiderAccountConfig(
+  cfg: OpenClawConfig,
+  accountId?: string | null,
+): SiderSetupConfigSnapshot & SiderAccountConfig {
+  const id = normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID;
+  const channelCfg = getSiderConfig(cfg);
+  return id === DEFAULT_ACCOUNT_ID ? channelCfg : (channelCfg.accounts?.[id] ?? {});
+}
+
+export function resolveSiderAccount(
+  cfg: OpenClawConfig,
+  accountId?: string | null,
+): ResolvedSiderAccount {
+  const id = normalizeAccountId(accountId) ?? DEFAULT_ACCOUNT_ID;
+  const accountCfg = readSiderAccountConfig(cfg, id);
+  const gatewayUrl = resolveSiderBaseUrl();
+  const sessionId = accountCfg.sessionId?.trim() || undefined;
+  const subscribeSessionIds = normalizeSessionIdList(accountCfg.subscribeSessionIds);
+  const relayId = accountCfg.relayId?.trim() || resolveEphemeralRelayId(id);
+  const token = accountCfg.token?.trim() || undefined;
+  const defaultTo = accountCfg.defaultTo?.trim() || (sessionId ? `session:${sessionId}` : undefined);
+
+  return {
+    accountId: id,
+    name: accountCfg.name?.trim() || id,
+    enabled: accountCfg.enabled !== false,
+    gatewayUrl,
+    sessionId,
+    subscribeSessionIds,
+    relayId,
+    token,
+    defaultTo,
+    connectTimeoutMs: normalizeTimeout(accountCfg.connectTimeoutMs, DEFAULT_CONNECT_TIMEOUT_MS),
+    sendTimeoutMs: normalizeTimeout(accountCfg.sendTimeoutMs, DEFAULT_SEND_TIMEOUT_MS),
+    reconnectDelayMs: normalizeTimeout(accountCfg.reconnectDelayMs, DEFAULT_RECONNECT_DELAY_MS),
+    configured: Boolean(token && relayId),
+    config: accountCfg,
+  };
+}
+
+export function listSiderAccountIds(cfg: OpenClawConfig): string[] {
+  const channelCfg = getSiderConfig(cfg);
+  const ids = new Set<string>();
+  if (
+    channelCfg.enabled !== undefined ||
+    channelCfg.setupToken ||
+    channelCfg.token ||
+    channelCfg.sessionId ||
+    channelCfg.relayId
+  ) {
+    ids.add(DEFAULT_ACCOUNT_ID);
+  }
+  for (const id of Object.keys(channelCfg.accounts ?? {})) {
+    ids.add(id);
+  }
+  return ids.size > 0 ? Array.from(ids) : [DEFAULT_ACCOUNT_ID];
+}
+
+function isSiderConfiguredForSetup(cfg: OpenClawConfig): boolean {
+  return listSiderAccountIds(cfg).some((accountId) => {
+    const account = resolveSiderAccount(cfg, accountId);
+    if (account.configured) {
+      return true;
+    }
+    return Boolean(resolveSiderSetupToken(accountId, readSiderAccountConfig(cfg, accountId)));
+  });
+}
+
+export const siderSetupWizard: ChannelSetupWizard = {
+  channel: setupChannel,
+  status: createStandardChannelSetupStatus({
+    channelLabel: SIDER_CHANNEL_LABEL,
+    configuredLabel: "configured",
+    unconfiguredLabel: "needs pairing",
+    configuredHint: "configured",
+    unconfiguredHint: "needs pairing",
+    configuredScore: 1,
+    unconfiguredScore: 0,
+    includeStatusLine: true,
+    resolveConfigured: ({ cfg }) => isSiderConfiguredForSetup(cfg),
+  }),
+  credentials: [],
+  finalize: async ({ cfg, accountId, prompter }) => {
+    for (;;) {
+      const pairing = await requestSiderPairing();
+      await prompter.note(
+        formatSiderPairingInstructions({ pairingCode: pairing.pairingCode }),
+        "Sider pairing",
+      );
+
+      const progress = prompter.progress("Waiting for connection...");
+      const reportPendingUpdate = createSiderPairingPendingUpdateReporter({
+        pairingCode: pairing.pairingCode,
+        report: (message) => {
+          progress.update(message);
+        },
+      });
+      try {
+        const paired = await waitForSiderPairing({
+          pairing,
+          onPending: reportPendingUpdate,
+          onRetryableError: (message) => {
+            progress.update(message);
+          },
+        });
+        progress.stop("Connected.");
+
+        await prompter.note(
+          "Connected! You can now chat with me in the browser Side Panel.",
+          "Sider connected",
+        );
+        return {
+          cfg: applySiderSetupAccountConfig({
+            cfg,
+            accountId,
+            input: {
+              token: paired.token,
+            },
+          }),
+        };
+      } catch (error) {
+        if (error instanceof SiderPairingExpiredError) {
+          progress.stop("Pairing code expired.");
+          await prompter.note(
+            "Pairing code expired.\nGenerating a new code...",
+            "Sider pairing",
+          );
+          continue;
+        }
+        progress.stop("Pairing failed.");
+        throw error;
+      }
+    }
+  },
+  disable: (cfg) => setSetupChannelEnabled(cfg, setupChannel, false),
+};
+
+export function describeSiderAccountConfigurationError(account: ResolvedSiderAccount): string {
+  if (isSiderAccountSetupPending(account.accountId)) {
+    return (
+      `sider account "${account.accountId}" is waiting for setup token exchange; ` +
+      `selfclaw registration is still in progress`
+    );
+  }
+  const missing: string[] = [];
+  if (!account.token?.trim()) {
+    missing.push("token");
+  }
+  if (!account.relayId?.trim()) {
+    missing.push("relayId");
+  }
+  return (
+    `sider account "${account.accountId}" is not configured: missing ${missing.join("/") || "token/relayId"}; ` +
+    `run \`openclaw channels login --channel ${SIDER_CHANNEL_ID}\` or configure a token`
+  );
+}
+
+export function isSiderAccountBootstrappable(account: ResolvedSiderAccount): boolean {
+  return Boolean(resolveSiderSetupToken(account.accountId, account.config));
+}
+
+export async function resolveManagedSiderAccount(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): Promise<ResolvedSiderAccount> {
+  const initial = resolveSiderAccount(params.cfg, params.accountId);
+  if (!initial.enabled) {
+    return initial;
+  }
+  const setupToken = resolveSiderSetupToken(initial.accountId, initial.config);
+  if (initial.configured && !setupToken) {
+    return initial;
+  }
+  const nextCfg = await ensureSiderAccountSetup({
+    cfg: params.cfg,
+    accountId: initial.accountId,
+    getAccountSetupConfig: readSiderAccountConfig,
+  });
+  return resolveSiderAccount(nextCfg, initial.accountId);
+}
+
+function parseSessionTarget(raw: string): string {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    throw new Error("Missing sider session target");
+  }
+  if (trimmed.startsWith("session:")) {
+    const sessionId = trimmed.slice("session:".length).trim();
+    if (!sessionId) {
+      throw new Error("Invalid sider target, empty session id");
+    }
+    return sessionId;
+  }
+  return trimmed;
+}
+
+export function normalizeSiderMessagingTarget(raw: string): string | undefined {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  const withoutProviderPrefix = trimmed.replace(/^sider:/i, "").trim();
+  return withoutProviderPrefix || undefined;
+}
+
+export function looksLikeSiderTargetId(raw: string, normalized?: string): boolean {
+  const candidate = (normalized ?? raw ?? "").trim();
+  if (!candidate) {
+    return false;
+  }
+  const match = candidate.match(/^session:(.+)$/i);
+  if (match) {
+    return match[1].trim().length > 0;
+  }
+  return !/\s/.test(candidate);
+}
+
+export function resolveOutboundSessionId(params: {
+  account: ResolvedSiderAccount;
+  to?: string;
+}): string {
+  const target = params.to?.trim() || params.account.defaultTo?.trim() || "";
+  if (!target) {
+    throw new Error(
+      `sider account "${params.account.accountId}" missing target; set 'to' or channels.${SIDER_CHANNEL_ID}.defaultTo`,
+    );
+  }
+  return parseSessionTarget(target);
+}
+
+export function extractSiderToolSend(args: Record<string, unknown>): {
+  to: string;
+  accountId?: string;
+  threadId?: string;
+} | null {
+  const action = typeof args.action === "string" ? args.action.trim() : "";
+  if (action !== "sendAttachment" && action !== "send") {
+    return null;
+  }
+  const to = typeof args.to === "string" ? args.to.trim() : "";
+  if (!to) {
+    return null;
+  }
+  const accountId =
+    typeof args.accountId === "string" && args.accountId.trim() ? args.accountId.trim() : undefined;
+  const threadId =
+    typeof args.threadId === "string" && args.threadId.trim() ? args.threadId.trim() : undefined;
+  return { to, accountId, threadId };
+}