wtt-connect 0.1.0

package/src/wtt-api.js

@@ -0,0 +1,79 @@
+import { apiUrl } from './config.js';
+import { log } from './logger.js';
+
+export class WTTApi {
+  constructor(config) {
+    this.config = config;
+    this.base = apiUrl(config.wttBaseUrl);
+  }
+
+  headers(extra = {}) {
+    return { ...(this.config.httpToken ? { Authorization: `Bearer ${this.config.httpToken}` } : {}), ...extra };
+  }
+
+  agentHeaders(extra = {}) {
+    return { ...(this.config.token ? { 'X-Agent-Token': this.config.token } : {}), ...extra };
+  }
+
+  async request(method, path, { json, headers } = {}) {
+    const r = await fetch(`${this.base}${path}`, {
+      method,
+      headers: this.headers(json ? { 'content-type': 'application/json', ...(headers || {}) } : (headers || {})),
+      body: json ? JSON.stringify(json) : undefined,
+    });
+    if (!r.ok) throw new Error(`${method} ${path} failed: ${r.status} ${await r.text()}`);
+    return r.status === 204 ? null : r.json();
+  }
+
+  async registerAgent(displayName = 'wtt-connect') {
+    return this.request('POST', '/agents/register', { json: { display_name: displayName, platform: 'wtt-connect' } });
+  }
+
+  async claimCode(agentId = this.config.agentId, token = this.config.token) {
+    try {
+      return await this.request('POST', `/agents/claim-code?agent_id=${encodeURIComponent(agentId)}`, {
+        headers: token ? { 'X-Agent-Token': token } : {},
+      });
+    } catch {
+      return this.request('POST', `/agents/claim-code?agent_id=${encodeURIComponent(agentId)}`);
+    }
+  }
+
+  async getTask(taskId) {
+    try {
+      return await this.request('GET', `/tasks/${taskId}`);
+    } catch (err) {
+      if (String(err.message).includes(' 404 ')) return null;
+      log('warn', 'get_task failed', { taskId, error: err.message });
+      return null;
+    }
+  }
+
+  async patchTask(taskId, payload) {
+    if (this.config.dryRun) {
+      log('info', 'dry-run patch task', { taskId, fields: Object.keys(payload).join(',') });
+      return null;
+    }
+    try {
+      return await this.request('PATCH', `/tasks/${taskId}`, { json: payload });
+    } catch (err) {
+      log('warn', 'patch_task failed', { taskId, error: err.message, fields: Object.keys(payload).join(',') });
+      return null;
+    }
+  }
+
+  async createTask(payload) {
+    return this.request('POST', '/tasks', { json: payload });
+  }
+
+  async runTask(taskId, payload = {}) {
+    return this.request('POST', `/tasks/${taskId}/run`, { json: payload });
+  }
+
+  async completeArenaJudgeJob(jobId, result) {
+    return this.request('POST', `/arena/judge/jobs/${encodeURIComponent(jobId)}/result`, {
+      headers: this.agentHeaders(),
+      json: { agent_id: this.config.agentId, result },
+    });
+  }
+}

package/src/wtt-client.js

@@ -0,0 +1,144 @@
+import { log } from './logger.js';
+
+export class WTTClient {
+  constructor(config, onEvent, runtimeInfoProvider = null) {
+    this.config = config;
+    this.onEvent = onEvent;
+    this.runtimeInfoProvider = runtimeInfoProvider;
+    this.ws = null;
+    this.pending = new Map();
+    this.closed = false;
+  }
+
+  async connectForever() {
+    let backoff = 1000;
+    while (!this.closed) {
+      try {
+        await this.connectOnce();
+        backoff = 1000;
+      } catch (err) {
+        if (this.closed) return;
+        log('warn', 'WTT websocket disconnected', { error: err?.message || err, reconnectMs: backoff });
+        await sleep(backoff);
+        backoff = Math.min(backoff * 2, 30000);
+      }
+    }
+  }
+
+  async connectOnce() {
+    if (!globalThis.WebSocket) throw new Error('Node.js global WebSocket is unavailable; use Node >=22');
+    log('info', 'connecting WTT websocket', { url: this.config.wttWsUrl, agentId: this.config.agentId });
+    const ws = new WebSocket(this.config.wttWsUrl);
+    this.ws = ws;
+    await onceOpen(ws, 15000);
+    if (this.config.token) {
+      await this.sendJson({ action: 'auth', request_id: rid('auth'), token: this.config.token });
+    }
+    log('info', 'WTT websocket connected');
+    await this.sendHeartbeat();
+    const heartbeat = setInterval(() => {
+      if (ws.readyState !== WebSocket.OPEN) return;
+      const runtime = this.runtimeInfoProvider ? this.runtimeInfoProvider() : null;
+      if (runtime) {
+        ws.send(JSON.stringify({ action: 'heartbeat', runtime }));
+      } else {
+        ws.send('ping');
+      }
+    }, Math.max(5, this.config.heartbeatSeconds) * 1000);
+    try {
+      await new Promise((resolve, reject) => {
+        ws.addEventListener('message', (event) => this.handleMessage(String(event.data)).catch(reject));
+        ws.addEventListener('error', () => reject(new Error('websocket error')));
+        ws.addEventListener('close', () => resolve());
+      });
+    } finally {
+      clearInterval(heartbeat);
+      if (this.ws === ws) this.ws = null;
+      for (const [, p] of this.pending) p.reject(new Error('WTT websocket closed'));
+      this.pending.clear();
+    }
+  }
+
+  async close() {
+    this.closed = true;
+    if (this.ws) this.ws.close();
+  }
+
+  async handleMessage(raw) {
+    if (raw === 'ping') {
+      await this.sendHeartbeat();
+      return;
+    }
+    if (raw === 'pong') return;
+    let msg;
+    try { msg = JSON.parse(raw); } catch { log('debug', 'non-json WTT message', { raw }); return; }
+    if (msg.type === 'action_result') {
+      const pending = this.pending.get(msg.request_id);
+      if (pending) {
+        this.pending.delete(msg.request_id);
+        msg.ok ? pending.resolve(msg.data) : pending.reject(new Error(String(msg.error || 'action failed')));
+      }
+      return;
+    }
+    await this.onEvent(msg);
+  }
+
+  async sendJson(payload) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) throw new Error('WTT websocket is not connected');
+    this.ws.send(JSON.stringify(payload));
+  }
+
+  async sendHeartbeat() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    const runtime = this.runtimeInfoProvider ? this.runtimeInfoProvider() : null;
+    if (runtime) {
+      await this.sendJson({ action: 'heartbeat', runtime });
+    } else {
+      this.ws.send('ping');
+    }
+  }
+
+  async action(action, payload = {}, timeoutMs = 20000) {
+    const requestId = rid(action);
+    const promise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        reject(new Error(`WTT action timeout: ${action}`));
+      }, timeoutMs);
+      this.pending.set(requestId, {
+        resolve: (v) => { clearTimeout(timer); resolve(v); },
+        reject: (e) => { clearTimeout(timer); reject(e); },
+      });
+    });
+    await this.sendJson({ action, request_id: requestId, ...payload });
+    return promise;
+  }
+
+  async publish(topicId, content, semanticType = 'CHAT_REPLY') {
+    if (this.config.dryRun) {
+      log('info', 'dry-run publish', { topicId, semanticType, chars: content.length });
+      return null;
+    }
+    return this.action('publish', { topic_id: topicId, content, content_type: 'text', semantic_type: semanticType });
+  }
+
+  async typing(topicId, state) {
+    try { await this.action('typing', { topic_id: topicId, state, ttl_ms: 6000 }, 5000); } catch {}
+  }
+}
+
+function rid(prefix) {
+  return `${prefix}-${crypto.randomUUID().slice(0, 10)}`;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function onceOpen(ws, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('websocket open timeout')), timeoutMs);
+    ws.addEventListener('open', () => { clearTimeout(timer); resolve(); }, { once: true });
+    ws.addEventListener('error', () => { clearTimeout(timer); reject(new Error('websocket open failed')); }, { once: true });
+  });
+}