@insta-dev01/intclaw 1.0.9 → 1.0.11

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "intclaw",
   "name": "IntClaw Plugin",
   "description": "OpenClaw plugin for IntClaw services - WebSocket-based channel integration for Community Platform, Message Channel, and Agent Collaboration Engine",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "kind": "channel",
   "channels": ["intclaw"],
   "configSchema": {
@@ -14,13 +14,13 @@
         "description": "Enable/disable the IntClaw channel",
         "default": true
       },
-      "apiKey": {
+      "appKey": {
         "type": "string",
-        "description": "API key for authentication with IntClaw server"
+        "description": "APP key for authentication with IntClaw server"
       },
-      "apiSecret": {
+      "appSecret": {
         "type": "string",
-        "description": "API secret for authentication with IntClaw server"
+        "description": "APP secret for authentication with IntClaw server"
       },
       "shadowInstance": {
         "type": "boolean",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@insta-dev01/intclaw",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "type": "module",
   "description": "OpenClaw plugin for IntClaw services - WebSocket-based channel integration for Community Platform, Message Channel, and Agent Collaboration Engine",
   "main": "src/index.js",
@@ -8,7 +8,8 @@
     "test": "node --test src/__tests__/**/*.test.js",
     "test:watch": "node --test --watch src/__tests__/**/*.test.js",
     "prepublishOnly": "pnpm test",
-    "publish:public": "npm publish --access public --registry=https://registry.npmjs.org/"
+    "publish:public": "npm publish --access public --registry=https://registry.npmjs.org/",
+    "tologin":"npm login --registry=https://registry.npmjs.org/"
   },
   "keywords": [
     "openclaw",

package/src/channel/intclaw_channel.js

@@ -0,0 +1,155 @@
+/**
+ * ---
+ * status: active
+ * birth_time: "2026-03-19T09:42:00Z"
+ * original_intent: "Provide IntClaw bidirectional websocket channel and proxy messages to OpenClaw gateway using chunked streaming"
+ * version_count: 1
+ * ---
+ */
+
+import WebSocket from 'ws';
+
+export async function start_intclaw_channel(gateway, config) {
+  const ws_url = 'wss://claw-dev.int-os.com/user-ws/';
+  
+  const ws_conn = new WebSocket(ws_url, {
+    headers: {
+      'X-App-Key': config.appKey,
+      'X-App-Secret': config.appSecret
+    }
+  });
+
+  ws_conn.on('open', () => {
+    const auth_payload = {
+      type: 'auth_request',
+      app_key: config.appKey,
+      timestamp: Date.now()
+    };
+    ws_conn.send(JSON.stringify(auth_payload));
+  });
+
+  ws_conn.on('message', async (data) => {
+    try {
+      const msg = JSON.parse(data.toString());
+      
+      if (msg.type === 'auth_response') {
+        if (msg.success && gateway.notifyChannelReady) {
+          await gateway.notifyChannelReady('intclaw');
+        }
+      } else if (msg.type === 'incoming_message') {
+        process_incoming_message(msg.payload, ws_conn, config);
+      } else if (msg.type === 'ping') {
+        ws_conn.send(JSON.stringify({ type: 'pong' }));
+      }
+    } catch (err) {
+      console.error(JSON.stringify({ error: "failed_to_handle_msg", reason: err.message }));
+    }
+  });
+
+  ws_conn.on('error', (err) => {
+    console.error(JSON.stringify({ error: "ws_error", reason: err.message }));
+  });
+
+  ws_conn.on('close', (code, reason) => {
+    console.log(JSON.stringify({ event: "ws_closed", code, reason: reason?.toString() }));
+    setTimeout(() => {
+      start_intclaw_channel(gateway, config);
+    }, 5000);
+  });
+  
+  return ws_conn;
+}
+
+async function process_incoming_message(payload, ws_conn, config) {
+  const session_context = {
+    channel: 'intclaw',
+    account_id: payload.accountId || 'default',
+    chat_type: payload.peerKind || 'direct',
+    peer_id: payload.peerId
+  };
+  
+  const session_key = JSON.stringify(session_context);
+  const user_content = payload.text;
+  
+  try {
+    for await (const chunk of stream_from_gateway(user_content, session_key, config)) {
+      send_stream_chunk(ws_conn, payload, chunk, false);
+    }
+    // send end of stream marker
+    send_stream_chunk(ws_conn, payload, "", true);
+  } catch (err) {
+    console.error(JSON.stringify({ error: "gateway_stream_failed", reason: err.message }));
+  }
+}
+
+async function* stream_from_gateway(user_content, session_key, config) {
+  const port = config.gatewayPort || 18789;
+  const url = `http://127.0.0.1:${port}/v1/chat/completions`;
+  
+  const resp = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-OpenClaw-Agent-Id': 'main'
+    },
+    body: JSON.stringify({
+      model: 'main',
+      messages: [{ role: 'user', content: user_content }],
+      stream: true,
+      user: session_key
+    })
+  });
+  
+  if (!resp.ok) {
+    const err_text = await resp.text();
+    throw new Error(`status_${resp.status}_${err_text}`);
+  }
+  
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+    
+    for (const line of lines) {
+      if (!line.startsWith('data: ')) continue;
+      const data = line.slice(6).trim();
+      if (data === '[DONE]') return;
+      
+      try {
+        const chunk_obj = JSON.parse(data);
+        const content = chunk_obj.choices?.[0]?.delta?.content;
+        if (content) yield content;
+      } catch (e) {
+        // partial chunk, ignore
+      }
+    }
+  }
+}
+
+function send_stream_chunk(ws_conn, incoming_payload, chunk_text, is_done) {
+  if (ws_conn.readyState !== WebSocket.OPEN) return;
+  
+  const out_msg = {
+    type: 'outgoing_message',
+    payload: {
+      id: `intclaw_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      account_id: incoming_payload.accountId || 'default',
+      peer_id: incoming_payload.peerId,
+      peer_kind: incoming_payload.peerKind,
+      text: chunk_text,
+      reply_to_id: incoming_payload.id,
+      timestamp: Date.now(),
+      is_chunk: true,
+      is_done: is_done
+    }
+  };
+  
+  ws_conn.send(JSON.stringify(out_msg));
+}

package/src/index.js

@@ -1,40 +1,23 @@
 /**
- * IntClaw Channel Plugin for OpenClaw
- *
- * This plugin provides a WebSocket-based channel for connecting to IntClaw services.
- * It handles bidirectional message flow between OpenClaw and IntClaw servers.
+ * ---
+ * status: active
+ * birth_time: "2026-03-19T09:42:00Z"
+ * original_intent: "Entry point for IntClaw plugin"
+ * version_count: 2
+ * ---
  */
 
-import { IntClawChannel } from './channel/IntClawChannel.js';
+import { start_intclaw_channel } from './channel/intclaw_channel.js';
 
-/**
- * Register the IntClaw channel with OpenClaw
- * @param {Object} gateway - OpenClaw gateway instance
- * @param {Object} config - Channel configuration
- * @returns {Promise<void>}
- */
-export async function registerChannel(gateway, config) {
-  const channel = new IntClawChannel(gateway, config);
-  await channel.start();
-}
-
-/**
- * Plugin initialization function (OpenClaw entry point)
- * @param {Object} gateway - OpenClaw gateway instance
- * @param {Object} config - Plugin configuration
- * @returns {Promise<void>}
- */
 export async function register(gateway, config) {
-  // Skip if explicitly disabled
   if (config?.enabled === false) {
     return;
   }
 
-  // Skip if required configuration is missing
-  if (!config?.wsUrl || !config?.apiKey) {
-    console.log('[IntClaw] Configuration missing (wsUrl, apiKey)');
+  if (!config?.appKey || !config?.appSecret) {
+    console.log(JSON.stringify({ error: "missing_config_keys" }));
     return;
   }
 
-  await registerChannel(gateway, config);
+  await start_intclaw_channel(gateway, config);
 }

package/src/channel/IntClawChannel.js

@@ -1,309 +0,0 @@
-/**
- * IntClaw Channel Implementation
- *
- * Handles WebSocket connection and message routing for IntClaw services.
- */
-
-const CHANNEL_ID = 'intclaw';
-const DEFAULT_WS_URL = 'wss://claw-message.int-os.com';
-const DEFAULT_RECONNECT_INTERVAL = 5000;
-
-/**
- * IntClaw message types
- */
-export const MessageTypes = {
-  // Incoming messages from IntClaw server
-  INCOMING_MESSAGE: 'incoming_message',
-  // Outgoing messages to IntClaw server
-  OUTGOING_MESSAGE: 'outgoing_message',
-  // Connection status
-  CONNECTION_STATUS: 'connection_status',
-  // Authentication
-  AUTH_REQUEST: 'auth_request',
-  AUTH_RESPONSE: 'auth_response',
-  // Heartbeat
-  PING: 'ping',
-  PONG: 'pong',
-};
-
-/**
- * IntClaw peer kinds
- */
-export const PeerKind = {
-  DIRECT: 'direct',
-  GROUP: 'group',
-};
-
-export class IntClawChannel {
-  #gateway;
-  #config;
-  #ws = null;
-  #reconnectTimer = null;
-  #isShuttingDown = false;
-  #isAuthenticated = false;
-
-  constructor(gateway, config) {
-    this.#gateway = gateway;
-    this.#config = config;
-  }
-
-  /**
-   * Start the channel
-   */
-  async start() {
-    this.#log('info', 'Starting IntClaw channel...');
-
-    if (!this.#config.apiKey) {
-      throw new Error('IntClaw channel requires apiKey in configuration');
-    }
-
-    await this.#connect();
-  }
-
-  /**
-   * Stop the channel
-   */
-  async stop() {
-    this.#log('info', 'Stopping IntClaw channel...');
-    this.#isShuttingDown = true;
-
-    if (this.#reconnectTimer) {
-      clearTimeout(this.#reconnectTimer);
-      this.#reconnectTimer = null;
-    }
-
-    if (this.#ws) {
-      this.#ws.close();
-      this.#ws = null;
-    }
-
-    this.#log('info', 'IntClaw channel stopped');
-  }
-
-  /**
-   * Connect to IntClaw WebSocket server
-   */
-  async #connect() {
-    if (this.#isShuttingDown) {
-      return;
-    }
-
-    try {
-      const wsUrl = this.#config.wsUrl || DEFAULT_WS_URL;
-      this.#log('info', `Connecting to IntClaw server: ${wsUrl}`);
-
-      // Import ws module dynamically
-      const WebSocket = (await import('ws')).default;
-
-      this.#ws = new WebSocket(wsUrl, {
-        headers: {
-          'X-API-Key': this.#config.apiKey,
-        },
-      });
-
-      this.#ws.on('open', () => this.#onOpen());
-      this.#ws.on('message', (data) => this.#onMessage(data));
-      this.#ws.on('error', (error) => this.#onError(error));
-      this.#ws.on('close', (code, reason) => this.#onClose(code, reason));
-
-    } catch (error) {
-      this.#log('error', `Connection failed: ${error.message}`);
-      this.#scheduleReconnect();
-    }
-  }
-
-  /**
-   * Handle WebSocket open event
-   */
-  #onOpen() {
-    this.#log('info', 'Connected to IntClaw server');
-
-    // Send authentication request
-    this.#send({
-      type: MessageTypes.AUTH_REQUEST,
-      apiKey: this.#config.apiKey,
-      timestamp: Date.now(),
-    });
-  }
-
-  /**
-   * Handle WebSocket message event
-   */
-  async #onMessage(data) {
-    try {
-      const message = JSON.parse(data.toString());
-      this.#log('debug', `Received message type: ${message.type}`);
-
-      switch (message.type) {
-        case MessageTypes.AUTH_RESPONSE:
-          await this.#handleAuthResponse(message);
-          break;
-
-        case MessageTypes.INCOMING_MESSAGE:
-          await this.#handleIncomingMessage(message);
-          break;
-
-        case MessageTypes.PING:
-          this.#send({ type: MessageTypes.PONG });
-          break;
-
-        case MessageTypes.PONG:
-          // Pong received, connection is alive
-          break;
-
-        default:
-          this.#log('warn', `Unknown message type: ${message.type}`);
-      }
-    } catch (error) {
-      this.#log('error', `Failed to handle message: ${error.message}`);
-    }
-  }
-
-  /**
-   * Handle authentication response
-   */
-  async #handleAuthResponse(message) {
-    if (message.success) {
-      this.#isAuthenticated = true;
-      this.#log('info', 'Authenticated with IntClaw server');
-
-      // Notify gateway that channel is ready
-      if (this.#gateway?.notifyChannelReady) {
-        await this.#gateway.notifyChannelReady(CHANNEL_ID);
-      }
-    } else {
-      this.#log('error', `Authentication failed: ${message.error || 'Unknown error'}`);
-      this.#ws.close();
-    }
-  }
-
-  /**
-   * Handle incoming message from IntClaw server
-   */
-  async #handleIncomingMessage(message) {
-    if (!this.#isAuthenticated) {
-      this.#log('warn', 'Ignoring message: not authenticated');
-      return;
-    }
-
-    const { payload } = message;
-
-    // Normalize message for OpenClaw gateway
-    const normalizedMessage = {
-      channel: CHANNEL_ID,
-      accountId: payload.accountId || 'default',
-      peer: {
-        kind: payload.peerKind || PeerKind.DIRECT,
-        id: payload.peerId,
-        name: payload.peerName,
-      },
-      text: payload.text,
-      timestamp: payload.timestamp || Date.now(),
-      id: payload.id,
-      threadId: payload.threadId,
-      replyToId: payload.replyToId,
-    };
-
-    // Send to gateway for processing
-    if (this.#gateway?.handleChannelMessage) {
-      await this.#gateway.handleChannelMessage(normalizedMessage);
-    } else {
-      this.#log('warn', 'Gateway does not support handleChannelMessage');
-    }
-  }
-
-  /**
-   * Handle WebSocket error event
-   */
-  #onError(error) {
-    this.#log('error', `WebSocket error: ${error.message}`);
-  }
-
-  /**
-   * Handle WebSocket close event
-   */
-  #onClose(code, reason) {
-    this.#log('info', `Connection closed: ${code} - ${reason || 'No reason'}`);
-    this.#isAuthenticated = false;
-
-    if (!this.#isShuttingDown) {
-      this.#scheduleReconnect();
-    }
-  }
-
-  /**
-   * Schedule reconnection attempt
-   */
-  #scheduleReconnect() {
-    const interval = this.#config.reconnectInterval || DEFAULT_RECONNECT_INTERVAL;
-
-    this.#log('info', `Reconnecting in ${interval}ms...`);
-
-    this.#reconnectTimer = setTimeout(() => {
-      this.#connect();
-    }, interval);
-  }
-
-  /**
-   * Send message to IntClaw server
-   */
-  #send(message) {
-    if (this.#ws && this.#ws.readyState === 1 /* OPEN */) {
-      this.#ws.send(JSON.stringify(message));
-    } else {
-      this.#log('warn', 'Cannot send message: WebSocket not connected');
-    }
-  }
-
-  /**
-   * Send message action
-   */
-  async send(message) {
-    const payload = {
-      type: MessageTypes.OUTGOING_MESSAGE,
-      payload: {
-        id: message.id || this.#generateMessageId(),
-        accountId: message.accountId || 'default',
-        peerId: message.peer.id,
-        peerKind: message.peer.kind,
-        text: message.text,
-        threadId: message.threadId,
-        replyToId: message.replyToId,
-        timestamp: Date.now(),
-      },
-    };
-
-    this.#send(payload);
-  }
-
-  /**
-   * Generate unique message ID
-   */
-  #generateMessageId() {
-    return `intclaw_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  /**
-   * Log message
-   */
-  #log(level, message) {
-    const logMessage = `[IntClaw Channel] ${message}`;
-
-    switch (level) {
-      case 'error':
-        console.error(logMessage);
-        break;
-      case 'warn':
-        console.warn(logMessage);
-        break;
-      case 'debug':
-        // Only log debug in development
-        if (process.env.NODE_ENV === 'development') {
-          console.log(logMessage);
-        }
-        break;
-      default:
-        console.log(logMessage);
-    }
-  }
-}