@openagents-org/agent-launcher 0.1.17 → 0.2.1

package/src/tui.js

@@ -85,6 +85,39 @@ function loadAgentRows(connector) {
         workspace = agent.network;
       }
     }
+    // Check if agent type needs configuration (API key etc.)
+    let notReadyMsg = '';
+    try {
+      const agentType = agent.type || 'openclaw';
+      const entry = connector.registry.getEntry(agentType);
+      if (entry && entry.check_ready) {
+        const cr = entry.check_ready;
+        let isReady = false;
+        // Check saved env
+        if (cr.saved_env_key) {
+          const saved = connector.env.load(agentType);
+          if (saved[cr.saved_env_key]) isReady = true;
+        }
+        // Check process env vars
+        if (!isReady && cr.env_vars) {
+          for (const v of cr.env_vars) {
+            if (process.env[v]) { isReady = true; break; }
+          }
+        }
+        // Check creds file (for claude)
+        if (!isReady && cr.creds_file) {
+          const credsPath = cr.creds_file.replace('~', process.env.HOME || process.env.USERPROFILE || '');
+          try {
+            if (fs.existsSync(credsPath)) {
+              const creds = JSON.parse(fs.readFileSync(credsPath, 'utf-8'));
+              if (cr.creds_key && creds[cr.creds_key]) isReady = true;
+            }
+          } catch {}
+        }
+        if (!isReady) notReadyMsg = cr.not_ready_message || 'Not configured';
+      }
+    } catch {}
+
     return {
       name: agent.name,
       type: agent.type || 'openclaw',
@@ -93,6 +126,7 @@ function loadAgentRows(connector) {
       path: agent.path || '',
       network: agent.network || '',
       lastError: info.last_error || '',
+      notReadyMsg,
       configured: true,
     };
   });
@@ -308,7 +342,8 @@ function createTUI() {
         const state = stateMarkup(r.state, !!r.workspace);
         const ws = r.workspace || '{gray-fg}-{/gray-fg}';
         const pathInfo = r.path ? `{gray-fg} ${r.path}{/gray-fg}` : '';
-        return `  ${r.name.padEnd(22)} ${r.type.padEnd(14)} ${state.padEnd(30)} ${ws}${pathInfo}`;
+        const warning = r.notReadyMsg ? ` {yellow-fg}⚠ ${r.notReadyMsg}{/yellow-fg}` : '';
+        return `  ${r.name.padEnd(22)} ${r.type.padEnd(14)} ${state.padEnd(30)} ${ws}${pathInfo}${warning}`;
       });
       agentList.setItems(items);
     }
@@ -328,7 +363,20 @@ function createTUI() {
     const dot = pid ? `{green-fg}\u25CF{/green-fg}` : `{gray-fg}\u25CB{/gray-fg}`;
     const state = pid ? 'Daemon running' : 'Daemon idle';
     const count = agentRows.length;
-    header.setContent(`  ${dot} ${state}  {gray-fg}|{/gray-fg}  ${count} agent${count !== 1 ? 's' : ''} configured`);
+
+    // Show installed runtimes
+    let installed = [];
+    try {
+      const catalog = loadCatalog(connector);
+      installed = catalog.filter(e => e.installed).map(e => e.name);
+    } catch {}
+    const installedStr = installed.length
+      ? `  {gray-fg}|{/gray-fg}  {green-fg}${installed.join(', ')}{/green-fg} installed`
+      : '';
+
+    header.setContent(
+      `  ${dot} ${state}  {gray-fg}|{/gray-fg}  ${count} agent${count !== 1 ? 's' : ''} configured${installedStr}`
+    );
   }
 
   // Update footer when selection changes
@@ -542,6 +590,8 @@ function createTUI() {
     }).then(() => {
       installLog.log('');
       installLog.log(`{green-fg}\u2713 ${entry.name} installed successfully!{/green-fg}`);
+      installLog.log('');
+      installLog.log(`{cyan-fg}Press c to create a ${entry.name} agent, or Esc to go back.{/cyan-fg}`);
       logPanel.setLabel(` {bold}{green-fg}Install Complete{/green-fg}{/bold} `);
       log(`{green-fg}\u2713{/green-fg} ${entry.name} installed`);
       const idx = catalog.findIndex(c => c.name === entry.name);
@@ -550,6 +600,36 @@ function createTUI() {
       onDone();
       list.focus();
       screen.render();
+
+      // Listen for 'c' to create agent from just-installed type
+      const onCreateKey = (ch) => {
+        if (ch === 'c') {
+          screen.unkey(['c', 'escape'], onCreateKey);
+          // Go back to main and start agent creation flow
+          list.emit('keypress', null, { name: 'escape' });
+          setTimeout(() => {
+            showStartAgentScreen(entry.name, (result) => {
+              try {
+                connector.addAgent({ name: result.name, type: result.type, path: result.path });
+                log(`{green-fg}\u2713{/green-fg} Created agent {cyan-fg}${result.name}{/cyan-fg} (${result.type})`);
+                const pid = connector.getDaemonPid();
+                if (!pid) {
+                  connector.startDaemon();
+                  log('{green-fg}\u2713{/green-fg} Daemon starting...');
+                } else {
+                  signalDaemonReload();
+                }
+              } catch (e) {
+                log(`{red-fg}\u2717{/red-fg} ${e.message}`);
+              }
+              setTimeout(refreshAgentTable, 3000);
+            });
+          }, 200);
+        } else {
+          screen.unkey(['c', 'escape'], onCreateKey);
+        }
+      };
+      screen.key(['c', 'escape'], onCreateKey);
     }).catch((e) => {
       installLog.log('');
       installLog.log(`{red-fg}\u2717 Failed: ${e.message}{/red-fg}`);
@@ -652,6 +732,7 @@ function createTUI() {
     const pathInput = blessed.textbox({
       parent: dialog, top: 6, left: 2, width: 50, height: 3,
       border: { type: 'line' }, inputOnFocus: true,
+      value: defaultPath,
       style: { fg: 'white', bg: COLORS.surface, focus: { border: { fg: COLORS.accent } }, border: { fg: 'grey' } },
     });
 
@@ -667,6 +748,18 @@ function createTUI() {
     nameInput.focus();
     screen.render();
 
+    // Override _listener on textboxes to intercept Tab before it's inserted
+    const origNameListener = nameInput._listener.bind(nameInput);
+    nameInput._listener = function(ch, key) {
+      if (key.name === 'tab') { nameInput._done(null, nameInput.value); pathInput.focus(); return; }
+      return origNameListener(ch, key);
+    };
+    const origPathListener = pathInput._listener.bind(pathInput);
+    pathInput._listener = function(ch, key) {
+      if (key.name === 'tab') { pathInput._done(null, pathInput.value); nameInput.focus(); return; }
+      return origPathListener(ch, key);
+    };
+
     const close = () => {
       screen.remove(dialog);
       dialog.destroy();
@@ -768,7 +861,7 @@ function createTUI() {
       parent: box, bottom: 0, left: 0, width: '100%', height: 1,
       tags: true,
       style: { bg: COLORS.footerBg, fg: COLORS.footerFg },
-      content: ' {cyan-fg}Enter{/cyan-fg} Next field  {cyan-fg}Ctrl+S{/cyan-fg} Save  {cyan-fg}Ctrl+T{/cyan-fg} Test  {cyan-fg}Esc{/cyan-fg} Back',
+      content: ' {cyan-fg}Tab{/cyan-fg} Next  {cyan-fg}Ctrl+U{/cyan-fg} Clear  {cyan-fg}Ctrl+S{/cyan-fg} Save  {cyan-fg}Ctrl+T{/cyan-fg} Test  {cyan-fg}Esc{/cyan-fg} Back',
     });
 
     screen.append(box);
@@ -786,6 +879,35 @@ function createTUI() {
       });
     }
 
+    // Override _listener on textboxes to intercept Tab and Escape
+    for (let i = 0; i < inputs.length; i++) {
+      const orig = inputs[i]._listener.bind(inputs[i]);
+      const idx = i;
+      inputs[i]._listener = function(ch, key) {
+        if (key.name === 'tab' && inputs.length > 1) {
+          inputs[idx]._done(null, inputs[idx].value);
+          inputs[(idx + 1) % inputs.length].focus();
+          return;
+        }
+        if (key.name === 'escape') {
+          inputs[idx]._done(null, inputs[idx].value);
+          closeConfig();
+          return;
+        }
+        // Ctrl+U to clear field
+        if (key.ctrl && key.name === 'u') {
+          inputs[idx].value = '';
+          inputs[idx].setValue('');
+          screen.render();
+          return;
+        }
+        // Ctrl+S to save, Ctrl+T to test
+        if (key.ctrl && key.name === 's') { inputs[idx]._done(null, inputs[idx].value); doSave(); return; }
+        if (key.ctrl && key.name === 't') { inputs[idx]._done(null, inputs[idx].value); doTest(); return; }
+        return orig(ch, key);
+      };
+    }
+
     function gatherEnv() {
       const env = {};
       for (const input of inputs) {
@@ -1341,6 +1463,21 @@ function createTUI() {
   agentList.focus();
   refreshAgentTable();
   log('Welcome to {bold}OpenAgents{/bold}. Press {cyan-fg}i{/cyan-fg} to install agents, {cyan-fg}n{/cyan-fg} to create one.');
+
+  // Show installed runtimes that don't have any agent instances yet
+  try {
+    const catalog = loadCatalog(connector);
+    const installed = catalog.filter(e => e.installed).map(e => e.name);
+    const configuredTypes = new Set(agentRows.map(r => r.type));
+    const unused = installed.filter(t => !configuredTypes.has(t));
+    if (unused.length > 0) {
+      log(`{green-fg}\u2713{/green-fg} Installed: {bold}${unused.join(', ')}{/bold} — press {cyan-fg}n{/cyan-fg} to create an agent`);
+    }
+    if (installed.length === 0) {
+      log('{yellow-fg}!{/yellow-fg} No agent runtimes installed. Press {cyan-fg}i{/cyan-fg} to install one.');
+    }
+  } catch {}
+
   setInterval(refreshAgentTable, 5000);
   screen.render();
 }

package/src/workspace-client.js

@@ -106,7 +106,7 @@ class WorkspaceClient {
   }
 
   /**
-   * Post a task result via POST /v1/events.
+   * Post a raw event via POST /v1/events.
    */
   async sendEvent(workspaceId, event, token) {
     event.network = workspaceId;
@@ -118,20 +118,42 @@ class WorkspaceClient {
    * Send a chat message to a workspace channel.
    */
   async sendMessage(workspaceId, channelName, token, content, {
-    senderType = 'agent', senderName, messageType = 'chat', metadata,
+    senderType = 'agent', senderName, messageType = 'chat', metadata, attachments,
   } = {}) {
     const sourcePrefix = senderType === 'agent' ? 'openagents' : 'human';
     const source = senderName ? `${sourcePrefix}:${senderName}` : `${sourcePrefix}:unknown`;
 
+    const payload = { content, message_type: messageType };
+    if (attachments && attachments.length) payload.attachments = attachments;
+
     return this.sendEvent(workspaceId, {
       type: 'workspace.message.posted',
       source,
       target: `channel/${channelName}`,
-      payload: { content, message_type: messageType },
+      payload,
       metadata: metadata || {},
     }, token);
   }
 
+  /**
+   * Poll messages in a channel via GET /v1/events.
+   * @returns {Array} message-compatible objects
+   */
+  async pollMessages(workspaceId, channelName, token, { after, limit = 50 } = {}) {
+    const params = new URLSearchParams({
+      network: workspaceId,
+      channel: channelName,
+      type: 'workspace.message',
+      limit: String(limit),
+    });
+    if (after) params.set('after', after);
+
+    const data = await this._get(`/v1/events?${params}`, this._wsHeaders(token));
+    const result = data.data || data;
+    const events = (result && result.events) || [];
+    return events.map((e) => this._eventToMessage(e));
+  }
+
   /**
    * Poll for pending messages targeted at an agent via GET /v1/events.
    * Returns { messages, cursor } where cursor is the last event ID.
@@ -180,27 +202,41 @@ class WorkspaceClient {
   }
 
   /**
-   * Get session/channel info via GET /v1/sessions/{channelName}.
+   * Get session/channel info via GET /v1/workspaces/{id}/channels/{name}.
    */
   async getSession(workspaceId, channelName, token) {
     try {
-      const params = new URLSearchParams({ network: workspaceId });
-      const data = await this._get(`/v1/sessions/${channelName}?${params}`, this._wsHeaders(token));
-      return (data.data || data) || {};
+      const data = await this._get(
+        `/v1/workspaces/${workspaceId}/channels/${channelName}`,
+        this._wsHeaders(token),
+      );
+      const result = data.data || data;
+      return {
+        sessionId: result.name || channelName,
+        title: result.title || channelName,
+        titleManuallySet: result.titleManuallySet || false,
+        resumeFrom: result.resumeFrom || null,
+        status: result.status || 'active',
+      };
     } catch {
-      return {};
+      return { sessionId: channelName, title: channelName, status: 'active' };
     }
   }
 
   /**
-   * Update session/channel info via PUT /v1/sessions/{channelName}.
+   * Update session/channel info via PATCH /v1/workspaces/{id}/channels/{name}.
    */
-  async updateSession(workspaceId, channelName, token, { title, autoTitle } = {}) {
-    const body = { network: workspaceId };
+  async updateSession(workspaceId, channelName, token, { title, status, autoTitle } = {}) {
+    const body = {};
     if (title !== undefined) body.title = title;
+    if (status !== undefined) body.status = status;
     if (autoTitle !== undefined) body.auto_title = autoTitle;
     try {
-      await this._post(`/v1/sessions/${channelName}`, body, this._wsHeaders(token));
+      await this._patch(
+        `/v1/workspaces/${workspaceId}/channels/${channelName}`,
+        body,
+        this._wsHeaders(token),
+      );
     } catch {}
   }
 
@@ -211,7 +247,7 @@ class WorkspaceClient {
     try {
       const params = new URLSearchParams({
         network: workspaceId,
-        type: 'workspace.control',
+        type: 'workspace.agent.control',
         limit: '10',
       });
       if (after) params.set('after', after);
@@ -219,14 +255,165 @@ class WorkspaceClient {
       const result = data.data || data;
       const events = (result && result.events) || [];
       return events.filter((e) => {
-        const targets = (e.metadata || {}).target_agents || [];
-        return !targets.length || targets.includes(agentName);
+        const target = e.target || '';
+        return target === `openagents:${agentName}`;
       });
     } catch {
       return [];
     }
   }
 
+  /**
+   * Get workspace agents via GET /v1/discover.
+   * @returns {Array<{ agentName, role, status }>}
+   */
+  async getAgents(workspaceId, token) {
+    const params = new URLSearchParams({ network: workspaceId });
+    const data = await this._get(`/v1/discover?${params}`, this._wsHeaders(token));
+    const result = data.data || data;
+    const agents = (result && result.agents) || [];
+    return agents.map((a) => ({
+      agentName: (a.address || '').replace('openagents:', ''),
+      role: a.role || 'member',
+      status: a.status || 'offline',
+    }));
+  }
+
+  // ── File methods ──
+
+  /**
+   * Upload a file via POST /v1/files/base64.
+   */
+  async uploadFile(workspaceId, token, filename, contentBase64, {
+    contentType = 'application/octet-stream', source = 'human:user', channelName,
+  } = {}) {
+    const body = {
+      filename,
+      content_base64: contentBase64,
+      content_type: contentType,
+      network: workspaceId,
+      source,
+    };
+    if (channelName) body.channel_name = channelName;
+
+    const data = await this._post('/v1/files/base64', body, this._wsHeaders(token), 60000);
+    return data.data || data;
+  }
+
+  /**
+   * List files via GET /v1/files.
+   */
+  async listFiles(workspaceId, token, { limit = 50, offset = 0 } = {}) {
+    const params = new URLSearchParams({
+      network: workspaceId,
+      limit: String(limit),
+      offset: String(offset),
+    });
+    const data = await this._get(`/v1/files?${params}`, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  /**
+   * Get file metadata via GET /v1/files/{fileId}/info.
+   */
+  async getFileInfo(token, fileId) {
+    try {
+      const data = await this._get(`/v1/files/${fileId}/info`, this._wsHeaders(token));
+      return data.data || data;
+    } catch {
+      return { id: fileId, filename: fileId, content_type: 'application/octet-stream' };
+    }
+  }
+
+  /**
+   * Download a file via GET /v1/files/{fileId}.
+   * @returns {Buffer}
+   */
+  async readFile(workspaceId, token, fileId) {
+    const params = new URLSearchParams({ network: workspaceId });
+    return this._getRaw(`/v1/files/${fileId}?${params}`, this._wsHeaders(token), 60000);
+  }
+
+  /**
+   * Delete a file via DELETE /v1/files/{fileId}.
+   */
+  async deleteFile(workspaceId, token, fileId) {
+    const data = await this._delete(`/v1/files/${fileId}`, this._wsHeaders(token), workspaceId);
+    return data.data || data;
+  }
+
+  // ── Browser methods ──
+
+  /**
+   * Open a new browser tab via POST /v1/browser/tabs.
+   */
+  async browserOpenTab(workspaceId, token, { url = 'about:blank', source = 'human:user' } = {}) {
+    const data = await this._post('/v1/browser/tabs', {
+      url, network: workspaceId, source,
+    }, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  /**
+   * List browser tabs via GET /v1/browser/tabs.
+   */
+  async browserListTabs(workspaceId, token) {
+    const params = new URLSearchParams({ network: workspaceId });
+    const data = await this._get(`/v1/browser/tabs?${params}`, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  /**
+   * Navigate a browser tab via POST /v1/browser/tabs/{tabId}/navigate.
+   */
+  async browserNavigate(workspaceId, token, tabId, url) {
+    const data = await this._post(`/v1/browser/tabs/${tabId}/navigate`, { url }, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  /**
+   * Click an element via POST /v1/browser/tabs/{tabId}/click.
+   */
+  async browserClick(workspaceId, token, tabId, selector) {
+    const data = await this._post(`/v1/browser/tabs/${tabId}/click`, { selector }, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  /**
+   * Type text via POST /v1/browser/tabs/{tabId}/type.
+   */
+  async browserType(workspaceId, token, tabId, selector, text) {
+    const data = await this._post(`/v1/browser/tabs/${tabId}/type`, { selector, text }, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  /**
+   * Get screenshot via GET /v1/browser/tabs/{tabId}/screenshot.
+   * @returns {Buffer}
+   */
+  async browserScreenshot(workspaceId, token, tabId) {
+    return this._getRaw(`/v1/browser/tabs/${tabId}/screenshot`, this._wsHeaders(token), 30000);
+  }
+
+  /**
+   * Get accessibility snapshot via GET /v1/browser/tabs/{tabId}/snapshot.
+   * @returns {string}
+   */
+  async browserSnapshot(workspaceId, token, tabId) {
+    const buf = await this._getRaw(`/v1/browser/tabs/${tabId}/snapshot`, this._wsHeaders(token));
+    return buf.toString('utf-8');
+  }
+
+  /**
+   * Close a browser tab via DELETE /v1/browser/tabs/{tabId}.
+   */
+  async browserCloseTab(workspaceId, token, tabId) {
+    const data = await this._delete(`/v1/browser/tabs/${tabId}`, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  // ── Internal helpers ──
+
   /**
    * Convert an ONM event to a message-compatible object.
    */
@@ -244,17 +431,19 @@ class WorkspaceClient {
       senderType: isHuman ? 'human' : 'agent',
       senderName,
       content: (payload.content || ''),
+      mentions: payload.mentions || [],
       messageType: payload.message_type || 'chat',
       metadata: event.metadata || {},
     };
     if (ts) {
       msg.createdAt = new Date(ts).toISOString();
     }
+    if (payload.attachments) {
+      msg.attachments = payload.attachments;
+    }
     return msg;
   }
 
-  // -- Internal --
-
   _wsHeaders(token) {
     return {
       'Content-Type': 'application/json',
@@ -262,7 +451,7 @@ class WorkspaceClient {
     };
   }
 
-  _get(urlPath, headers = {}) {
+  _get(urlPath, headers = {}, timeout = 15000) {
     const fullUrl = this.endpoint + urlPath;
 
     return new Promise((resolve, reject) => {
@@ -272,7 +461,7 @@ class WorkspaceClient {
       const req = transport.request(fullUrl, {
         method: 'GET',
         headers,
-        timeout: 15000,
+        timeout,
       }, (res) => {
         let data = '';
         res.on('data', (chunk) => { data += chunk; });
@@ -296,7 +485,37 @@ class WorkspaceClient {
     });
   }
 
-  _post(urlPath, body, headers = {}) {
+  _getRaw(urlPath, headers = {}, timeout = 15000) {
+    const fullUrl = this.endpoint + urlPath;
+
+    return new Promise((resolve, reject) => {
+      const parsedUrl = new URL(fullUrl);
+      const transport = parsedUrl.protocol === 'https:' ? https : http;
+
+      const req = transport.request(fullUrl, {
+        method: 'GET',
+        headers,
+        timeout,
+      }, (res) => {
+        const chunks = [];
+        res.on('data', (chunk) => { chunks.push(chunk); });
+        res.on('end', () => {
+          const buf = Buffer.concat(chunks);
+          if (res.statusCode >= 400) {
+            reject(new Error(`HTTP ${res.statusCode}: ${buf.toString('utf-8').slice(0, 200)}`));
+          } else {
+            resolve(buf);
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.end();
+    });
+  }
+
+  _post(urlPath, body, headers = {}, timeout = 30000) {
     if (!headers['Content-Type']) headers['Content-Type'] = 'application/json';
     const jsonBody = JSON.stringify(body);
     const fullUrl = this.endpoint + urlPath;
@@ -308,7 +527,7 @@ class WorkspaceClient {
       const req = transport.request(fullUrl, {
         method: 'POST',
         headers: { ...headers, 'Content-Length': Buffer.byteLength(jsonBody) },
-        timeout: 30000,
+        timeout,
       }, (res) => {
         let data = '';
         res.on('data', (chunk) => { data += chunk; });
@@ -333,6 +552,77 @@ class WorkspaceClient {
       req.end();
     });
   }
+
+  _patch(urlPath, body, headers = {}, timeout = 15000) {
+    if (!headers['Content-Type']) headers['Content-Type'] = 'application/json';
+    const jsonBody = JSON.stringify(body);
+    const fullUrl = this.endpoint + urlPath;
+
+    return new Promise((resolve, reject) => {
+      const parsedUrl = new URL(fullUrl);
+      const transport = parsedUrl.protocol === 'https:' ? https : http;
+
+      const req = transport.request(fullUrl, {
+        method: 'PATCH',
+        headers: { ...headers, 'Content-Length': Buffer.byteLength(jsonBody) },
+        timeout,
+      }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(data);
+            if (res.statusCode >= 400) {
+              reject(new Error(parsed.message || `HTTP ${res.statusCode}`));
+            } else {
+              resolve(parsed);
+            }
+          } catch {
+            reject(new Error(`Invalid response: ${data.slice(0, 200)}`));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.write(jsonBody);
+      req.end();
+    });
+  }
+
+  _delete(urlPath, headers = {}, network) {
+    const fullUrl = this.endpoint + urlPath + (network ? `?network=${network}` : '');
+
+    return new Promise((resolve, reject) => {
+      const parsedUrl = new URL(fullUrl);
+      const transport = parsedUrl.protocol === 'https:' ? https : http;
+
+      const req = transport.request(fullUrl, {
+        method: 'DELETE',
+        headers,
+        timeout: 15000,
+      }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(data);
+            if (res.statusCode >= 400) {
+              reject(new Error(parsed.message || `HTTP ${res.statusCode}`));
+            } else {
+              resolve(parsed);
+            }
+          } catch {
+            reject(new Error(`Invalid response: ${data.slice(0, 200)}`));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.end();
+    });
+  }
 }
 
 module.exports = { WorkspaceClient };