@lardexx/arenacode 0.0.0-stage → 2.5.3

package/src/turn.js

@@ -0,0 +1,213 @@
+'use strict';
+
+const { c, SYMBOL, ICONS, truncate, width, write } = require('./ui');
+const { handleLocalExec, handleLocalFs, handleLocalUi, handleLocalFile } = require('./local');
+
+/**
+ * Renders the Agent Mode timeline: long-poll GET /task/<id>/events?format=json&since=N&wait=25
+ * and answers the cards the client is expected to execute (terminal, files, plan, files sent
+ * by the agent).
+ */
+class Timeline {
+  constructor(opts) {
+    this.opts = opts;
+    this.seen = new Map(); // seq -> {kind, printed}
+    this.textOpen = false;
+    this.handled = new Set(); // rids already executed
+    this.finalText = '';
+    this.sawText = false;
+    this.lastActivity = Date.now();
+  }
+
+  newlineIfText() {
+    if (this.textOpen) {
+      process.stdout.write('\n');
+      this.textOpen = false;
+    }
+  }
+
+  printText(delta) {
+    if (!delta) return;
+    const text = String(delta).replace(/\\n/g, '\n');
+    if (!this.textOpen) {
+      process.stdout.write(c.cyan('  │ ') + c.white(''));
+      this.textOpen = true;
+    }
+    const parts = text.split('\n');
+    process.stdout.write(c.white(parts[0]));
+    for (let i = 1; i < parts.length; i += 1) process.stdout.write('\n' + c.cyan('  │ ') + c.white(parts[i]));
+    this.finalText += text;
+    this.sawText = true;
+  }
+
+  row(icon, label, { tone = 'cyan', extra = '' } = {}) {
+    const body = `${c[tone](icon)} ${label}${extra}`;
+    write('  ' + body);
+  }
+
+  printDetail(detail) {
+    if (!detail) return;
+    const lines = String(detail).split('\n');
+    const max = 14;
+    for (const line of lines.slice(0, max)) write(c.gray('    ' + truncate(line, Math.max(40, (process.stdout.columns || 100) - 6))));
+    if (lines.length > max) write(c.gray(`    … ${lines.length - max} more lines`));
+  }
+
+  render(ev) {
+    this.lastActivity = Date.now();
+    const kind = ev.kind || 'status';
+    const prev = this.seen.get(ev.seq);
+    const isUpdate = Boolean(prev) && prev.kind === kind;
+
+    if (kind !== 'text') this.newlineIfText();
+
+    switch (kind) {
+      case 'text':
+        this.printText(ev.delta || '');
+        break;
+
+      case 'thought':
+        if (isUpdate && ev.state === 'done') break;
+        this.row(SYMBOL.thought, c.dim(ev.label || '…'), { icon: 'dim', tone: 'dim' });
+        break;
+
+      case 'tool': {
+        const icon = ICONS[ev.icon] || SYMBOL.tool;
+        const label = ev.label || ev.tool || 'step';
+        const secs = ev.secs ? c.gray(` ${Number(ev.secs).toFixed(1)}s`) : '';
+        const tone = ev.state === 'failed' ? 'red' : ev.state === 'done' ? 'green' : 'yellow';
+        this.row(icon, c.bold(label), { tone, extra: secs });
+        if (ev.detail) this.printDetail(ev.detail);
+        break;
+      }
+
+      case 'status':
+        this.row(SYMBOL.status, c.gray(ev.label || ''));
+        break;
+
+      case 'vision':
+        this.row(SYMBOL.vision, c.gray(`vision: ${ev.vision === true ? 'yes' : 'no'}`), { tone: 'magenta' });
+        break;
+
+      case 'user':
+        this.row(SYMBOL.user, c.yellow(`${ev.label || 'user event'} ${ev.detail || ''}`), { tone: 'yellow' });
+        break;
+
+      case 'error':
+        this.row(SYMBOL.error, c.red(ev.label || ev.error || 'error'), { tone: 'red' });
+        if (ev.detail) this.printDetail(ev.detail);
+        break;
+
+      case 'done': {
+        const secs = ev.secs ? c.gray(` ${Number(ev.secs).toFixed(1)}s`) : '';
+        if (ev.state === 'cancelled') this.row('■', c.yellow('cancelled'), { tone: 'yellow', extra: secs });
+        else if (ev.state === 'error') this.row(SYMBOL.error, c.red('failed'), { tone: 'red', extra: secs });
+        else this.row(SYMBOL.done, c.green('done'), { tone: 'green', extra: secs });
+        break;
+      }
+
+      default:
+        this.row(SYMBOL.status, c.gray(`${kind} ${ev.label || ''}`));
+    }
+
+    this.seen.set(ev.seq, { kind });
+  }
+
+  /** Executes the cards the client owns. Runs at most once per rid. */
+  async handle(ev, bridge, taskId) {
+    const { local_exec: localExec, local_fs: localFs, local_ui: localUi, local_file: localFile } = ev;
+    try {
+      if (localExec && localExec.rid && !this.handled.has(localExec.rid)) {
+        this.handled.add(localExec.rid);
+        return handleLocalExec(bridge, taskId, localExec, this.opts);
+      }
+      if (localFs && localFs.rid && !this.handled.has(localFs.rid)) {
+        this.handled.add(localFs.rid);
+        return handleLocalFs(bridge, taskId, localFs, this.opts);
+      }
+      if (localUi && localUi.rid && !this.handled.has(localUi.rid)) {
+        this.handled.add(localUi.rid);
+        return handleLocalUi(bridge, taskId, localUi, this.opts);
+      }
+      if (localFile && !this.handled.has(`file:${localFile.remote}:${localFile.dest || localFile.name}`)) {
+        this.handled.add(`file:${localFile.remote}:${localFile.dest || localFile.name}`);
+        return handleLocalFile(bridge, taskId, localFile, this.opts);
+      }
+    } catch (e) {
+      write(c.red(`  ✗ local action failed: ${e.message}`));
+    }
+    return false;
+  }
+}
+
+/**
+ * Follows one task until it finishes. Returns {state, output, error}.
+ * `stop()` can be used from a SIGINT handler to cancel the turn.
+ */
+async function followTask(bridge, taskId, opts, onTaskId) {
+  const timeline = new Timeline(opts);
+  let since = 0;
+  let done = false;
+  let state = 'pending';
+  let output = '';
+  let error = null;
+  const idleTimeout = (opts.idleTimeout || 180) * 1000;
+
+  if (onTaskId) onTaskId(taskId);
+
+  for (;;) {
+    const res = await bridge.events(taskId, since, 25);
+
+    if (res.status === 0 || res.status >= 500) {
+      // transient: the client retries instead of dropping the turn
+      write(c.yellow(`  ! ${(res.json && res.json.error) || res.status}; retrying in 3s`));
+      await new Promise((r) => setTimeout(r, 3000));
+      continue;
+    }
+    if (res.status === 404) {
+      return { state: 'error', output: '', error: 'task not found on the bridge' };
+    }
+    if (res.status !== 200 || !res.json) {
+      write(c.red(`  ✗ events: HTTP ${res.status} ${res.text || ''}`));
+      return { state: 'error', output: '', error: `HTTP ${res.status}` };
+    }
+
+    const payload = res.json;
+    const events = Array.isArray(payload.events) ? payload.events : [];
+    for (const ev of events) {
+      if (ev.kind === 'done') {
+        done = true;
+        state = ev.state || state;
+        output = ev.output || output;
+        error = ev.error || null;
+      }
+      timeline.render(ev);
+      await timeline.handle(ev, bridge, taskId);
+    }
+    if (typeof payload.next === 'number') since = payload.next;
+
+    if (payload.done) {
+      state = payload.state || state;
+      if (!output) {
+        const t = await bridge.getTask(taskId);
+        if (t.status === 200 && t.json) {
+          output = t.json.output || '';
+          error = t.json.error || error;
+        }
+      }
+      break;
+    }
+    if (done) break;
+
+    if (Date.now() - timeline.lastActivity > idleTimeout) {
+      timeline.newlineIfText();
+      write(c.yellow(`  ! no activity for ${Math.round(idleTimeout / 1000)}s: closing the session (the agent may still be working)`));
+      break;
+    }
+  }
+
+  timeline.newlineIfText();
+  return { state, output, error, streamed: timeline.sawText, timeline };
+}
+
+module.exports = { Timeline, followTask };

package/src/ui.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const readline = require('node:readline');
+const { stdin, stdout } = require('node:process');
+
+const useColor = stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== 'dumb';
+
+function wrap(code) {
+  return (s) => (useColor ? `\x1b[${code}m${s}\x1b[0m` : String(s));
+}
+
+const c = {
+  dim: wrap('2'),
+  bold: wrap('1'),
+  gray: wrap('90'),
+  red: wrap('31'),
+  green: wrap('32'),
+  yellow: wrap('33'),
+  blue: wrap('34'),
+  magenta: wrap('35'),
+  cyan: wrap('36'),
+  white: wrap('37'),
+  inverse: wrap('7'),
+};
+
+const SYMBOL = {
+  thought: '·',
+  tool: '›',
+  text: '│',
+  status: '~',
+  done: '✓',
+  error: '✗',
+  user: '←',
+  vision: '◉',
+};
+
+const ICONS = {
+  globe: '🌐', terminal: '⌘', doc: '▤', eye: '◉', search: '⌕',
+  image: '▣', sparkle: '✦', bolt: '⚡', check: '✓', x: '✗', folder: '▸', pencil: '✎',
+};
+
+function stripAnsi(s) {
+  return String(s).replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+/** Visual width, counting wide CJK/emoji as 2 cells. */
+function width(s) {
+  let w = 0;
+  for (const ch of stripAnsi(s)) {
+    const cp = ch.codePointAt(0);
+    w += cp > 0x1100 && (cp <= 0x115f || (cp >= 0x2e80 && cp <= 0xa4cf) || (cp >= 0xac00 && cp <= 0xd7a3) ||
+      (cp >= 0xf900 && cp <= 0xfaff) || (cp >= 0xfe30 && cp <= 0xfe6f) || (cp >= 0xff00 && cp <= 0xff60) ||
+      (cp >= 0x1f300 && cp <= 0x1f9ff)) ? 2 : 1;
+  }
+  return w;
+}
+
+function truncate(s, max) {
+  const text = String(s);
+  if (width(text) <= max) return text;
+  let out = '';
+  let w = 0;
+  for (const ch of stripAnsi(text)) {
+    const cw = width(ch);
+    if (w + cw > max - 1) break;
+    out += ch;
+    w += cw;
+  }
+  return out + '…';
+}
+
+function indentLines(text, prefix) {
+  return String(text)
+    .split('\n')
+    .map((line) => prefix + line)
+    .join('\n');
+}
+
+/** Asks a question and resolves with the trimmed answer ('' when stdin is not a TTY). */
+function ask(question, { default: def = '', hidden = false } = {}) {
+  if (!stdin.isTTY) {
+    const chunks = [];
+    return new Promise((resolve) => {
+      stdin.on('data', (d) => chunks.push(d));
+      stdin.on('end', () => resolve(String(Buffer.concat(chunks)).trim() || def));
+    });
+  }
+  const rl = readline.createInterface({ input: stdin, output: stdout, terminal: true });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(String(answer).trim() || def);
+    });
+  });
+}
+
+/** Single-key question: returns the pressed key, lowercased. */
+function askKey(question, allowed) {
+  process.stdout.write(question);
+  return new Promise((resolve) => {
+    if (!stdin.isTTY) {
+      resolve(allowed[0]);
+      return;
+    }
+    stdin.setRawMode(true);
+    stdin.resume();
+    const onData = (buf) => {
+      const ch = String(buf).toLowerCase();
+      if (!allowed.includes(ch)) return;
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener('data', onData);
+      process.stdout.write('\n');
+      resolve(ch);
+    };
+    stdin.on('data', onData);
+  });
+}
+
+function write(s = '') {
+  process.stdout.write(s + '\n');
+}
+
+function banner(version) {
+  write('');
+  write(`  ${c.cyan(c.bold('ArenaCode CLI'))} ${c.dim('v' + version)} ${c.gray('· terminal client for arena-bridge')}`);
+  write('');
+}
+
+module.exports = { c, SYMBOL, ICONS, useColor, stripAnsi, width, truncate, indentLines, ask, askKey, write, banner };