@rlynicrisis/link 0.0.1 → 0.0.2

package/src/link/protocol.ts

@@ -1,6 +1,7 @@
 import { Buffer } from 'buffer';
 import { CmdCodes } from './constants.js';
 import { EmbMessage, EmbCommand } from './types.js';
+import { emb } from './message.js';
 
 const HEAD = 0x5;
 const OPT = 0x0;
@@ -12,26 +13,41 @@ export class ProtocolError extends Error {
   }
 }
 
-// Simple encryption from Java client: ~byte then Base64
-export function encryptContent(raw: string): string {
-  if (!raw) return raw;
-  const buffer = Buffer.from(raw, 'utf-8');
+// Simple encryption from Java client: Base64
+export function encryptContent(raw: string | Buffer): string {
+  if (!raw) return raw as string;
+  let buffer: Buffer;
+  if (Buffer.isBuffer(raw)) {
+    buffer = Buffer.from(raw); // Copy to avoid modifying original
+  } else {
+    buffer = Buffer.from(raw, 'utf-8');
+  }
+
+  // Restore bitwise NOT (~) to match provided Java code
+  // It seems sending requires encryption, while receiving might not (or depends on msg type)
   for (let i = 0; i < buffer.length; i++) {
     buffer[i] = ~buffer[i];
   }
   return buffer.toString('base64');
 }
 
-export function decryptContent(encoded: string): string {
-  if (!encoded) return encoded;
+export function decryptContentBuffer(encoded: string): Buffer {
+  if (!encoded) return Buffer.alloc(0);
   const buffer = Buffer.from(encoded, 'base64');
+
   for (let i = 0; i < buffer.length; i++) {
     buffer[i] = ~buffer[i];
   }
+  
+  return buffer;
+}
+
+export function decryptContent(encoded: string): string {
+  const buffer = decryptContentBuffer(encoded);
   return buffer.toString('utf-8');
 }
 
-export function encodePacket(cmdCode: number, body?: string): Buffer {
+export function encodePacket(cmdCode: number, body?: string | Buffer): Buffer {
   const header = Buffer.alloc(4);
   header[0] = HEAD;
   header[1] = cmdCode;
@@ -43,14 +59,21 @@ export function encodePacket(cmdCode: number, body?: string): Buffer {
   }
 
   header[3] = 1; // Body count = 1
-  const bodyBuffer = Buffer.from(body, 'utf-8');
+  
+  let bodyBuffer: Buffer;
+  if (Buffer.isBuffer(body)) {
+    bodyBuffer = body;
+  } else {
+    bodyBuffer = Buffer.from(body, 'utf-8');
+  }
+
   const lenBuffer = Buffer.alloc(4);
   lenBuffer.writeUInt32BE(bodyBuffer.length, 0);
   
   return Buffer.concat([header, lenBuffer, bodyBuffer]);
 }
 
-export function decodePacket(buffer: Buffer): { cmdCode: number; body?: string; consumed: number } {
+export function decodePacket(buffer: Buffer): { cmdCode: number; body?: Buffer; consumed: number } {
   if (buffer.length < 4) {
     throw new ProtocolError('Incomplete header');
   }
@@ -75,221 +98,192 @@ export function decodePacket(buffer: Buffer): { cmdCode: number; body?: string;
     if (buffer.length < 8 + bodyLen) {
       throw new ProtocolError('Incomplete body');
     }
-    const body = buffer.toString('utf-8', 8, 8 + bodyLen);
+    const body = buffer.subarray(8, 8 + bodyLen);
     return { cmdCode, body, consumed: 8 + bodyLen };
   }
 
   throw new ProtocolError(`Unsupported body count: ${bodyCount}`);
 }
 
-export function encodeMessage(msg: EmbMessage): string {
-  // Map fields to JSON keys as per Java implementation
-  const json = {
-    msg_id: msg.id,
-    msg_type: msg.type,
-    content: msg.sign ? msg.content : encryptContent(msg.content),
-    from_type: msg.fromType,
-    from_id: msg.fromId,
-    from_name: msg.fromName,
-    from_company: msg.fromCompany,
-    to_type: msg.toType,
-    to_id: msg.toId,
-    to_name: msg.toName,
-    to_company: msg.toCompany,
-    send_time: msg.sendTime,
-    is_read: msg.read ? 1 : 0,
-    sign: msg.sign
+export function encodeMessage(msg: EmbMessage): Buffer {
+  // If protocol version is >= 3.0, server expects Protobuf encoded message in payload, 
+  // NOT JSON string.
+  
+  // Convert EmbMessage to Protobuf Message object
+  // Note: content field in Protobuf is bytes.
+  // We need to handle content encryption here:
+  // Raw Content -> ~ (Bitwise NOT) -> Buffer -> Protobuf content field
+  
+  let contentBuffer: Buffer;
+  if (Buffer.isBuffer(msg.content)) {
+    contentBuffer = Buffer.from(msg.content);
+  } else {
+    contentBuffer = Buffer.from(msg.content, 'utf-8');
+  }
+
+  // Apply encryption (~)
+  for (let i = 0; i < contentBuffer.length; i++) {
+    contentBuffer[i] = ~contentBuffer[i];
+  }
+
+  const messagePayload = {
+    msgId: msg.id,
+    type: msg.type,
+    sendTime: msg.sendTime,
+    content: contentBuffer,
+    from: {
+      fromId: msg.fromId,
+      fromType: msg.fromType,
+      fromName: msg.fromName,
+      fromCompany: msg.fromCompany,
+      // fromDevice: ... (filled by server session)
+    },
+    to: {
+      toId: msg.toId,
+      toType: msg.toType,
+      toName: msg.toName,
+      toCompany: msg.toCompany
+    },
+    options: {
+      isRead: msg.read
+    }
   };
-  return JSON.stringify(json);
+
+  const message = emb.message.format.Message.create(messagePayload);
+  return Buffer.from(emb.message.format.Message.encode(message).finish());
 }
 
-export function decodeMessage(jsonStr: string): EmbMessage {
+export function decodeMessage(body: Buffer | string): EmbMessage {
+  // Try to decode as string first to check for JSON
+  let jsonStr = '';
+  if (Buffer.isBuffer(body)) {
+    jsonStr = body.toString('utf-8');
+  } else {
+    jsonStr = body;
+  }
+
   // Try to fix malformed JSON if it has leading garbage
   let cleanJsonStr = jsonStr;
   
   // Find first '{'
   const braceIndex = jsonStr.indexOf('{');
+  // Check if it looks like JSON
   if (braceIndex >= 0) {
      cleanJsonStr = jsonStr.substring(braceIndex);
-  } else {
-     // No JSON object start found?
-     throw new Error("No JSON object found in message body");
-  }
+     
+     // Find last '}' to handle trailing garbage if any
+     const lastBraceIndex = cleanJsonStr.lastIndexOf('}');
+     if (lastBraceIndex >= 0 && lastBraceIndex < cleanJsonStr.length - 1) {
+       cleanJsonStr = cleanJsonStr.substring(0, lastBraceIndex + 1);
+     }
 
-  // Find last '}' to handle trailing garbage if any
-  const lastBraceIndex = cleanJsonStr.lastIndexOf('}');
-  if (lastBraceIndex >= 0 && lastBraceIndex < cleanJsonStr.length - 1) {
-    cleanJsonStr = cleanJsonStr.substring(0, lastBraceIndex + 1);
+     try {
+       const json = JSON.parse(cleanJsonStr);
+       const sign = json.sign;
+       // Return Buffer if encrypted, otherwise string
+       const content = sign ? json.content : decryptContentBuffer(json.content);
+       
+       return {
+         id: json.msg_id,
+         type: json.msg_type,
+         content: content,
+         fromType: json.from_type,
+         fromId: json.from_id,
+         fromName: json.from_name,
+         fromCompany: json.from_company,
+         toType: json.to_type,
+         toId: json.to_id,
+         toName: json.to_name,
+         toCompany: json.to_company,
+         sendTime: json.send_time,
+         read: json.is_read === 1,
+         sign: sign
+       };
+     } catch (e) {
+       // Ignore JSON parse error and fall through to Protobuf check
+     }
   }
 
-  // Attempt to remove non-JSON prefix if '{' check wasn't enough (e.g. if body starts with garbage but contains {)
-  // The logs show bodies starting with $UUID... then JSON content?
-  // Actually the logs show: $UUID... and then some binary/garbage? Or maybe the body IS just that string?
-  // Wait, the logs show: "$c8b8dca6-..." ... is not valid JSON
-  // And Raw Body: $c8b8dca6-... followed by some binary chars.
-  
-  // It seems the body received is NOT JSON.
-  // The Java code suggests:
-  // protected EmbMessage decode(JsonObject json) { ... }
-  // And TcpProtocolV2.java:
-  // public EmbCommand decodeCommandWithBody(byte[] body) {
-  //    if(bodyCount == 1) {
-  //        EmbCommandWithBody cmd = newInstance();
-  //        cmd.setCmdBody(Strings.newStringUtf8(body));
-  //        return cmd;
-  //    }
-  // }
-  
-  // However, `SendMessage` (Cmd 0x3) is `EmbCommandWithMsgBase`.
-  // Wait, `SendMessage` extends `EmbCommandWithMsgBase`.
-  // `EmbCommandWithMsgBase` implements `EmbCommandWithMsg`.
-  // `EmbCommandWithMsg` extends `EmbCommandWithBody`.
-  
-  // The `TcpProtocolV2` decodes the body as a UTF-8 string.
-  // Then `MessageProtocol` decodes that string into an `EmbMessage`.
-  // `MessageProtocolV3.decode(JsonObject json)` expects a JSON object.
-  
-  // BUT the logs show the body content starting with a UUID (maybe msgId?) and NOT a JSON object.
-  // Example: $c8b8dca6-a423-48e1-8c15-911eebc316b0c...
-  
-  // Is it possible the server is sending V2 protocol or a different format?
-  // Or maybe the body is encrypted?
-  // `MessageProtocolV2` has `encrypt`/`decrypt`.
-  // But `decode` calls `JsonObject.parse(body)`.
-  
-  // Let's look closely at the Java code again.
-  // TcpProtocolV2:
-  //   byte[] body = ...
-  //   cmd.setCmdBody(Strings.newStringUtf8(body));
-  
-  // If the server sends `SEND_MSG` (0x3), the client receives it.
-  // The body SHOULD be a JSON string representing the message.
-  
-  // Why does the log show `$UUID...`?
-  // Maybe the `TcpProtocolV2` logic for parsing the packet is slightly off?
-  // Packet structure:
-  // HEAD(1) + CMD(1) + OPT(1) + BODY_COUNT(1)
-  // If BODY_COUNT=1: + LENGTH(4) + BODY(LENGTH)
-  
-  // My implementation:
-  // header[0] = HEAD;
-  // header[1] = cmdCode;
-  // header[3] = bodyCount;
-  // ...
-  // const bodyLen = buffer.readUInt32BE(4);
-  
-  // Let's verify if I am reading the length correctly.
-  // If I read length wrong, I might be reading into the next packet or reading garbage.
-  
-  // In the logs:
-  // Raw body: $c8b8dca6-a423-48e1-8c15-911eebc316b0c...
-  // This looks like a UUID.
-  // Maybe the body IS just a UUID? But SEND_MSG expects a full message.
-  
-  // Is it possible that `0x3` (SEND_MSG) from server to client has a different format?
-  // `SendMessage` class:
-  // public byte getCmdCode() { return CmdCodes.SEND_MSG; }
-  
-  // Wait, `SendMessage` is typically Client -> Server.
-  // Server -> Client message push is also `SEND_MSG`?
-  // Java client `TcpClient` handles received messages.
-  // It decodes the command.
-  
-  // If the server is sending `SEND_MSG`, it should contain the message.
-  // The logs show what looks like a message ID (UUID).
-  
-  // Maybe the packet has multiple bodies?
-  // My code throws "Unsupported body count" if != 0 or 1.
-  // It didn't throw that. So bodyCount is 1.
-  
-  // Maybe the length includes something else?
-  // `TcpProtocolV2`: `Bytes.bytes4ToInt(bytesLen)` (Big Endian usually).
-  
-  // Let's try to parse the body as if it might be encrypted or formatted differently?
-  // Or maybe I should log the hex of the body to see what's going on.
-  
-  // If I look at the "Raw body" output again:
-  // $c8b8dca6-a423-48e1-8c15-911eebc316b0c...
-  // It starts with `$`.
-  // A UUID is 36 chars.
-  // The log shows more chars after it.
-  // It looks like `UUID` + `Content`?
-  
-  // Wait! In Java `MessageProtocolV2`:
-  // encode: writes JSON.
-  // decode: parses JSON.
-  
-  // Is it possible the server is using a custom serialization that is NOT JSON?
-  // Or maybe I am connecting to a server version that uses a different protocol?
-  
-  // Let's relax the JSON requirement and return a raw message if JSON fails, just to see what happens.
-  
-  try {
-    const json = JSON.parse(cleanJsonStr);
-    const sign = json.sign;
-    const content = sign ? json.content : decryptContent(json.content);
-    
-    return {
-      id: json.msg_id,
-      type: json.msg_type,
-      content: content,
-      fromType: json.from_type,
-      fromId: json.from_id,
-      fromName: json.from_name,
-      fromCompany: json.from_company,
-      toType: json.to_type,
-      toId: json.to_id,
-      toName: json.to_name,
-      toCompany: json.to_company,
-      sendTime: json.send_time,
-      read: json.is_read === 1,
-      sign: sign
-    };
-  } catch (e) {
-    // If parsing fails, use regex to extract key fields as a fallback
-    // The raw body seems to have format: $UUID...{JSON content}...binary?
-    // Or maybe: $UUID...JSON...
-    
-    // Let's try to extract JSON-like structure using regex if standard parsing fails
-    // This is risky but might work for the mixed content we are seeing
-    const jsonMatch = jsonStr.match(/(\{.*\})/s);
-    if (jsonMatch) {
-       try {
-         const json = JSON.parse(jsonMatch[1]);
-         const sign = json.sign;
-         const content = sign ? json.content : decryptContent(json.content);
-         return {
-            id: json.msg_id,
-            type: json.msg_type,
-            content: content,
-            fromType: json.from_type,
-            fromId: json.from_id,
-            fromName: json.from_name,
-            fromCompany: json.from_company,
-            toType: json.to_type,
-            toId: json.to_id,
-            toName: json.to_name,
-            toCompany: json.to_company,
-            sendTime: json.send_time,
-            read: json.is_read === 1,
-            sign: sign
-         };
-       } catch (innerE) {
-         // ignore
-       }
+  // Fallback: Try Protobuf decoding
+  if (Buffer.isBuffer(body)) {
+    try {
+      // Check if body starts with $UUID... (Legacy/Custom framing?)
+      // If so, we might need to strip it.
+      // But let's try to decode the whole body first.
+      const message = emb.message.format.Message.decode(body);
+      return convertProtoMessage(message);
+    } catch (e) {
+      // Maybe it has a prefix?
+      // Log observed: $UUID...
+      // $ is 0x24.
+      if (body[0] === 0x24) { // '$'
+         // Try to find where the actual protobuf starts.
+         // A UUID is 36 chars.
+         // $ + 36 chars = 37 bytes.
+         // Maybe the protobuf starts after that?
+         if (body.length > 37) {
+            try {
+               const protoBody = body.subarray(37);
+               const message = emb.message.format.Message.decode(protoBody);
+               return convertProtoMessage(message);
+            } catch (innerE) {
+               // Ignore
+            }
+         }
+      }
     }
+  }
+
+  // Fallback: return raw content for debugging
+  // Try to extract ID if it looks like a UUID (e.g. $UUID...)
+  let id = 'unknown';
+  const uuidMatch = jsonStr.match(/\$([0-9a-fA-F-]{36})/);
+  if (uuidMatch) {
+    id = uuidMatch[1];
+  }
+
+  return {
+    id: id,
+    type: 1, // TEXT
+    content: jsonStr, // Return original string
+    fromType: 1,
+    fromId: 'unknown',
+    toType: 1,
+    toId: 'unknown',
+    sendTime: Date.now(),
+    read: false
+  };
+}
 
-    // Fallback: return raw content for debugging
-    return {
-      id: 'unknown',
-      type: 1, // TEXT
-      content: jsonStr, // Return original string
-      fromType: 1,
-      fromId: 'unknown',
-      toType: 1,
-      toId: 'unknown',
-      sendTime: Date.now(),
-      read: false
-    };
+function convertProtoMessage(protoMsg: any): EmbMessage {
+  let content: string | Buffer = '';
+  if (protoMsg.content && protoMsg.content.length > 0) {
+      // Protobuf content is bytes.
+      // Keep it as Buffer
+      content = Buffer.from(protoMsg.content);
+
+      // Decrypt content using bitwise NOT (~)
+      // This matches the encryption logic provided: raw -> ~ -> Base64 (for JSON)
+      // For Protobuf bytes, we just reverse the ~ operation.
+      for (let i = 0; i < content.length; i++) {
+        content[i] = ~content[i];
+      }
   }
+
+  return {
+    id: protoMsg.msgId || 'unknown',
+    type: protoMsg.type || 1,
+    content: content,
+    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,
+    toId: protoMsg.to?.toId || 'unknown',
+    toName: protoMsg.to?.toName || undefined,
+    toCompany: protoMsg.to?.toCompany || undefined,
+    sendTime: typeof protoMsg.sendTime === 'number' ? protoMsg.sendTime : (protoMsg.sendTime?.toNumber() || Date.now()),
+    read: protoMsg.options?.isRead || false,
+    // Add other fields if needed
+  };
 }

package/src/link/types.ts

@@ -3,7 +3,7 @@ import { MsgType, ParticipantType } from './constants.js';
 export interface EmbMessage {
   id: string;
   type: MsgType;
-  content: string; // Encrypted or plain? Java code suggests encryption.
+  content: string | Buffer; // Encrypted or plain? Java code suggests encryption.
   fromType: ParticipantType;
   fromId: string;
   fromName?: string;
@@ -14,7 +14,7 @@ export interface EmbMessage {
   toCompany?: string;
   sendTime: number;
   read: boolean;
-  sign?: string;
+  sign?: boolean | string;
 }
 
 export interface ClientVerifyInfo {

package/src/types.ts

@@ -3,8 +3,10 @@ import { ClientVerifyInfo } from "./link/types.js";
 
 export interface LinkConfig {
   host: string;
-  port: number;
+  // port: number; // merged into host
   accessToken: string;
+  refreshToken?: string;
+  ssoUrl?: string;
   verifyInfo?: Partial<ClientVerifyInfo>;
   heartbeatIntervalMs?: number;
   protocol?: "tcp" | "ws"; // Default tcp