openclaw-linso 1.0.0

package/README.md

@@ -0,0 +1,66 @@
+# openclaw-linso
+
+Linso iOS App 的 OpenClaw Channel Plugin，让你的 iPhone 直接和你的 AI 龙虾对话。
+
+## 架构
+
+```
+iPhone (Linso App)
+      │ WebSocket + appToken
+      ▼
+ Relay Server（云端中转）
+      │ WebSocket + appToken
+      ▼
+ OpenClaw Gateway（你的龙虾）
+      │
+      ▼
+   AI Agent
+```
+
+## 安装
+
+```bash
+openclaw plugins install openclaw-linso
+```
+
+## 配置
+
+```bash
+openclaw config set channels.linso.enabled true
+openclaw config set channels.linso.relayUrl wss://relay.linsoapp.com
+openclaw config set channels.linso.appToken <从 App 设置页复制的 Token>
+openclaw gateway restart
+```
+
+或直接编辑 `~/.openclaw/openclaw.json`：
+
+```json
+{
+  "channels": {
+    "linso": {
+      "enabled": true,
+      "relayUrl": "wss://relay.linsoapp.com",
+      "appToken": "从 App 设置页复制的 Token"
+    }
+  }
+}
+```
+
+## 使用步骤
+
+1. 下载 Linso iOS App
+2. 打开 App → 设置 → 填写 Relay 地址 → 自动获取 Token
+3. 复制 Token，运行上面的配置命令
+4. 重启龙虾，配对完成 ✅
+
+## App 消息协议
+
+| 事件 | 说明 |
+|------|------|
+| `connected` | 鉴权成功 |
+| `run_start` | AI 开始生成 |
+| `delta` | 流式增量文字 |
+| `final` | 完整回复 |
+| `done` | 本轮结束 |
+| `plugin_status` | 龙虾连接状态变化 |
+| `error` | 错误信息 |

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+export { monitorLinsoProvider } from "./src/monitor.js";
+export { linsoPlugin } from "./src/channel.js";
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    register(api: OpenClawPluginApi): void;
+};
+export default plugin;

package/dist/index.js

@@ -0,0 +1,35 @@
+// index.ts
+// 插件入口：注册 channel + 启动 monitor service
+// 和飞书 index.ts 结构完全一致
+import { linsoPlugin } from "./src/channel.js";
+import { monitorLinsoProvider } from "./src/monitor.js";
+import { setLinsoRuntime } from "./src/runtime.js";
+export { monitorLinsoProvider } from "./src/monitor.js";
+export { linsoPlugin } from "./src/channel.js";
+const plugin = {
+    id: "linso",
+    name: "Linso iOS Channel",
+    description: "Linso iOS App WebSocket 直连渠道，与飞书接入方式完全一致",
+    register(api) {
+        // 1. 保存 runtime 引用（供 monitor.ts 和 channel.ts 使用）
+        setLinsoRuntime(api.runtime);
+        // 2. 注册 channel plugin（channel 定义、config schema、outbound...）
+        api.registerChannel({ plugin: linsoPlugin });
+        // 3. 注册 service（Gateway 启动时自动调用 start()，停止时调用 stop()）
+        //    这是 monitor 的入口，和飞书的 monitorFeishuProvider 调用方式一样
+        api.registerService({
+            id: "linso-monitor",
+            start: async (ctx) => {
+                await monitorLinsoProvider({
+                    config: ctx.config,
+                    log: (msg) => ctx.logger.info(String(msg)),
+                });
+            },
+            stop: async () => {
+                const { disconnectFromRelay } = await import("./src/relay-client.js");
+                disconnectFromRelay();
+            },
+        });
+    },
+};
+export default plugin;

package/dist/src/channel.d.ts

@@ -0,0 +1,3 @@
+import type { ChannelPlugin } from "openclaw/plugin-sdk";
+import { type ResolvedLinsoAccount } from "./types.js";
+export declare const linsoPlugin: ChannelPlugin<ResolvedLinsoAccount>;

package/dist/src/channel.js

@@ -0,0 +1,118 @@
+// src/channel.ts
+// ChannelPlugin 定义
+import { DEFAULT_ACCOUNT_ID, PAIRING_APPROVED_MESSAGE, buildBaseChannelStatusSummary, createDefaultChannelRuntimeState, } from "openclaw/plugin-sdk";
+import { sendToClient } from "./store.js";
+import { resolveLinsoAccount } from "./types.js";
+// ChannelOutboundAdapter: Agent 主动发消息给 iOS
+const linsoOutbound = {
+    deliveryMode: "direct",
+    textChunkLimit: 4000,
+    sendText: async ({ to, text }) => {
+        const deviceId = to.replace(/^device:/, "");
+        sendToClient(deviceId, { type: "message", text });
+        return { channel: "linso", messageId: `${deviceId}-${Date.now()}` };
+    },
+    sendMedia: async ({ to, mediaUrl }) => {
+        const deviceId = to.replace(/^device:/, "");
+        sendToClient(deviceId, { type: "media", url: mediaUrl });
+        return { channel: "linso", messageId: `${deviceId}-${Date.now()}` };
+    },
+};
+export const linsoPlugin = {
+    id: "linso",
+    meta: {
+        id: "linso",
+        label: "Linso",
+        selectionLabel: "Linso iOS App",
+        docsPath: "/channels/linso",
+        docsLabel: "linso",
+        blurb: "Linso iOS App WebSocket 直连渠道",
+        order: 90,
+    },
+    capabilities: {
+        chatTypes: ["direct"],
+        reactions: false,
+        threads: false,
+        media: false,
+        polls: false,
+    },
+    reload: {
+        configPrefixes: ["channels.linso"],
+    },
+    config: {
+        listAccountIds: () => [DEFAULT_ACCOUNT_ID],
+        resolveAccount: (cfg, accountId) => resolveLinsoAccount(cfg, accountId ?? DEFAULT_ACCOUNT_ID),
+        defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            enabled: account.enabled,
+            configured: account.configured,
+            relayUrl: account.relayUrl,
+        }),
+        resolveAllowFrom: () => [],
+        setAccountEnabled: ({ cfg, enabled }) => ({
+            ...cfg,
+            channels: {
+                ...cfg.channels,
+                linso: {
+                    ...cfg.channels?.linso,
+                    enabled,
+                },
+            },
+        }),
+        deleteAccount: ({ cfg }) => {
+            const channels = { ...cfg.channels };
+            delete channels.linso;
+            return { ...cfg, channels };
+        },
+    },
+    configSchema: {
+        schema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                enabled: { type: "boolean" },
+                relayUrl: { type: "string" },
+                pluginSecret: { type: "string" },
+                appToken: { type: "string" },
+                agentId: { type: "string" },
+                dmPolicy: { type: "string", enum: ["open", "pairing"] },
+            },
+        },
+        uiHints: {
+            relayUrl: { label: "Relay Server 地址", placeholder: "wss://relay.yourdomain.com" },
+            pluginSecret: { label: "Plugin 密钥（Plugin↔Relay 鉴权）", sensitive: true },
+            appToken: { label: "App Token（iOS↔Relay 鉴权）", sensitive: true },
+            agentId: { label: "Agent ID（默认 main）", placeholder: "main" },
+            dmPolicy: { label: "连接策略" },
+        },
+    },
+    pairing: {
+        idLabel: "linsoDeviceId",
+        normalizeAllowEntry: (entry) => entry.replace(/^linso:/i, ""),
+        notifyApproval: async ({ id }) => {
+            sendToClient(id, { type: "pairing_approved", message: PAIRING_APPROVED_MESSAGE });
+        },
+    },
+    outbound: linsoOutbound,
+    status: {
+        defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+        buildChannelSummary: ({ account, snapshot }) => {
+            return buildBaseChannelStatusSummary(snapshot);
+        },
+    },
+    setup: {
+        resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+        applyAccountConfig: ({ cfg }) => ({
+            ...cfg,
+            channels: {
+                ...cfg.channels,
+                linso: {
+                    ...cfg.channels?.linso,
+                    enabled: true,
+                },
+            },
+        }),
+    },
+};

package/dist/src/monitor.d.ts

@@ -0,0 +1,7 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+export type MonitorLinsoOpts = {
+    config?: OpenClawConfig;
+    log?: (...args: unknown[]) => void;
+    abortSignal?: AbortSignal;
+};
+export declare function monitorLinsoProvider(opts?: MonitorLinsoOpts): Promise<void>;

package/dist/src/monitor.js

@@ -0,0 +1,157 @@
+// src/monitor.ts
+// 核心 monitor：Plugin 主动连接云端 Relay（和飞书连 open.feishu.cn 一致）
+// 收到 iOS 消息后路由到 Agent，流式回复经 Relay 推回 iOS
+import { getLinsoRuntime } from "./runtime.js";
+import { connectToRelay, disconnectFromRelay } from "./relay-client.js";
+import { sendToClient } from "./store.js";
+import { resolveLinsoAccount } from "./types.js";
+export async function monitorLinsoProvider(opts = {}) {
+    const cfg = opts.config;
+    if (!cfg)
+        throw new Error("Config is required for Linso monitor");
+    const core = getLinsoRuntime();
+    const log = opts.log ?? ((...args) => console.log(...args));
+    const account = resolveLinsoAccount(cfg);
+    if (!account.enabled || !account.configured) {
+        log("[Linso] 未启用或未配置，跳过 monitor");
+        return;
+    }
+    if (!account.relayUrl) {
+        log("[Linso] 未配置 relayUrl，跳过 monitor");
+        return;
+    }
+    log(`[Linso] 连接 Relay Server: ${account.relayUrl}`);
+    // Plugin 主动连接 Relay（outbound，和飞书连 open.feishu.cn 完全一致）
+    connectToRelay(account.relayUrl, {
+        appToken: account.appToken,
+        log,
+        onReady: () => {
+            log("[Linso] Plugin 已连接 Relay，等待 iOS 消息");
+            core.channel.activity.record({
+                channel: "linso",
+                accountId: "default",
+                direction: "inbound",
+            });
+        },
+        onDisconnected: () => {
+            log("[Linso] 与 Relay 断开");
+        },
+        onMessage: (deviceId, msg) => {
+            if (msg.type === "send" && typeof msg.text === "string" && msg.text.trim()) {
+                const text = msg.text.trim();
+                // 拦截 slash 命令，直接回复，不走 Agent
+                if (text.startsWith("/")) {
+                    const runId = `linso-${Date.now()}`;
+                    sendToClient(deviceId, { type: "run_start", runId });
+                    sendToClient(deviceId, { type: "final", runId, text: handleSlashCommand(text) });
+                    sendToClient(deviceId, { type: "done", runId });
+                    return;
+                }
+                void handleIncomingMessage(deviceId, text, cfg, log).catch((err) => {
+                    log(`[Linso] 处理消息出错: ${String(err)}`);
+                    sendToClient(deviceId, { type: "error", message: String(err) });
+                });
+            }
+        },
+    });
+    // 等待 abort 信号（Gateway 重启/重载时触发）
+    if (opts.abortSignal) {
+        await new Promise((resolve) => {
+            opts.abortSignal.addEventListener("abort", () => {
+                log("[Linso] 收到 abort 信号，断开 Relay");
+                disconnectFromRelay();
+                resolve();
+            }, { once: true });
+        });
+    }
+}
+/**
+ * 把 iOS 消息路由到 Agent，流式回复（核心逻辑不变）
+ */
+async function handleIncomingMessage(deviceId, text, cfg, log) {
+    const core = getLinsoRuntime();
+    const route = core.channel.routing.resolveAgentRoute({
+        cfg,
+        channel: "linso",
+        accountId: "default",
+        peer: { kind: "direct", id: deviceId },
+    });
+    log(`[Linso] 路由: ${deviceId} → session=${route.sessionKey} agent=${route.agentId}`);
+    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+    const body = core.channel.reply.formatAgentEnvelope({
+        channel: "Linso",
+        from: deviceId,
+        timestamp: new Date(),
+        envelope: envelopeOptions,
+        body: text,
+    });
+    const inboundCtx = core.channel.reply.finalizeInboundContext({
+        Body: body,
+        BodyForAgent: text,
+        RawBody: text,
+        CommandBody: text,
+        From: `linso:${deviceId}`,
+        To: `device:${deviceId}`,
+        SessionKey: route.sessionKey,
+        AccountId: "default",
+        ChatType: "direct",
+        SenderId: deviceId,
+        SenderName: deviceId,
+        Provider: "linso",
+        Surface: "linso",
+        MessageSid: `${deviceId}-${Date.now()}`,
+        Timestamp: Date.now(),
+        WasMentioned: true,
+        OriginatingChannel: "linso",
+        OriginatingTo: `device:${deviceId}`,
+    });
+    const runId = `linso-${Date.now()}`;
+    const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
+        deliver: async (payload, info) => {
+            if (!payload.text || payload.isReasoning)
+                return;
+            sendToClient(deviceId, {
+                type: info.kind === "final" ? "final" : "delta",
+                runId,
+                text: payload.text,
+            });
+        },
+    });
+    sendToClient(deviceId, { type: "run_start", runId });
+    await core.channel.reply.withReplyDispatcher({
+        dispatcher,
+        onSettled: () => markDispatchIdle(),
+        run: () => core.channel.reply.dispatchReplyFromConfig({
+            ctx: inboundCtx,
+            cfg,
+            dispatcher,
+            replyOptions,
+        }),
+    });
+    sendToClient(deviceId, { type: "done", runId });
+    log(`[Linso] 回复完成: deviceId=${deviceId}`);
+}
+function handleSlashCommand(text) {
+    const cmd = text.toLowerCase().split(/\s+/)[0];
+    switch (cmd) {
+        case "/help":
+            return [
+                "📋 可用命令：",
+                "/help    — 显示帮助",
+                "/status  — 查看连接状态",
+                "/clear   — 提示清除会话（实际需在 App 操作）",
+                "",
+                "直接发消息即可和 AI 对话 🦞",
+            ].join("\n");
+        case "/status":
+            return [
+                "✅ 连接状态：",
+                "• Relay Server：已连接",
+                "• Plugin：已就绪",
+                "• AI Agent：可用",
+                `• 时间：${new Date().toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" })}`,
+            ].join("\n");
+        default:
+            return `未知命令：${text}\n输入 /help 查看可用命令`;
+    }
+}

package/dist/src/relay-client.d.ts

@@ -0,0 +1,10 @@
+export type RelayCallbacks = {
+    appToken: string;
+    onMessage: (deviceId: string, msg: Record<string, unknown>) => void;
+    onReady: () => void;
+    onDisconnected: () => void;
+    log: (...args: unknown[]) => void;
+};
+export declare function connectToRelay(relayUrl: string, callbacks: RelayCallbacks): void;
+export declare function disconnectFromRelay(): void;
+export declare function sendToRelay(msg: Record<string, unknown>): void;

package/dist/src/relay-client.js

@@ -0,0 +1,59 @@
+// src/relay-client.ts
+import { WebSocket } from "ws";
+let ws = null;
+let shouldReconnect = false;
+let reconnectDelay = 3000;
+export function connectToRelay(relayUrl, callbacks) {
+    shouldReconnect = true;
+    reconnectDelay = 3000;
+    _connect(relayUrl, callbacks);
+}
+export function disconnectFromRelay() {
+    shouldReconnect = false;
+    ws?.close();
+    ws = null;
+}
+export function sendToRelay(msg) {
+    if (ws?.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(msg));
+    }
+}
+function _connect(relayUrl, callbacks) {
+    const { appToken, onMessage, onReady, onDisconnected, log } = callbacks;
+    const url = relayUrl.replace(/\/$/, "") + "/plugin";
+    log(`[Linso] 连接 Relay: ${url}`);
+    ws = new WebSocket(url);
+    ws.on("open", () => {
+        log("[Linso] Relay 连接建立，发送鉴权...");
+        ws.send(JSON.stringify({ type: "plugin_auth", appToken }));
+    });
+    ws.on("message", (data) => {
+        let msg;
+        try {
+            msg = JSON.parse(data.toString());
+        }
+        catch {
+            return;
+        }
+        if (msg.type === "plugin_ready") {
+            log("[Linso] Relay 鉴权成功，Plugin 就绪");
+            reconnectDelay = 3000;
+            onReady();
+            return;
+        }
+        const deviceId = msg.deviceId;
+        if (deviceId)
+            onMessage(deviceId, msg);
+    });
+    ws.on("close", () => {
+        log(`[Linso] Relay 断开，${reconnectDelay / 1000}s 后重连...`);
+        ws = null;
+        onDisconnected();
+        if (shouldReconnect) {
+            setTimeout(() => { if (shouldReconnect)
+                _connect(relayUrl, callbacks); }, reconnectDelay);
+            reconnectDelay = Math.min(reconnectDelay * 2, 60_000);
+        }
+    });
+    ws.on("error", err => log(`[Linso] Relay 错误: ${err.message}`));
+}

package/dist/src/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+export declare function setLinsoRuntime(next: PluginRuntime): void;
+export declare function getLinsoRuntime(): PluginRuntime;

package/dist/src/runtime.js

@@ -0,0 +1,11 @@
+// src/runtime.ts
+// 存储 PluginRuntime 引用（和飞书 runtime.ts 完全一致的模式）
+let runtime = null;
+export function setLinsoRuntime(next) {
+    runtime = next;
+}
+export function getLinsoRuntime() {
+    if (!runtime)
+        throw new Error("Linso runtime not initialized");
+    return runtime;
+}

package/dist/src/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/server.js

@@ -0,0 +1 @@
+export {};

package/dist/src/store.d.ts

@@ -0,0 +1,2 @@
+/** 向指定 iOS 设备发送消息（经由 Relay） */
+export declare function sendToClient(deviceId: string, msg: Record<string, unknown>): void;

package/dist/src/store.js

@@ -0,0 +1,8 @@
+// src/store.ts
+// 通过 Relay 向 iOS 推送消息
+// Plugin 不直接持有 iOS 的 WebSocket，而是通过 Relay 转发
+import { sendToRelay } from "./relay-client.js";
+/** 向指定 iOS 设备发送消息（经由 Relay） */
+export function sendToClient(deviceId, msg) {
+    sendToRelay({ ...msg, deviceId });
+}

package/dist/src/types.d.ts

@@ -0,0 +1,20 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+export type LinsoChannelConfig = {
+    enabled?: boolean;
+    relayUrl?: string;
+    appToken?: string;
+    agentId?: string;
+    dmPolicy?: "open" | "pairing";
+};
+export type ResolvedLinsoAccount = {
+    accountId: string;
+    enabled: boolean;
+    configured: boolean;
+    relayUrl: string;
+    appToken: string;
+    agentId: string;
+    dmPolicy: "open" | "pairing";
+    config: LinsoChannelConfig;
+};
+export declare function resolveLinsoConfig(cfg: OpenClawConfig): LinsoChannelConfig;
+export declare function resolveLinsoAccount(cfg: OpenClawConfig, accountId?: string): ResolvedLinsoAccount;

package/dist/src/types.js

@@ -0,0 +1,16 @@
+export function resolveLinsoConfig(cfg) {
+    return cfg.channels?.linso ?? {};
+}
+export function resolveLinsoAccount(cfg, accountId = "default") {
+    const c = resolveLinsoConfig(cfg);
+    return {
+        accountId,
+        enabled: c.enabled ?? false,
+        configured: !!(c.relayUrl && c.appToken),
+        relayUrl: c.relayUrl ?? "",
+        appToken: c.appToken ?? "",
+        agentId: c.agentId ?? "main",
+        dmPolicy: c.dmPolicy ?? "open",
+        config: c,
+    };
+}

package/openclaw.plugin.json

@@ -0,0 +1,18 @@
+{
+  "id": "linso",
+  "name": "Linso iOS Channel",
+  "description": "Linso iOS App channel for OpenClaw — connects your iPhone to your AI via cloud Relay",
+  "version": "1.0.0",
+  "channels": ["linso"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "enabled": { "type": "boolean" },
+      "relayUrl": { "type": "string", "description": "Relay Server WebSocket URL, e.g. wss://relay.yourdomain.com" },
+      "appToken": { "type": "string", "description": "Token from Linso iOS App Settings — used to pair App with this Gateway" },
+      "agentId": { "type": "string" },
+      "dmPolicy": { "type": "string", "enum": ["open", "pairing"] }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "openclaw-linso",
+  "version": "1.0.0",
+  "description": "Linso iOS App channel plugin for OpenClaw — connects via cloud Relay Server",
+  "type": "module",
+  "main": "./dist/index.js",
+  "files": [
+    "dist/",
+    "src/",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "openclaw",
+    "openclaw-plugin",
+    "linso",
+    "ios",
+    "channel"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.12",
+    "typescript": "^5.4.0"
+  },
+  "peerDependencies": {
+    "openclaw": "*"
+  }
+}

package/src/channel.ts

@@ -0,0 +1,148 @@
+// src/channel.ts
+// ChannelPlugin 定义
+
+import type {
+  ChannelPlugin,
+  ChannelOutboundAdapter,
+  OpenClawConfig,
+} from "openclaw/plugin-sdk";
+import {
+  DEFAULT_ACCOUNT_ID,
+  PAIRING_APPROVED_MESSAGE,
+  buildBaseChannelStatusSummary,
+  createDefaultChannelRuntimeState,
+} from "openclaw/plugin-sdk";
+import { sendToClient } from "./store.js";
+import { resolveLinsoAccount, type ResolvedLinsoAccount } from "./types.js";
+
+// ChannelOutboundAdapter: Agent 主动发消息给 iOS
+const linsoOutbound: ChannelOutboundAdapter = {
+  deliveryMode: "direct",
+  textChunkLimit: 4000,
+  sendText: async ({ to, text }) => {
+    const deviceId = to.replace(/^device:/, "");
+    sendToClient(deviceId, { type: "message", text });
+    return { channel: "linso" as any, messageId: `${deviceId}-${Date.now()}` };
+  },
+  sendMedia: async ({ to, mediaUrl }) => {
+    const deviceId = to.replace(/^device:/, "");
+    sendToClient(deviceId, { type: "media", url: mediaUrl });
+    return { channel: "linso" as any, messageId: `${deviceId}-${Date.now()}` };
+  },
+};
+
+export const linsoPlugin: ChannelPlugin<ResolvedLinsoAccount> = {
+  id: "linso",
+
+  meta: {
+    id: "linso",
+    label: "Linso",
+    selectionLabel: "Linso iOS App",
+    docsPath: "/channels/linso",
+    docsLabel: "linso",
+    blurb: "Linso iOS App WebSocket 直连渠道",
+    order: 90,
+  },
+
+  capabilities: {
+    chatTypes: ["direct"],
+    reactions: false,
+    threads: false,
+    media: false,
+    polls: false,
+  },
+
+  reload: {
+    configPrefixes: ["channels.linso"],
+  },
+
+  config: {
+    listAccountIds: () => [DEFAULT_ACCOUNT_ID],
+
+    resolveAccount: (cfg: OpenClawConfig, accountId?: string | null) =>
+      resolveLinsoAccount(cfg, accountId ?? DEFAULT_ACCOUNT_ID),
+
+    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+
+    isConfigured: (account: ResolvedLinsoAccount) => account.configured,
+
+    describeAccount: (account: ResolvedLinsoAccount) => ({
+      accountId: account.accountId,
+      enabled: account.enabled,
+      configured: account.configured,
+      relayUrl: account.relayUrl,
+    }),
+
+    resolveAllowFrom: () => [],
+
+    setAccountEnabled: ({ cfg, enabled }: { cfg: OpenClawConfig; accountId: string; enabled: boolean }) => ({
+      ...cfg,
+      channels: {
+        ...(cfg.channels as Record<string, unknown>),
+        linso: {
+          ...((cfg.channels as Record<string, unknown>)?.linso as Record<string, unknown>),
+          enabled,
+        },
+      },
+    }),
+
+    deleteAccount: ({ cfg }: { cfg: OpenClawConfig; accountId: string }) => {
+      const channels = { ...(cfg.channels as Record<string, unknown>) };
+      delete channels.linso;
+      return { ...cfg, channels } as OpenClawConfig;
+    },
+  },
+
+  configSchema: {
+    schema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled:      { type: "boolean" },
+        relayUrl:     { type: "string" },
+        pluginSecret: { type: "string" },
+        appToken:     { type: "string" },
+        agentId:      { type: "string" },
+        dmPolicy:     { type: "string", enum: ["open", "pairing"] },
+      },
+    },
+    uiHints: {
+      relayUrl:     { label: "Relay Server 地址", placeholder: "wss://relay.yourdomain.com" },
+      pluginSecret: { label: "Plugin 密钥（Plugin↔Relay 鉴权）", sensitive: true },
+      appToken:     { label: "App Token（iOS↔Relay 鉴权）", sensitive: true },
+      agentId:      { label: "Agent ID（默认 main）", placeholder: "main" },
+      dmPolicy:     { label: "连接策略" },
+    },
+  },
+
+  pairing: {
+    idLabel: "linsoDeviceId",
+    normalizeAllowEntry: (entry) => entry.replace(/^linso:/i, ""),
+    notifyApproval: async ({ id }) => {
+      sendToClient(id, { type: "pairing_approved", message: PAIRING_APPROVED_MESSAGE });
+    },
+  },
+
+  outbound: linsoOutbound,
+
+  status: {
+    defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+    buildChannelSummary: ({ account, snapshot }) => {
+      return buildBaseChannelStatusSummary(snapshot);
+    },
+  },
+
+  setup: {
+    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+    applyAccountConfig: ({ cfg }) => ({
+      ...cfg,
+      channels: {
+        ...(cfg.channels as Record<string, unknown>),
+        linso: {
+          ...((cfg.channels as Record<string, unknown>)?.linso as Record<string, unknown>),
+          enabled: true,
+        },
+      },
+    }),
+  },
+};

package/src/monitor.ts

@@ -0,0 +1,195 @@
+// src/monitor.ts
+// 核心 monitor：Plugin 主动连接云端 Relay（和飞书连 open.feishu.cn 一致）
+// 收到 iOS 消息后路由到 Agent，流式回复经 Relay 推回 iOS
+
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { getLinsoRuntime } from "./runtime.js";
+import { connectToRelay, disconnectFromRelay } from "./relay-client.js";
+import { sendToClient } from "./store.js";
+import { resolveLinsoAccount } from "./types.js";
+
+export type MonitorLinsoOpts = {
+  config?: OpenClawConfig;
+  log?: (...args: unknown[]) => void;
+  abortSignal?: AbortSignal;
+};
+
+export async function monitorLinsoProvider(opts: MonitorLinsoOpts = {}): Promise<void> {
+  const cfg = opts.config;
+  if (!cfg) throw new Error("Config is required for Linso monitor");
+
+  const core = getLinsoRuntime();
+  const log = opts.log ?? ((...args: unknown[]) => console.log(...args));
+  const account = resolveLinsoAccount(cfg);
+
+  if (!account.enabled || !account.configured) {
+    log("[Linso] 未启用或未配置，跳过 monitor");
+    return;
+  }
+
+  if (!account.relayUrl) {
+    log("[Linso] 未配置 relayUrl，跳过 monitor");
+    return;
+  }
+
+  log(`[Linso] 连接 Relay Server: ${account.relayUrl}`);
+
+  // Plugin 主动连接 Relay（outbound，和飞书连 open.feishu.cn 完全一致）
+  connectToRelay(account.relayUrl, {
+    appToken: account.appToken,
+    log,
+
+    onReady: () => {
+      log("[Linso] Plugin 已连接 Relay，等待 iOS 消息");
+      core.channel.activity.record({
+        channel: "linso",
+        accountId: "default",
+        direction: "inbound",
+      });
+    },
+
+    onDisconnected: () => {
+      log("[Linso] 与 Relay 断开");
+    },
+
+    onMessage: (deviceId, msg) => {
+      if (msg.type === "send" && typeof msg.text === "string" && msg.text.trim()) {
+        const text = msg.text.trim();
+
+        // 拦截 slash 命令，直接回复，不走 Agent
+        if (text.startsWith("/")) {
+          const runId = `linso-${Date.now()}`;
+          sendToClient(deviceId, { type: "run_start", runId });
+          sendToClient(deviceId, { type: "final", runId, text: handleSlashCommand(text) });
+          sendToClient(deviceId, { type: "done", runId });
+          return;
+        }
+
+        void handleIncomingMessage(deviceId, text, cfg, log).catch((err) => {
+          log(`[Linso] 处理消息出错: ${String(err)}`);
+          sendToClient(deviceId, { type: "error", message: String(err) });
+        });
+      }
+    },
+  });
+
+  // 等待 abort 信号（Gateway 重启/重载时触发）
+  if (opts.abortSignal) {
+    await new Promise<void>((resolve) => {
+      opts.abortSignal!.addEventListener("abort", () => {
+        log("[Linso] 收到 abort 信号，断开 Relay");
+        disconnectFromRelay();
+        resolve();
+      }, { once: true });
+    });
+  }
+}
+
+/**
+ * 把 iOS 消息路由到 Agent，流式回复（核心逻辑不变）
+ */
+async function handleIncomingMessage(
+  deviceId: string,
+  text: string,
+  cfg: OpenClawConfig,
+  log: (...args: unknown[]) => void,
+): Promise<void> {
+  const core = getLinsoRuntime();
+
+  const route = core.channel.routing.resolveAgentRoute({
+    cfg,
+    channel: "linso",
+    accountId: "default",
+    peer: { kind: "direct", id: deviceId },
+  });
+
+  log(`[Linso] 路由: ${deviceId} → session=${route.sessionKey} agent=${route.agentId}`);
+
+  const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+  const body = core.channel.reply.formatAgentEnvelope({
+    channel: "Linso",
+    from: deviceId,
+    timestamp: new Date(),
+    envelope: envelopeOptions,
+    body: text,
+  });
+
+  const inboundCtx = core.channel.reply.finalizeInboundContext({
+    Body: body,
+    BodyForAgent: text,
+    RawBody: text,
+    CommandBody: text,
+    From: `linso:${deviceId}`,
+    To: `device:${deviceId}`,
+    SessionKey: route.sessionKey,
+    AccountId: "default",
+    ChatType: "direct" as const,
+    SenderId: deviceId,
+    SenderName: deviceId,
+    Provider: "linso" as const,
+    Surface: "linso" as const,
+    MessageSid: `${deviceId}-${Date.now()}`,
+    Timestamp: Date.now(),
+    WasMentioned: true,
+    OriginatingChannel: "linso" as const,
+    OriginatingTo: `device:${deviceId}`,
+  });
+
+  const runId = `linso-${Date.now()}`;
+
+  const { dispatcher, replyOptions, markDispatchIdle } =
+    core.channel.reply.createReplyDispatcherWithTyping({
+      deliver: async (payload, info) => {
+        if (!payload.text || payload.isReasoning) return;
+        sendToClient(deviceId, {
+          type: info.kind === "final" ? "final" : "delta",
+          runId,
+          text: payload.text,
+        });
+      },
+    });
+
+  sendToClient(deviceId, { type: "run_start", runId });
+
+  await core.channel.reply.withReplyDispatcher({
+    dispatcher,
+    onSettled: () => markDispatchIdle(),
+    run: () =>
+      core.channel.reply.dispatchReplyFromConfig({
+        ctx: inboundCtx,
+        cfg,
+        dispatcher,
+        replyOptions,
+      }),
+  });
+
+  sendToClient(deviceId, { type: "done", runId });
+  log(`[Linso] 回复完成: deviceId=${deviceId}`);
+}
+
+function handleSlashCommand(text: string): string {
+  const cmd = text.toLowerCase().split(/\s+/)[0];
+  switch (cmd) {
+    case "/help":
+      return [
+        "📋 可用命令：",
+        "/help    — 显示帮助",
+        "/status  — 查看连接状态",
+        "/clear   — 提示清除会话（实际需在 App 操作）",
+        "",
+        "直接发消息即可和 AI 对话 🦞",
+      ].join("\n");
+
+    case "/status":
+      return [
+        "✅ 连接状态：",
+        "• Relay Server：已连接",
+        "• Plugin：已就绪",
+        "• AI Agent：可用",
+        `• 时间：${new Date().toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" })}`,
+      ].join("\n");
+
+    default:
+      return `未知命令：${text}\n输入 /help 查看可用命令`;
+  }
+}

package/src/relay-client.ts

@@ -0,0 +1,72 @@
+// src/relay-client.ts
+import { WebSocket } from "ws";
+
+export type RelayCallbacks = {
+  appToken: string;
+  onMessage: (deviceId: string, msg: Record<string, unknown>) => void;
+  onReady: () => void;
+  onDisconnected: () => void;
+  log: (...args: unknown[]) => void;
+};
+
+let ws: WebSocket | null = null;
+let shouldReconnect = false;
+let reconnectDelay = 3000;
+
+export function connectToRelay(relayUrl: string, callbacks: RelayCallbacks) {
+  shouldReconnect = true;
+  reconnectDelay = 3000;
+  _connect(relayUrl, callbacks);
+}
+
+export function disconnectFromRelay() {
+  shouldReconnect = false;
+  ws?.close();
+  ws = null;
+}
+
+export function sendToRelay(msg: Record<string, unknown>) {
+  if (ws?.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify(msg));
+  }
+}
+
+function _connect(relayUrl: string, callbacks: RelayCallbacks) {
+  const { appToken, onMessage, onReady, onDisconnected, log } = callbacks;
+  const url = relayUrl.replace(/\/$/, "") + "/plugin";
+  log(`[Linso] 连接 Relay: ${url}`);
+
+  ws = new WebSocket(url);
+
+  ws.on("open", () => {
+    log("[Linso] Relay 连接建立，发送鉴权...");
+    ws!.send(JSON.stringify({ type: "plugin_auth", appToken }));
+  });
+
+  ws.on("message", (data) => {
+    let msg: Record<string, unknown>;
+    try { msg = JSON.parse(data.toString()); } catch { return; }
+
+    if (msg.type === "plugin_ready") {
+      log("[Linso] Relay 鉴权成功，Plugin 就绪");
+      reconnectDelay = 3000;
+      onReady();
+      return;
+    }
+
+    const deviceId = msg.deviceId as string | undefined;
+    if (deviceId) onMessage(deviceId, msg);
+  });
+
+  ws.on("close", () => {
+    log(`[Linso] Relay 断开，${reconnectDelay / 1000}s 后重连...`);
+    ws = null;
+    onDisconnected();
+    if (shouldReconnect) {
+      setTimeout(() => { if (shouldReconnect) _connect(relayUrl, callbacks); }, reconnectDelay);
+      reconnectDelay = Math.min(reconnectDelay * 2, 60_000);
+    }
+  });
+
+  ws.on("error", err => log(`[Linso] Relay 错误: ${err.message}`));
+}

package/src/runtime.ts

@@ -0,0 +1,15 @@
+// src/runtime.ts
+// 存储 PluginRuntime 引用（和飞书 runtime.ts 完全一致的模式）
+
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let runtime: PluginRuntime | null = null;
+
+export function setLinsoRuntime(next: PluginRuntime) {
+  runtime = next;
+}
+
+export function getLinsoRuntime(): PluginRuntime {
+  if (!runtime) throw new Error("Linso runtime not initialized");
+  return runtime;
+}

package/src/server.ts

@@ -0,0 +1,4 @@
+// src/server.ts
+// 已废弃 - Plugin 现在使用 relay-client.ts 主动连接云端 Relay
+// 保留此文件避免其他地方意外引用报错
+export {};

package/src/store.ts

@@ -0,0 +1,10 @@
+// src/store.ts
+// 通过 Relay 向 iOS 推送消息
+// Plugin 不直接持有 iOS 的 WebSocket，而是通过 Relay 转发
+
+import { sendToRelay } from "./relay-client.js";
+
+/** 向指定 iOS 设备发送消息（经由 Relay） */
+export function sendToClient(deviceId: string, msg: Record<string, unknown>) {
+  sendToRelay({ ...msg, deviceId });
+}

package/src/types.ts

@@ -0,0 +1,38 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+
+export type LinsoChannelConfig = {
+  enabled?: boolean;
+  relayUrl?: string;
+  appToken?: string;    // App 注册拿到的 token，Plugin 用它连接 Relay
+  agentId?: string;
+  dmPolicy?: "open" | "pairing";
+};
+
+export type ResolvedLinsoAccount = {
+  accountId: string;
+  enabled: boolean;
+  configured: boolean;
+  relayUrl: string;
+  appToken: string;
+  agentId: string;
+  dmPolicy: "open" | "pairing";
+  config: LinsoChannelConfig;
+};
+
+export function resolveLinsoConfig(cfg: OpenClawConfig): LinsoChannelConfig {
+  return (cfg.channels as Record<string, unknown>)?.linso as LinsoChannelConfig ?? {};
+}
+
+export function resolveLinsoAccount(cfg: OpenClawConfig, accountId = "default"): ResolvedLinsoAccount {
+  const c = resolveLinsoConfig(cfg);
+  return {
+    accountId,
+    enabled: c.enabled ?? false,
+    configured: !!(c.relayUrl && c.appToken),
+    relayUrl: c.relayUrl ?? "",
+    appToken: c.appToken ?? "",
+    agentId: c.agentId ?? "main",
+    dmPolicy: c.dmPolicy ?? "open",
+    config: c,
+  };
+}