chromux 0.2.0

package/README.md

@@ -0,0 +1,152 @@
+# chromux
+
+tmux for Chrome tabs — zero-dependency parallel Chrome tab controller via raw CDP.
+
+## Why
+
+AI agents need to browse the web in parallel using the user's **real Chrome** (with logins preserved, no bot detection). Existing tools either bundle their own Chromium (Playwright/Puppeteer) or can't isolate tabs properly (agent-browser `--cdp --session`).
+
+chromux solves this by talking to Chrome's DevTools Protocol directly using only Node.js built-ins — no Playwright, no Puppeteer, no npm dependencies.
+
+| | Playwright/Puppeteer | agent-browser `--cdp` | chromux |
+|---|---|---|---|
+| Browser | Bundled Chromium | Real Chrome | Real Chrome |
+| Bot detection | Often caught | Avoided | Avoided |
+| Tab isolation | Yes | **No** (sessions share tab) | **Yes** |
+| Parallel agents | Yes | **Broken** | **Yes** |
+| Dependencies | 100s of MB | playwright-core | **None** |
+| Profile management | No | No | **Yes** |
+
+## Prerequisites
+
+- **Node.js >= 22** (for built-in `WebSocket`)
+- **Google Chrome** installed
+
+## Quick Start
+
+```bash
+# Launch Chrome with an isolated profile (auto-finds Chrome, auto-assigns port)
+chromux launch
+
+# Open tabs for two agents
+chromux open agent-a https://news.ycombinator.com
+chromux open agent-b https://reddit.com/r/programming
+
+# Each operates independently
+chromux snapshot agent-a
+chromux click agent-a @3
+chromux eval agent-b "document.title"
+chromux screenshot agent-a /tmp/hn.png
+
+# Clean up
+chromux close agent-a
+chromux close agent-b
+chromux kill default
+```
+
+## Profile Management
+
+Each profile is an isolated Chrome instance with its own user-data-dir, logins, cookies, and extensions.
+
+```bash
+# Launch named profiles
+chromux launch work
+chromux launch personal
+
+# See what's running
+chromux ps
+# PROFILE             PORT    PID       STATUS      TABS
+# work                9300    12345     running     3
+# personal            9301    12346     running     1
+
+# Use a specific profile for tab commands
+chromux --profile work open my-tab https://...
+CHROMUX_PROFILE=personal chromux open other-tab https://...
+
+# Default profile is "default" — used when no --profile specified
+chromux open my-tab https://...  # → uses "default" profile (auto-launches if needed)
+
+# Stop a profile
+chromux kill work
+```
+
+## Commands
+
+### Profile
+
+| Command | Description |
+|---------|-------------|
+| `launch [name]` | Launch Chrome with isolated profile (default: "default") |
+| `launch <name> --port N` | Launch with specific port |
+| `ps` | List running profiles |
+| `kill <name>` | Stop profile (Chrome + daemon) |
+
+### Tab Operations
+
+| Command | Description |
+|---------|-------------|
+| `open <session> <url>` | Navigate (auto-creates tab) |
+| `snapshot <session>` | Accessibility tree with `@ref` numbers |
+| `click <session> @<ref>` | Click element by ref |
+| `click <session> "selector"` | Click by CSS selector |
+| `fill <session> @<ref> "text"` | Fill input field |
+| `type <session> "text"` | Keyboard input (Enter, Tab, etc.) |
+| `eval <session> "js"` | Run JavaScript expression |
+| `screenshot <session> [path]` | Take PNG screenshot |
+| `scroll <session> up\|down` | Scroll page |
+| `wait <session> <ms>` | Wait milliseconds |
+| `close <session>` | Close tab |
+| `list` | List active sessions in current profile |
+| `stop` | Stop daemon (keeps Chrome running) |
+
+## Architecture
+
+```
+~/.chromux/
+  config.json                    Global config (optional)
+  profiles/
+    default/                     Chrome user-data-dir
+      .state                     PID, port, socket path
+    work/
+      .state
+
+Chrome instance A (port 9300, ~/.chromux/profiles/default/)
+  ↑ CDP WebSocket per tab
+chromux daemon (Unix socket /tmp/chromux-default.sock)
+  ↑ HTTP
+CLI / AI agents
+
+Chrome instance B (port 9301, ~/.chromux/profiles/work/)
+  ↑ CDP WebSocket per tab
+chromux daemon (Unix socket /tmp/chromux-work.sock)
+  ↑ HTTP
+CLI / AI agents
+```
+
+- **No Playwright/Puppeteer** — raw `WebSocket` + `http` from Node.js stdlib
+- **Tab CRUD** via Chrome's `/json/*` HTTP endpoints
+- **Page ops** via CDP WebSocket JSON-RPC
+- **Daemon per profile** keeps WebSocket connections alive across CLI invocations
+- **Auto-launch** — `chromux open` auto-launches default profile if needed
+
+## Configuration
+
+Optional `~/.chromux/config.json`:
+
+```json
+{
+  "chromePath": "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "portRangeStart": 9300,
+  "portRangeEnd": 9399
+}
+```
+
+## Environment
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `CHROMUX_PROFILE` | `default` | Active profile name |
+
+## License
+
+MIT

package/chrome-tabs.mjs

@@ -0,0 +1,501 @@
+#!/usr/bin/env node
+
+/**
+ * chrome-tabs — Zero-dependency parallel Chrome tab controller via raw CDP.
+ *
+ * Connects to a real Chrome instance (e.g. chrome-agent) over the Chrome
+ * DevTools Protocol.  Each "session" is an independent browser tab that can
+ * be operated in parallel by different AI agents.
+ *
+ * Dependencies: NONE — uses only Node.js ≥22 built-ins (http, WebSocket, fs).
+ */
+
+import http from 'node:http';
+import fs from 'node:fs';
+import { spawn, execSync } from 'node:child_process';
+
+const SOCK = '/tmp/chrome-tabs.sock';
+const CDP_URL = process.env.CHROME_CDP || 'http://localhost:9222';
+
+// ============================================================
+// CDP Client — thin wrapper over Chrome DevTools Protocol
+// ============================================================
+
+class CDPClient {
+  #ws;
+  #seq = 0;
+  #pending = new Map();   // id → { resolve }
+  #waiters = [];          // [{ method, resolve, timer }]
+
+  async connect(wsUrl) {
+    this.#ws = new WebSocket(wsUrl);
+    await new Promise((res, rej) => {
+      this.#ws.addEventListener('open', res, { once: true });
+      this.#ws.addEventListener('error', rej, { once: true });
+    });
+    this.#ws.addEventListener('message', (evt) => {
+      const msg = JSON.parse(evt.data);
+      // command response
+      if ('id' in msg) {
+        const p = this.#pending.get(msg.id);
+        if (p) { this.#pending.delete(msg.id); p.resolve(msg); }
+      }
+      // domain event
+      if ('method' in msg) {
+        for (let i = this.#waiters.length - 1; i >= 0; i--) {
+          if (this.#waiters[i].method === msg.method) {
+            clearTimeout(this.#waiters[i].timer);
+            this.#waiters[i].resolve(msg.params);
+            this.#waiters.splice(i, 1);
+            break;
+          }
+        }
+      }
+    });
+  }
+
+  /** Send a CDP command, return result (throws on CDP error). */
+  async send(method, params = {}) {
+    const id = ++this.#seq;
+    const msg = await new Promise((resolve) => {
+      this.#pending.set(id, { resolve });
+      this.#ws.send(JSON.stringify({ id, method, params }));
+    });
+    if (msg.error) throw new Error(`CDP ${method}: ${msg.error.message}`);
+    return msg.result;
+  }
+
+  /** Wait for a domain event (e.g. Page.loadEventFired). */
+  waitForEvent(method, timeout = 30000) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const i = this.#waiters.findIndex(w => w === entry);
+        if (i >= 0) this.#waiters.splice(i, 1);
+        reject(new Error(`Timeout waiting for ${method}`));
+      }, timeout);
+      const entry = { method, resolve, timer };
+      this.#waiters.push(entry);
+    });
+  }
+
+  close() { this.#ws?.close(); }
+}
+
+// ============================================================
+// Chrome HTTP helpers — tab CRUD via /json/* endpoints
+// ============================================================
+
+function cdpFetch(path, method = 'GET') {
+  const base = new URL(CDP_URL);
+  return new Promise((resolve, reject) => {
+    const req = http.request({ hostname: base.hostname, port: base.port, path, method }, (res) => {
+      let d = '';
+      res.on('data', c => d += c);
+      res.on('end', () => {
+        try { resolve(JSON.parse(d)); }
+        catch { resolve(d); }
+      });
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+async function createTab(url = 'about:blank') {
+  return cdpFetch(`/json/new?${url}`, 'PUT');
+}
+
+async function closeTab(targetId) {
+  return cdpFetch(`/json/close/${targetId}`);
+}
+
+async function listTabs() {
+  const all = await cdpFetch('/json');
+  return all.filter(t => t.type === 'page');
+}
+
+// ============================================================
+// Snapshot — accessibility tree with @ref numbers
+// ============================================================
+
+const SNAPSHOT_JS = `(() => {
+  let refId = 0;
+  const ROLES = {
+    a:'link', button:'button', input:'textbox', select:'combobox',
+    textarea:'textbox', img:'img', nav:'navigation', main:'main',
+    header:'banner', footer:'contentinfo', form:'form',
+    h1:'heading', h2:'heading', h3:'heading',
+    h4:'heading', h5:'heading', h6:'heading',
+    ul:'list', ol:'list', li:'listitem',
+    table:'table', tr:'row', td:'cell', th:'columnheader',
+    dialog:'dialog', section:'region', aside:'complementary',
+  };
+  const INTERACTIVE = new Set(['a','button','input','select','textarea']);
+  function getRole(el) {
+    return el.getAttribute('role') || ROLES[el.tagName.toLowerCase()] || null;
+  }
+  function isInteractive(el) {
+    const tag = el.tagName.toLowerCase();
+    if (INTERACTIVE.has(tag)) return true;
+    const role = el.getAttribute('role');
+    if (role === 'button' || role === 'link' || role === 'tab' || role === 'menuitem') return true;
+    if (el.getAttribute('tabindex') !== null && el.getAttribute('tabindex') !== '-1') return true;
+    return false;
+  }
+  function getLabel(el) {
+    const tag = el.tagName.toLowerCase();
+    const aria = el.getAttribute('aria-label');
+    if (aria) return aria;
+    if (tag === 'input' || tag === 'textarea') return el.value || el.placeholder || '';
+    if (tag === 'img') return el.alt || '';
+    let text = '';
+    for (const n of el.childNodes) { if (n.nodeType === 3) text += n.textContent; }
+    return text.trim().substring(0, 100);
+  }
+  function walk(el, depth) {
+    if (!el || el.nodeType !== 1) return '';
+    try {
+      const s = getComputedStyle(el);
+      if (s.display === 'none' || s.visibility === 'hidden' || el.hidden) return '';
+    } catch { return ''; }
+    if (el.getAttribute('aria-hidden') === 'true') return '';
+    const tag = el.tagName.toLowerCase();
+    if (['script','style','noscript','br','hr','svg','path'].includes(tag)) return '';
+    const role = getRole(el);
+    const interactive = isInteractive(el);
+    const label = getLabel(el);
+    const has = role || interactive || label;
+    const cd = has ? depth + 1 : depth;
+    let children = '';
+    for (const c of el.children) children += walk(c, cd);
+    if (!has && !children) return '';
+    if (!has) return children;
+    const indent = '  '.repeat(depth);
+    let line = indent;
+    if (interactive) {
+      const ref = ++refId;
+      el.setAttribute('data-ct-ref', String(ref));
+      line += '@' + ref + ' ';
+    }
+    line += role || tag;
+    if (label) line += ' "' + label.replace(/"/g, '\\\\"') + '"';
+    if (tag === 'input') line += ' [' + (el.type || 'text') + ']';
+    if (tag === 'a' && el.href) {
+      const href = el.getAttribute('href');
+      if (href && !href.startsWith('javascript:') && !href.startsWith('#'))
+        line += ' -> ' + href.substring(0, 80);
+    }
+    return line + '\\n' + children;
+  }
+  return '# ' + document.title + '\\n# ' + location.href + '\\n\\n' + walk(document.body, 0);
+})()`;
+
+// ============================================================
+// Daemon server
+// ============================================================
+
+async function startDaemon() {
+  try { fs.unlinkSync(SOCK); } catch {}
+
+  // Verify Chrome is reachable
+  try { await cdpFetch('/json/version'); }
+  catch { console.error(`Cannot reach Chrome at ${CDP_URL}`); process.exit(1); }
+
+  /** @type {Map<string, {targetId: string, cdp: CDPClient}>} */
+  const sessions = new Map();
+
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url, 'http://x');
+    const body = ['POST', 'PUT'].includes(req.method) ? await readBody(req) : null;
+
+    try {
+      const result = await route(req.method, url.pathname, body, sessions);
+      const isText = typeof result === 'string';
+      res.writeHead(200, { 'Content-Type': isText ? 'text/plain; charset=utf-8' : 'application/json' });
+      res.end(isText ? result : JSON.stringify(result));
+    } catch (err) {
+      res.writeHead(err.status || 500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: err.message }));
+    }
+  });
+
+  server.listen(SOCK, () => console.log(`chrome-tabs daemon on ${SOCK}`));
+
+  const cleanup = () => {
+    for (const s of sessions.values()) s.cdp.close();
+    try { fs.unlinkSync(SOCK); } catch {}
+  };
+  process.on('exit', cleanup);
+  process.on('SIGTERM', () => process.exit(0));
+  process.on('SIGINT', () => process.exit(0));
+}
+
+async function route(method, path, body, sessions) {
+
+  // --- health ---
+  if (path === '/health')
+    return { ok: true, sessions: sessions.size };
+
+  // --- list ---
+  if (path === '/list') {
+    const out = {};
+    for (const [id, s] of sessions) {
+      try {
+        const r = await s.cdp.send('Runtime.evaluate', { expression: 'JSON.stringify({url:location.href,title:document.title})', returnByValue: true });
+        out[id] = JSON.parse(r.result.value);
+      } catch { out[id] = { url: '(closed)', title: '' }; sessions.delete(id); }
+    }
+    return out;
+  }
+
+  // --- open ---
+  if (path === '/open' && method === 'POST') {
+    const { session, url } = body;
+    if (!session || !url) throw httpErr(400, 'session and url required');
+
+    let s = sessions.get(session);
+    if (!s) {
+      const tab = await createTab('about:blank');
+      const cdp = new CDPClient();
+      await cdp.connect(tab.webSocketDebuggerUrl);
+      await cdp.send('Page.enable');
+      await cdp.send('Runtime.enable');
+      s = { targetId: tab.id, cdp };
+      sessions.set(session, s);
+    }
+
+    const loaded = s.cdp.waitForEvent('Page.loadEventFired', 30000);
+    await s.cdp.send('Page.navigate', { url });
+    await loaded;
+
+    const r = await s.cdp.send('Runtime.evaluate', { expression: 'JSON.stringify({url:location.href,title:document.title})', returnByValue: true });
+    return { session, ...JSON.parse(r.result.value) };
+  }
+
+  // --- snapshot ---
+  if (path.startsWith('/snapshot/')) {
+    const session = decodeURIComponent(path.split('/')[2]);
+    const s = getSession(sessions, session);
+    const r = await s.cdp.send('Runtime.evaluate', { expression: SNAPSHOT_JS, returnByValue: true });
+    return r.result.value;   // plain text
+  }
+
+  // --- click ---
+  if (path === '/click' && method === 'POST') {
+    const { session, selector } = body;
+    const s = getSession(sessions, session);
+    const sel = selector.startsWith('@')
+      ? `[data-ct-ref="${selector.slice(1)}"]`
+      : selector;
+    await s.cdp.send('Runtime.evaluate', {
+      expression: `document.querySelector('${sel.replace(/'/g, "\\'")}').click()`,
+      returnByValue: true,
+    });
+    await sleep(500);
+    return { clicked: selector };
+  }
+
+  // --- fill ---
+  if (path === '/fill' && method === 'POST') {
+    const { session, selector, text } = body;
+    const s = getSession(sessions, session);
+    const sel = selector.startsWith('@')
+      ? `[data-ct-ref="${selector.slice(1)}"]`
+      : selector;
+    const escaped = text.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    await s.cdp.send('Runtime.evaluate', {
+      expression: `(() => { const el = document.querySelector('${sel.replace(/'/g, "\\'")}'); el.focus(); el.value = '${escaped}'; el.dispatchEvent(new Event('input', {bubbles:true})); })()`,
+      returnByValue: true,
+    });
+    return { filled: selector, text };
+  }
+
+  // --- type ---
+  if (path === '/type' && method === 'POST') {
+    const { session, text } = body;
+    const s = getSession(sessions, session);
+    const KEY_MAP = { Enter: '\r', Tab: '\t', Escape: '\u001B', Backspace: '\b' };
+    if (KEY_MAP[text] || text.length === 1) {
+      await s.cdp.send('Input.dispatchKeyEvent', {
+        type: 'keyDown', key: text, text: KEY_MAP[text] || text,
+      });
+      await s.cdp.send('Input.dispatchKeyEvent', { type: 'keyUp', key: text });
+    } else {
+      for (const ch of text) {
+        await s.cdp.send('Input.dispatchKeyEvent', { type: 'keyDown', key: ch, text: ch });
+        await s.cdp.send('Input.dispatchKeyEvent', { type: 'keyUp', key: ch });
+      }
+    }
+    return { typed: text };
+  }
+
+  // --- eval ---
+  if (path === '/eval' && method === 'POST') {
+    const { session, code } = body;
+    const s = getSession(sessions, session);
+    const r = await s.cdp.send('Runtime.evaluate', {
+      expression: code, returnByValue: true, awaitPromise: true,
+    });
+    if (r.exceptionDetails) throw httpErr(400, r.exceptionDetails.text || 'eval error');
+    return r.result.value;
+  }
+
+  // --- screenshot ---
+  if (path === '/screenshot' && method === 'POST') {
+    const { session, path: savePath } = body;
+    const s = getSession(sessions, session);
+    const r = await s.cdp.send('Page.captureScreenshot', { format: 'png' });
+    const p = savePath || `/tmp/chrome-tabs-${session}-${Date.now()}.png`;
+    fs.writeFileSync(p, Buffer.from(r.data, 'base64'));
+    return { path: p };
+  }
+
+  // --- scroll ---
+  if (path === '/scroll' && method === 'POST') {
+    const { session, direction } = body;
+    const s = getSession(sessions, session);
+    const delta = direction === 'up' ? -500 : 500;
+    await s.cdp.send('Input.dispatchMouseEvent', { type: 'mouseWheel', x: 300, y: 300, deltaX: 0, deltaY: delta });
+    await sleep(300);
+    return { scrolled: direction };
+  }
+
+  // --- wait ---
+  if (path === '/wait' && method === 'POST') {
+    getSession(sessions, body.session);
+    await sleep(body.ms || 1000);
+    return { waited: body.ms || 1000 };
+  }
+
+  // --- close session ---
+  if (path.startsWith('/session/') && method === 'DELETE') {
+    const session = decodeURIComponent(path.split('/')[2]);
+    const s = sessions.get(session);
+    if (s) {
+      s.cdp.close();
+      await closeTab(s.targetId).catch(() => {});
+      sessions.delete(session);
+    }
+    return { closed: session };
+  }
+
+  // --- stop ---
+  if (path === '/stop') {
+    setTimeout(() => process.exit(0), 100);
+    return { stopping: true };
+  }
+
+  throw httpErr(404, `Not found: ${method} ${path}`);
+}
+
+// ============================================================
+// CLI client
+// ============================================================
+
+function cliReq(method, path, body) {
+  return new Promise((resolve, reject) => {
+    const opts = {
+      socketPath: SOCK, path, method,
+      headers: body ? { 'Content-Type': 'application/json' } : {},
+    };
+    const req = http.request(opts, (res) => {
+      let d = '';
+      res.on('data', c => d += c);
+      res.on('end', () => {
+        if (res.statusCode >= 400) {
+          try { reject(new Error(JSON.parse(d).error)); }
+          catch { reject(new Error(d)); }
+          return;
+        }
+        if (res.headers['content-type']?.includes('text/plain')) resolve(d);
+        else { try { resolve(JSON.parse(d)); } catch { resolve(d); } }
+      });
+    });
+    req.on('error', reject);
+    if (body) req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+async function ensureDaemon() {
+  try { await cliReq('GET', '/health'); return; } catch {}
+  process.stderr.write('Starting chrome-tabs daemon...');
+  const child = spawn(process.execPath, [process.argv[1], '--daemon'], {
+    detached: true, stdio: 'ignore', env: { ...process.env, CHROME_CDP: CDP_URL },
+  });
+  child.unref();
+  for (let i = 0; i < 50; i++) {
+    await sleep(200);
+    try { await cliReq('GET', '/health'); process.stderr.write(' ready.\n'); return; } catch {}
+  }
+  console.error(' failed. Is Chrome running with --remote-debugging-port=9222?');
+  process.exit(1);
+}
+
+async function runCli(cmd, args) {
+  await ensureDaemon();
+  const routes = {
+    open:       () => cliReq('POST', '/open', { session: args[0], url: args[1] }),
+    snapshot:   () => cliReq('GET', `/snapshot/${args[0]}`),
+    click:      () => cliReq('POST', '/click', { session: args[0], selector: args[1] }),
+    fill:       () => cliReq('POST', '/fill', { session: args[0], selector: args[1], text: args[2] }),
+    type:       () => cliReq('POST', '/type', { session: args[0], text: args[1] }),
+    eval:       () => cliReq('POST', '/eval', { session: args[0], code: args[1] }),
+    screenshot: () => cliReq('POST', '/screenshot', { session: args[0], path: args[1] }),
+    scroll:     () => cliReq('POST', '/scroll', { session: args[0], direction: args[1] || 'down' }),
+    wait:       () => cliReq('POST', '/wait', { session: args[0], ms: parseInt(args[1]) || 1000 }),
+    close:      () => cliReq('DELETE', `/session/${args[0]}`),
+    list:       () => cliReq('GET', '/list'),
+    stop:       () => cliReq('POST', '/stop', {}),
+  };
+  if (!routes[cmd]) { console.error(`Unknown: ${cmd}. Run: chrome-tabs help`); process.exit(1); }
+  try {
+    const r = await routes[cmd]();
+    console.log(typeof r === 'string' ? r : JSON.stringify(r, null, 2));
+  } catch (e) { console.error(`Error: ${e.message}`); process.exit(1); }
+}
+
+// ============================================================
+// Helpers
+// ============================================================
+
+function getSession(sessions, id) {
+  const s = sessions.get(id);
+  if (!s) throw httpErr(404, `Session "${id}" not found`);
+  return s;
+}
+function httpErr(status, message) { const e = new Error(message); e.status = status; return e; }
+function readBody(req) {
+  return new Promise(r => { let d = ''; req.on('data', c => d += c); req.on('end', () => { try { r(JSON.parse(d)); } catch { r(d); } }); });
+}
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+// ============================================================
+// Entry
+// ============================================================
+
+const [,, cmd, ...args] = process.argv;
+
+if (cmd === '--daemon') {
+  await startDaemon();
+} else if (!cmd || cmd === 'help' || cmd === '--help') {
+  console.log(`chrome-tabs — Zero-dep parallel Chrome tab controller via raw CDP
+
+Usage:
+  chrome-tabs open <session> <url>          Navigate (auto-creates tab)
+  chrome-tabs snapshot <session>            Accessibility tree with @ref
+  chrome-tabs click <session> @<ref>        Click by ref number
+  chrome-tabs fill <session> @<ref> "text"  Fill input
+  chrome-tabs type <session> "text"         Keyboard input
+  chrome-tabs eval <session> "js"           Run JavaScript
+  chrome-tabs screenshot <session> [path]   Take screenshot
+  chrome-tabs scroll <session> up|down      Scroll
+  chrome-tabs wait <session> <ms>           Wait
+  chrome-tabs close <session>               Close tab
+  chrome-tabs list                          List sessions
+  chrome-tabs stop                          Stop daemon
+
+Env: CHROME_CDP (default http://localhost:9222)`);
+} else {
+  await runCli(cmd, args);
+}