@rlynicrisis/link 0.1.5 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rlynicrisis/link",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "type": "module",
   "description": "OpenClaw Link channel plugin",
   "files": [
@@ -30,7 +30,7 @@
     "@types/ws": "^8.5.12",
     "openclaw": "latest",
     "protobufjs-cli": "^2.0.0",
-    "typescript": "^5.5.4",
+    "typescript": "^5.9.3",
     "vitest": "^2.0.5"
   },
   "openclaw": {

package/src/bot.ts

@@ -70,11 +70,11 @@ async function handleLinkMessage(params: {
   const { cfg, msg, runtime, accountId, linkCfg } = params;
   const core = getLinkRuntime();
 
-  console.log(`[LinkBot] Received message: type=${msg.type}, fromId=${msg.fromId}, toId=${msg.toId}`);
+  console.log(`[LinkBot:${accountId}] Received message: type=${msg.type}, fromId=${msg.fromId}, toId=${msg.toId}`);
 
   if (msg.type !== MsgType.TEXT) {
     // Only support text for now
-    console.log(`[LinkBot] Ignoring non-text message: type=${msg.type}`);
+    console.log(`[LinkBot:${accountId}] Ignoring non-text message: type=${msg.type}`);
     return;
   }
 
@@ -83,7 +83,7 @@ async function handleLinkMessage(params: {
   const allowedUserId = linkCfg.verifyInfo?.userId;
   const receiverId = msg.toId || "unknown";
 
-  console.log(`[LinkBot] allowedUserId=${allowedUserId}, senderId=${senderId}, receiverId=${receiverId}, toType=${msg.toType}`);
+  console.log(`[LinkBot:${accountId}] allowedUserId=${allowedUserId}, senderId=${senderId}, receiverId=${receiverId}, toType=${msg.toType}`);
 
   if (linkCfg.groupId) {
     // Group mode: only accept messages sent to the configured group
@@ -103,7 +103,7 @@ async function handleLinkMessage(params: {
     bodyStr = JSON.stringify(msg.content);
   }
 
-  console.log(`[LinkBot] Message Body: ${bodyStr}`);
+  console.log(`[LinkBot:${accountId}] Message Body: ${bodyStr}`);
 
 
   // Determine chat ID (for reply)
@@ -113,7 +113,7 @@ async function handleLinkMessage(params: {
   const chatId = isGroup ? msg.toId : senderId;
 
   // Map Link message to OpenClaw InboundContext
-  const sessionKey = `link:${chatId}`; 
+  const sessionKey = `link:${accountId}`;
   
   const ctx = core.channel.reply.finalizeInboundContext({
     Body: bodyStr,
@@ -124,7 +124,7 @@ async function handleLinkMessage(params: {
     SessionKey: sessionKey,
     AccountId: accountId,
     ChatType: isGroup ? "group" : "direct",
-    GroupSubject: isGroup ? chatId : undefined,
+    GroupSubject: isGroup ? sessionKey : undefined,
     SenderName: msg.fromName || senderId,
     SenderId: senderId,
     Provider: "link" as any, 

package/src/channel.ts

@@ -1,7 +1,8 @@
 import type { ChannelPlugin } from "openclaw/plugin-sdk";
 import { startLinkBot, stopLinkBot } from "./bot.js";
 import { linkOnboardingAdapter } from "./onboarding.js";
-import { LinkChannelConfig } from "./types.js";
+import { LinkChannelConfig, resolveAccountConfig, applyLinkDefaults } from "./types.js";
+import { sendMessageLink } from "./send.js";
 
 export const linkPlugin: ChannelPlugin<any> = {
   id: "link",
@@ -91,5 +92,50 @@ export const linkPlugin: ChannelPlugin<any> = {
         });
       });
     }
+  },
+  outbound: {
+    deliveryMode: "direct" as const,
+    textChunkLimit: 4096,
+    sendMedia: async (ctx: any) => {
+      // Link channel does not support media sending
+      return { channel: "link", messageId: "", error: "Media sending not supported on Link channel" };
+    },
+    sendText: async (ctx: any) => {
+      //打印ctx，json字符串
+      console.log("ctx:", JSON.stringify(ctx));
+      const { cfg, to, text, accountId } = ctx;
+      const channelCfg = cfg?.channels?.link as LinkChannelConfig | undefined;
+      
+      if (!channelCfg) {
+        return { channel: "link", messageId: "", error: "Link channel not configured" };
+      }
+
+      const rawCfg = resolveAccountConfig(channelCfg, accountId || "default");
+      if (!rawCfg) {
+        return { channel: "link", messageId: "", error: `Link config not found for account ${accountId}` };
+      }
+      
+      const linkCfg = applyLinkDefaults(rawCfg);
+      
+      if (!to) {
+        return { channel: "link", messageId: "", error: "No target specified" };
+      }
+
+      if (!text) {
+        return { channel: "link", messageId: "", error: "No text content" };
+      }
+
+      try {
+        await sendMessageLink({
+          to,
+          text,
+          accountId: accountId || "default",
+          cfg: linkCfg
+        });
+        return { channel: "link", messageId: `link-${Date.now()}` };
+      } catch (error) {
+        return { channel: "link", messageId: "", error: String(error) };
+      }
+    }
   }
 };

package/src/client-manager.ts

@@ -26,6 +26,7 @@ export function createLinkClient(accountId: string, config: LinkConfig): LinkCli
   }
 
   const client = new LinkClient({
+      accountId,
       host,
       port,
       accessToken: config.accessToken,

package/src/link/client.ts

@@ -6,6 +6,7 @@ import * as crypto from 'crypto';
 import { CmdCodes } from './constants.js';
 import { decodePacket, encodePacket, encodeMessage, decodeMessage, ProtocolError } from './protocol.js';
 import { EmbMessage, ClientVerifyInfo } from './types.js';
+import { loadLastMsgTime, saveLastMsgTime } from './state-store.js';
 
 export class LinkClient extends EventEmitter {
   private socket: net.Socket | null = null;
@@ -14,9 +15,13 @@ export class LinkClient extends EventEmitter {
   private reconnectTimeout: NodeJS.Timeout | null = null;
   private isConnected = false;
   private immediateReconnect = false;
-  
+  private stopped = false;
+  private lastOfflineMsgSendTime: number;
+  private get tag() { return `[LinkBot:${this.config.accountId}]`; }
+
   constructor(
     public readonly config: {
+      accountId: string;
       host: string;
       port: number;
       accessToken: string;
@@ -27,17 +32,19 @@ export class LinkClient extends EventEmitter {
     }
   ) {
     super();
+    this.lastOfflineMsgSendTime = loadLastMsgTime(config.accountId);
   }
 
   public connect() {
+    this.stopped = false;
     if (this.socket) {
       this.socket.destroy();
     }
 
     this.socket = new net.Socket();
-    
+
     this.socket.on('connect', () => {
-      console.log('LinkClient connected');
+      console.log(`${this.tag} LinkClient connected`);
       this.isConnected = true;
       this.sendVerify();
       this.startHeartbeat();
@@ -50,7 +57,7 @@ export class LinkClient extends EventEmitter {
     });
 
     this.socket.on('close', () => {
-      console.log('LinkClient disconnected');
+      console.log(`${this.tag} LinkClient disconnected`);
       this.isConnected = false;
       this.stopHeartbeat();
       this.emit('disconnected');
@@ -58,7 +65,7 @@ export class LinkClient extends EventEmitter {
     });
 
     this.socket.on('error', (err) => {
-      console.error('LinkClient error:', err);
+      console.error(`${this.tag} LinkClient error:`, err);
       this.emit('error', err);
     });
 
@@ -66,9 +73,11 @@ export class LinkClient extends EventEmitter {
   }
 
   public disconnect() {
+    this.stopped = true;
     this.stopHeartbeat();
     if (this.reconnectTimeout) {
       clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
     }
     if (this.socket) {
       this.socket.destroy();
@@ -96,37 +105,36 @@ export class LinkClient extends EventEmitter {
         const payload = JSON.parse(Buffer.from(tokenParts[1], 'base64').toString());
         userId = payload.sub || payload.user_id || 'unknown';
       } catch (e) {
-        console.error('Failed to parse accessToken for userId', e);
+        console.error(`${this.tag} Failed to parse accessToken for userId`, e);
       }
     }
 
     // Generate stable deviceUID based on machine info if not provided
     let deviceUID = this.config.verifyInfo?.deviceUID;
     if (!deviceUID) {
-      // ... (keep existing logic)
-      deviceUID = `openclaw-link-${userId}`;
+      const machineInfo = `${os.hostname()}-${os.platform()}-${os.arch()}`;
+      const machineHash = crypto.createHash('sha256').update(machineInfo).digest('hex').slice(0, 8);
+      deviceUID = `openclaw-link-${userId}-${this.config.accountId}-${machineHash}`;
     }
 
     const info = {
         userId: userId,
-        deviceUID: deviceUID!, 
+        deviceUID: deviceUID!,
         deviceName: 'OpenClawBot',
-        deviceToken: 'openclaw-device-token', 
+        deviceToken: 'openclaw-device-token',
         accessToken: this.config.accessToken,
         version: '1.0.0',
         force: true,
         protocolVersion: 3.0,
         isFirstLogin: false,
         secret: '',
-        ...this.config.verifyInfo 
+        ...this.config.verifyInfo
       };
 
     if (!this.config.verifyInfo) {
        // Should not happen if initialized correctly in client-manager
        // But if it is undefined, we can't update the config object passed in constructor if it's readonly
        // However, this.config.verifyInfo is a reference.
-       // Let's cast to writable or ensure it is set.
-       // Actually, 'config' is readonly, but 'verifyInfo' property inside it is an object reference.
        // If verifyInfo was undefined, we can't assign to it.
        // We need to make sure verifyInfo is initialized in constructor or allow it to be mutable.
        // The best way is to ensure client-manager passes an object reference.
@@ -135,7 +143,7 @@ export class LinkClient extends EventEmitter {
        // But wait, typescript readonly on config means we can't assign to config.verifyInfo if it's not there.
        // We can assign to properties OF verifyInfo if verifyInfo exists.
     }
-    
+
     if (this.config.verifyInfo) {
         this.config.verifyInfo.userId = info.userId;
         this.config.verifyInfo.deviceUID = info.deviceUID;
@@ -158,7 +166,7 @@ export class LinkClient extends EventEmitter {
     };
 
     const body = JSON.stringify(verifyBody);
-    
+
     const packet = encodePacket(CmdCodes.CLIENT_VERIFY_UP, body);
     if (this.socket) this.socket.write(packet);
   }
@@ -169,6 +177,7 @@ export class LinkClient extends EventEmitter {
       if (this.socket && this.isConnected) {
         const packet = encodePacket(CmdCodes.HEART_BEAT_UP);
         this.socket.write(packet);
+        console.log(`${this.tag} Heartbeat UP sent`);
       }
     }, this.config.heartbeatIntervalMs || 30000);
   }
@@ -181,12 +190,13 @@ export class LinkClient extends EventEmitter {
   }
 
   private scheduleReconnect() {
+    if (this.stopped) return;
     if (this.reconnectTimeout) return;
     const delay = this.immediateReconnect ? 0 : 5000;
     this.immediateReconnect = false;
     this.reconnectTimeout = setTimeout(() => {
       this.reconnectTimeout = null;
-      console.log('Reconnecting...');
+      console.log(`${this.tag} Reconnecting...`);
       this.connect();
     }, delay);
   }
@@ -197,18 +207,18 @@ export class LinkClient extends EventEmitter {
         // Try to decode one packet
         // We need to peek header first
         if (this.buffer.length < 4) break; // Wait for more data
-        
+
         // decodePacket throws if incomplete body, but we need to handle that gracefully
         // The decodePacket implementation I wrote throws "Incomplete body" which is not ideal for stream processing
-        // Let's modify decodePacket or handle it here. 
+        // Let's modify decodePacket or handle it here.
         // Better: implement a peek function or modify decodePacket to return null if incomplete.
         // For now, I'll rely on the length check I added in decodePacket:
         // if (buffer.length < 8 + bodyLen) throw ...
-        
+
         // Wait, if it throws "Incomplete body", I should catch it and return.
         // But "ProtocolError" might mean malformed too.
         // I should probably improve decodePacket to differentiate "Need more data" vs "Invalid data".
-        
+
         // Let's do a manual check here to be safe and efficient
         const bodyCount = this.buffer[3];
         let requiredLen = 4;
@@ -217,13 +227,13 @@ export class LinkClient extends EventEmitter {
             const bodyLen = this.buffer.readUInt32BE(4);
             requiredLen = 8 + bodyLen;
         }
-        
+
         if (this.buffer.length < requiredLen) break; // Wait for more data
 
         // Now we have a full packet
         const packetData = this.buffer.subarray(0, requiredLen);
         const { cmdCode, body } = decodePacket(packetData); // This shouldn't throw "Incomplete" now
-        
+
         // Advance buffer
         this.buffer = this.buffer.subarray(requiredLen);
 
@@ -233,7 +243,7 @@ export class LinkClient extends EventEmitter {
         if (err instanceof ProtocolError) {
              // If it's truly a protocol error (e.g. invalid header), we might need to close connection or skip byte?
              // For simplicity, let's log and maybe close.
-             console.error('Protocol error:', err);
+             console.error(`${this.tag} Protocol error:`, err);
              // Skip one byte and try again to resync?
              this.buffer = this.buffer.subarray(1);
              // this.socket?.destroy();
@@ -247,71 +257,97 @@ export class LinkClient extends EventEmitter {
   private async handleCommand(cmdCode: number, body?: string | Buffer) {
     switch (cmdCode) {
       case CmdCodes.HEART_BEAT_DOWN:
-        // Heartbeat ack, ignore or reset timer
+        console.log(`${this.tag} Heartbeat DOWN received (server ack)`);
         break;
       case CmdCodes.SEND_MSG:
         if (body) {
           try {
             const msg = decodeMessage(body);
+            if (this.lastOfflineMsgSendTime > 0 && msg.sendTime <= this.lastOfflineMsgSendTime) {
+              console.log(`${this.tag} Skipping duplicate offline message (sendTime=${msg.sendTime})`);
+              this.sendReceipt(msg.id);
+              break;
+            }
+            if (msg.sendTime > this.lastOfflineMsgSendTime) {
+              this.lastOfflineMsgSendTime = msg.sendTime;
+              saveLastMsgTime(this.config.accountId, this.lastOfflineMsgSendTime);
+            }
             this.sendReceipt(msg.id);
             this.emit('message', msg);
           } catch (e) {
-            console.error('Failed to decode message:', e);
-            console.error('Raw body:', body);
+            console.error(`${this.tag} Failed to decode message:`, e);
+            console.error(`${this.tag} Raw body:`, body);
           }
         }
         break;
       case CmdCodes.CLIENT_VERIFY_DOWN:
-        console.log('Client verify success');
+        console.log(`${this.tag} Client verify success`);
         break;
       case CmdCodes.ERROR_UP:
-        console.error('Link server returned error:', body);
+        console.error(`${this.tag} Link server returned error:`, body);
         break;
       case CmdCodes.REFRESH_TOKEN_DOWN:
-        console.log('Received REFRESH_TOKEN_DOWN (0x87), token might be expired. Attempting refresh...');
+        console.log(`${this.tag} Received REFRESH_TOKEN_DOWN (0x87), token might be expired. Attempting refresh...`);
         await this.refreshAccessToken();
         break;
       case CmdCodes.OFFLINE_UNEND_DOWN:
+        console.log(`${this.tag} Offline messages not complete, pulling more...`);
+        this.requestOfflineMessages();
+        break;
       case CmdCodes.OFFLINE_END_DOWN:
+        console.log(`${this.tag} Offline messages fully received`);
+        break;
       case CmdCodes.SINGLE_DEVICE_DOWN:
       case CmdCodes.SLEEP_DOWN:
+        console.log(`${this.tag} Received cmd: 0x${cmdCode.toString(16)}`);
+        break;
       case CmdCodes.SEND_MSG_RECEIPT:
-        console.log('Received message receipt from server. Body len:', body ? body.length : 0);
+        console.log(`${this.tag} Received message receipt from server. Body len:`, body ? body.length : 0);
         break;
       case CmdCodes.REC_READ_DOWN:
         // Ignore for now or log
         // console.log(`Received cmd: 0x${cmdCode.toString(16)}, body: ${body}`);
         break;
       case CmdCodes.FORCE_RECONNECT_DOWN:
-        console.log('Server signaled session reset (0x6b), will reconnect immediately on disconnect');
+        console.log(`${this.tag} Server signaled session reset (0x6b), will reconnect immediately on disconnect`);
         this.immediateReconnect = true;
         break;
       default:
-         console.log(`Received unknown cmd: 0x${cmdCode.toString(16)}, body: ${body}`);
+        console.log(`${this.tag} Received unknown cmd: 0x${cmdCode.toString(16)}, body: ${body}`);
     }
   }
 
+  private requestOfflineMessages() {
+    if (!this.socket || !this.isConnected) return;
+    const body = JSON.stringify({
+      pageSize: -1,
+      startSendTime: this.lastOfflineMsgSendTime + 1,
+    });
+    const packet = encodePacket(CmdCodes.OFFLINE_GET_UP, body);
+    this.socket.write(packet);
+  }
+
   private sendReceipt(msgId: unknown) {
     if (!this.socket || !this.isConnected) return;
-    console.log('Sending receipt for message:', msgId);
+    console.log(`${this.tag} Sending receipt for message:`, msgId);
     const packet = encodePacket(CmdCodes.SEND_MSG_RECEIPT, String(msgId));
     this.socket.write(packet);
   }
 
   private async refreshAccessToken() {
     if (!this.config.refreshToken || !this.config.ssoUrl) {
-      console.error('Cannot refresh token: Missing refreshToken or ssoUrl in config');
+      console.error(`${this.tag} Cannot refresh token: Missing refreshToken or ssoUrl in config`);
       return;
     }
 
     try {
-      console.log('Refreshing access token via SSO...');
+      console.log(`${this.tag} Refreshing access token via SSO...`);
       let ssoUrl = this.config.ssoUrl;
       if (!ssoUrl.endsWith('/')) {
         ssoUrl += '/';
       }
       const url = new URL('oauth2/token', ssoUrl);
-      
+
       // Assume client credentials (clientId/clientSecret) are encoded in basic auth or not needed?
       // User input implies "Authorization: Basic Y2xpZW50SWQ6Y2xpZW50U2VjcmV0" (clientId:clientSecret)
       // Since we don't have clientId/Secret in config, we might need to add them or assume they are fixed/optional.
@@ -329,7 +365,7 @@ export class LinkClient extends EventEmitter {
       // And maybe use a default or empty basic auth if not provided?
       // Let's check if we can add clientId/Secret to config. The prompt didn't explicitly ask for them, but implied by the example.
       // I'll assume for now that I should just send the POST request.
-      
+
       // Let's add a placeholder for Authorization header if not configurable.
       const authHeader = 'Basic Y2xpZW50SWQ6Y2xpZW50U2VjcmV0'; // From example
 
@@ -353,12 +389,12 @@ export class LinkClient extends EventEmitter {
 
       const data = await response.json();
       if (data.access_token) {
-        console.log('Token refreshed successfully');
+        console.log(`${this.tag} Token refreshed successfully`);
         this.config.accessToken = data.access_token;
         if (data.refresh_token) {
           this.config.refreshToken = data.refresh_token;
         }
-        
+
         // Re-verify with new token
         // We might need to disconnect and reconnect, or just send verify packet again?
         // Usually Verify packet is sent after connection.
@@ -367,10 +403,10 @@ export class LinkClient extends EventEmitter {
         // Let's try sending Verify again.
         this.sendVerify();
       } else {
-        console.error('Invalid refresh response:', data);
+        console.error(`${this.tag} Invalid refresh response:`, data);
       }
     } catch (e) {
-      console.error('Failed to refresh token:', e);
+      console.error(`${this.tag} Failed to refresh token:`, e);
     }
   }
 }

package/src/link/protocol.ts

@@ -273,13 +273,13 @@ function convertProtoMessage(protoMsg: any): EmbMessage {
 
   return {
     id: protoMsg.msgId || 'unknown',
-    type: protoMsg.type || 1,
+    type: protoMsg.type ?? 1,
     content: content,
-    fromType: protoMsg.from?.fromType || 1,
+    fromType: protoMsg.from?.fromType ?? 1,
     fromId: protoMsg.from?.fromId || 'unknown',
     fromName: protoMsg.from?.fromName || undefined,
     fromCompany: protoMsg.from?.fromCompany || undefined,
-    toType: protoMsg.to?.toType || 1,
+    toType: protoMsg.to?.toType ?? 1,
     toId: protoMsg.to?.toId || 'unknown',
     toName: protoMsg.to?.toName || undefined,
     toCompany: protoMsg.to?.toCompany || undefined,

package/src/link/state-store.ts

@@ -0,0 +1,31 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+const STATE_DIR = path.join(os.homedir(), '.openclaw', 'link');
+const STATE_FILE = path.join(STATE_DIR, 'state.json');
+
+type StateMap = Record<string, { lastOfflineMsgSendTime: number }>;
+
+function readAll(): StateMap {
+  try {
+    return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+export function loadLastMsgTime(accountId: string): number {
+  return readAll()[accountId]?.lastOfflineMsgSendTime ?? 0;
+}
+
+export function saveLastMsgTime(accountId: string, time: number): void {
+  try {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+    const all = readAll();
+    all[accountId] = { lastOfflineMsgSendTime: time };
+    fs.writeFileSync(STATE_FILE, JSON.stringify(all, null, 2));
+  } catch (e) {
+    console.error(`[LinkBot:${accountId}] Failed to save state:`, e);
+  }
+}