bortexcode 1.2.8 → 1.3.0

package/README.md

@@ -47,6 +47,9 @@ export BORTEX_API_KEY=<YOUR_API_KEY>
 bortexcode
 bortexcode "explain this function"
 bortexcode --agent "refactor src/utils.js"
+bortexcode remote-control
+bortexcode remote-control --cloud
+bortexcode --remote-control
 ```
 
 ## REPL Commands
@@ -63,9 +66,45 @@ Common commands:
 /help
 /llm-config show
 /llm-config sync
+/remote-control [name]
+/remote-control --lan
+/remote-control --cloud
+/rc
 /exit
 ```
 
+## Remote Control
+
+Remote Control exposes the current Bortex Code process through a token-protected
+browser UI. By default it binds to `127.0.0.1`.
+
+```bash
+bortexcode remote-control --name "My Project"
+bortexcode --remote-control "My Project"
+```
+
+For phone access on the same LAN:
+
+```bash
+bortexcode remote-control --remote-lan
+```
+
+For remote access without opening an inbound port, use the bortex.site relay:
+
+```bash
+bortexcode remote-control --cloud --name "My Project"
+bortexcode --remote-cloud "My Project"
+```
+
+Inside the REPL:
+
+```text
+/remote-control My Project
+/remote-control --lan
+/remote-control --cloud
+/remote-control stop
+```
+
 ## Options
 
 ```text
@@ -84,6 +123,15 @@ Common commands:
     --check-update  Check for updates now
     --no-update-check
                     Disable startup update check
+    --remote-control, --rc [name]
+                    Enable browser remote control
+    --remote-cloud, --cloud
+                    Use bortex.site relay instead of opening a local port
+    --remote-relay <url>
+                    Remote relay base URL
+    --remote-lan    Bind remote control to 0.0.0.0 for LAN/mobile access
+    --remote-host <host>, --remote-port <port>
+                    Remote control bind address
 -v, --version       Show version
 -h, --help          Show help
 ```
@@ -105,4 +153,7 @@ BORTEX_URL
 BORTEX_API_KEY
 BORTEX_CLI_ICONS=1
 BORTEX_NO_UPDATE_CHECK=1
+BORTEX_REMOTE_HOST
+BORTEX_REMOTE_PORT
+BORTEX_REMOTE_RELAY_URL
 ```

package/bin/bortex.js

@@ -31,6 +31,13 @@ function parseArgs(argv) {
     _modelExplicit: false,
     _apiUrlExplicit: false,
     _apiKeyExplicit: false,
+    remoteControl: false,
+    remoteControlServerMode: false,
+    remoteControlCloud: false,
+    remoteControlRelayUrl: process.env.BORTEX_REMOTE_RELAY_URL || '',
+    remoteControlName: '',
+    remoteControlHost: process.env.BORTEX_REMOTE_HOST || '127.0.0.1',
+    remoteControlPort: Number(process.env.BORTEX_REMOTE_PORT || 0) || 0,
     ux: {
       verbose: false,
       spinner: true,
@@ -42,6 +49,14 @@ function parseArgs(argv) {
   const rest = [];
   for (let i = 0; i < argv.length; i += 1) {
     const a = argv[i];
+    if (a === 'remote-control' || a === 'remote') {
+      opts.remoteControlServerMode = true;
+      continue;
+    }
+    if ((a === 'cloud' || a === 'relay') && opts.remoteControlServerMode) {
+      opts.remoteControlCloud = true;
+      continue;
+    }
     if (a === '--agent' || a === '-a') {
       opts.agent = true;
       continue;
@@ -128,6 +143,68 @@ function parseArgs(argv) {
       opts.forceUpdateCheck = true;
       continue;
     }
+    if (a === '--remote-control' || a === '--rc') {
+      opts.remoteControl = true;
+      if (argv[i + 1] && !String(argv[i + 1]).startsWith('-')) {
+        opts.remoteControlName = argv[i + 1];
+        i += 1;
+      }
+      continue;
+    }
+    if (a.startsWith('--remote-control=')) {
+      opts.remoteControl = true;
+      opts.remoteControlName = a.slice('--remote-control='.length);
+      continue;
+    }
+    if (a === '--remote-cloud' || a === '--cloud' || a === '--relay') {
+      opts.remoteControl = true;
+      opts.remoteControlCloud = true;
+      if (argv[i + 1] && !String(argv[i + 1]).startsWith('-')) {
+        opts.remoteControlName = argv[i + 1];
+        i += 1;
+      }
+      continue;
+    }
+    if ((a === '--remote-relay' || a === '--relay-url') && argv[i + 1]) {
+      opts.remoteControlRelayUrl = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if (a.startsWith('--remote-relay=')) {
+      opts.remoteControlRelayUrl = a.slice('--remote-relay='.length);
+      continue;
+    }
+    if (a.startsWith('--relay-url=')) {
+      opts.remoteControlRelayUrl = a.slice('--relay-url='.length);
+      continue;
+    }
+    if (a === '--remote-lan') {
+      opts.remoteControlHost = '0.0.0.0';
+      continue;
+    }
+    if ((a === '--remote-host' || a === '--rc-host') && argv[i + 1]) {
+      opts.remoteControlHost = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if (a.startsWith('--remote-host=')) {
+      opts.remoteControlHost = a.slice('--remote-host='.length);
+      continue;
+    }
+    if ((a === '--remote-port' || a === '--rc-port') && argv[i + 1]) {
+      opts.remoteControlPort = Number(argv[i + 1]) || 0;
+      i += 1;
+      continue;
+    }
+    if (a.startsWith('--remote-port=')) {
+      opts.remoteControlPort = Number(a.slice('--remote-port='.length)) || 0;
+      continue;
+    }
+    if ((a === '--name' || a === '--remote-name') && argv[i + 1]) {
+      opts.remoteControlName = argv[i + 1];
+      i += 1;
+      continue;
+    }
     if (a === '--login' || a === '--signin') {
       opts.login = true;
       continue;
@@ -147,6 +224,8 @@ function usage() {
   console.log('');
   console.log('Usage:');
   console.log(`  ${cliName} [options] [prompt]`);
+  console.log(`  ${cliName} remote-control [--name <title>] [--remote-lan]`);
+  console.log(`  ${cliName} remote-control --cloud [--name <title>]`);
   console.log(`  ${cliName} --api-key <apikey>`);
   console.log(`  ${cliName} "write a python function"`);
   console.log('');
@@ -166,15 +245,25 @@ function usage() {
   console.log('      --check-update  Check for updates now');
   console.log('      --no-update-check');
   console.log('                      Disable startup update check');
+  console.log('      --remote-control, --rc [name]');
+  console.log('                      Enable browser remote control for this session');
+  console.log('      --remote-cloud, --cloud');
+  console.log('                      Use bortex.site relay instead of opening a local port');
+  console.log('      --remote-relay <url>');
+  console.log('                      Remote relay base URL (default: current --url)');
+  console.log('      --remote-lan    Bind remote control to 0.0.0.0 for LAN/mobile access');
+  console.log('      --remote-host <host>, --remote-port <port>');
+  console.log('                      Remote control bind address');
   console.log('  -v, --version       Show version');
   console.log('  -h, --help          Show help');
   console.log('');
-  console.log('REPL commands: /agent on|off, /status, /exit, /help, /llm-config');
+  console.log('REPL commands: /agent on|off, /status, /remote-control, /exit, /help, /llm-config');
   console.log('Local tools:   /pwd, /cd, /ls, /tree, /read, /write, /append, /mkdir, /git, /ssh-status, /sys-status, /process-status, /port-status, /tool, /sh');
   console.log('');
   console.log('Environment:');
   console.log('  BORTEX_URL      Server URL');
   console.log('  BORTEX_API_KEY  API key');
+  console.log('  BORTEX_REMOTE_RELAY_URL  Remote Control cloud relay URL');
 }
 
 function formatMs(ms) {
@@ -3874,6 +3963,9 @@ function printLocalHelp() {
   console.log('  /sys-status         check system / runtime status');
   console.log('  /process-status     check running processes');
   console.log('  /port-status        check listening ports');
+  console.log('  /remote-control [name] [--lan|--host <host>|--port <port>]');
+  console.log('  /remote-control --cloud [name]');
+  console.log('  /remote-control stop');
   console.log('  /diff [unstaged|staged|all]');
   console.log('  /stage <file>|--all');
   console.log('  /unstage <file>|--all');
@@ -4107,6 +4199,616 @@ async function runGitApplyInline(opts, mode) {
   }
 }
 
+function escapeHtml(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function getRemoteLanAddresses(port, token) {
+  const out = [];
+  const nets = os.networkInterfaces();
+  Object.values(nets).forEach((entries) => {
+    (entries || []).forEach((entry) => {
+      if (!entry || entry.internal || entry.family !== 'IPv4') return;
+      out.push(`http://${entry.address}:${port}/?token=${encodeURIComponent(token)}`);
+    });
+  });
+  return out;
+}
+
+function sendJson(res, statusCode, payload) {
+  const body = JSON.stringify(payload);
+  res.writeHead(statusCode, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+    'content-length': Buffer.byteLength(body)
+  });
+  res.end(body);
+}
+
+function readHttpBody(req, maxBytes = 1024 * 1024) {
+  return new Promise((resolve, reject) => {
+    let size = 0;
+    const chunks = [];
+    req.on('data', (chunk) => {
+      size += chunk.length;
+      if (size > maxBytes) {
+        reject(new Error('request body too large'));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    req.on('error', reject);
+  });
+}
+
+function buildRemoteControlHtml(state) {
+  const title = escapeHtml(state.name || 'Bortex Remote Control');
+  const token = escapeHtml(state.token);
+  const cwd = escapeHtml(state.cwd || process.cwd());
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <title>${title}</title>
+  <style>
+    :root { color-scheme: light dark; font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+    body { margin: 0; background: #0f1115; color: #f4f7fb; }
+    main { max-width: 980px; margin: 0 auto; padding: 20px; }
+    header { display: flex; justify-content: space-between; gap: 16px; align-items: flex-start; border-bottom: 1px solid #2a2f3a; padding-bottom: 14px; }
+    h1 { font-size: 20px; margin: 0 0 6px; font-weight: 700; }
+    .meta { color: #9aa4b2; font-size: 13px; overflow-wrap: anywhere; }
+    .pill { border: 1px solid #334155; border-radius: 999px; padding: 6px 10px; color: #cbd5e1; font-size: 12px; white-space: nowrap; }
+    #log { margin: 18px 0; background: #080a0f; border: 1px solid #242a36; border-radius: 8px; min-height: 45vh; max-height: 62vh; overflow: auto; padding: 12px; }
+    .msg { border-bottom: 1px solid #151923; padding: 10px 0; white-space: pre-wrap; overflow-wrap: anywhere; }
+    .role { color: #8ab4ff; font-size: 12px; text-transform: uppercase; letter-spacing: .04em; margin-bottom: 4px; }
+    .assistant .role { color: #78d7a4; }
+    .system .role { color: #fbbf24; }
+    textarea { width: 100%; min-height: 92px; resize: vertical; border-radius: 8px; border: 1px solid #334155; background: #10141d; color: #f8fafc; padding: 12px; font: 14px/1.45 ui-monospace, SFMono-Regular, Consolas, monospace; box-sizing: border-box; }
+    .bar { display: flex; gap: 10px; margin-top: 10px; align-items: center; }
+    button { border: 0; border-radius: 8px; background: #2563eb; color: white; font-weight: 650; padding: 10px 14px; cursor: pointer; }
+    button:disabled { opacity: .55; cursor: not-allowed; }
+    .hint { color: #94a3b8; font-size: 12px; }
+    code { color: #bfdbfe; }
+  </style>
+</head>
+<body>
+  <main>
+    <header>
+      <div>
+        <h1>${title}</h1>
+        <div class="meta">cwd: <code>${cwd}</code></div>
+      </div>
+      <div id="status" class="pill">connecting</div>
+    </header>
+    <section id="log"></section>
+    <form id="form">
+      <textarea id="prompt" placeholder="Ask Bortex Code or run a slash command, e.g. /status, /tool-plan --run fix lint"></textarea>
+      <div class="bar">
+        <button id="send" type="submit">Send</button>
+        <span class="hint">Token-protected local session. Keep this URL private.</span>
+      </div>
+    </form>
+  </main>
+  <script>
+    const token = ${JSON.stringify(state.token)};
+    const logEl = document.getElementById('log');
+    const statusEl = document.getElementById('status');
+    const promptEl = document.getElementById('prompt');
+    const sendEl = document.getElementById('send');
+    let lastCount = -1;
+    function renderLog(items) {
+      if (!Array.isArray(items) || items.length === lastCount) return;
+      lastCount = items.length;
+      logEl.innerHTML = items.map((item) => {
+        const role = String(item.role || 'system');
+        const text = String(item.text || '');
+        return '<div class="msg ' + role.replace(/[^a-z0-9_-]/gi, '') + '"><div class="role">' + role + '</div><div>' +
+          text.replace(/[&<>"']/g, (c) => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c])) +
+          '</div></div>';
+      }).join('');
+      logEl.scrollTop = logEl.scrollHeight;
+    }
+    async function refresh() {
+      try {
+        const r = await fetch('/api/status?token=' + encodeURIComponent(token), { cache: 'no-store' });
+        const data = await r.json();
+        statusEl.textContent = data.busy ? 'running' : 'connected';
+        sendEl.disabled = !!data.busy;
+        renderLog(data.log || []);
+      } catch (err) {
+        statusEl.textContent = 'disconnected';
+      }
+    }
+    document.getElementById('form').addEventListener('submit', async (event) => {
+      event.preventDefault();
+      const text = promptEl.value.trim();
+      if (!text) return;
+      sendEl.disabled = true;
+      await fetch('/api/prompt?token=' + encodeURIComponent(token), {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ text })
+      }).catch(() => {});
+      promptEl.value = '';
+      await refresh();
+    });
+    promptEl.addEventListener('keydown', (event) => {
+      if ((event.ctrlKey || event.metaKey) && event.key === 'Enter') {
+        document.getElementById('form').requestSubmit();
+      }
+    });
+    refresh();
+    setInterval(refresh, 1200);
+  </script>
+</body>
+</html>`;
+}
+
+async function captureRemoteControlOutput(fn) {
+  let stdout = '';
+  let stderr = '';
+  const originalStdoutWrite = process.stdout.write;
+  const originalStderrWrite = process.stderr.write;
+  process.stdout.write = function patchedStdoutWrite(chunk, encoding, cb) {
+    stdout += Buffer.isBuffer(chunk) ? chunk.toString(typeof encoding === 'string' ? encoding : 'utf8') : String(chunk ?? '');
+    return originalStdoutWrite.apply(process.stdout, arguments);
+  };
+  process.stderr.write = function patchedStderrWrite(chunk, encoding, cb) {
+    stderr += Buffer.isBuffer(chunk) ? chunk.toString(typeof encoding === 'string' ? encoding : 'utf8') : String(chunk ?? '');
+    return originalStderrWrite.apply(process.stderr, arguments);
+  };
+  try {
+    await fn();
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+  }
+  return { stdout, stderr };
+}
+
+async function runRemoteControlPrompt(opts, text) {
+  const line = String(text || '').trim();
+  if (!line) return { ok: false, output: 'Empty prompt.' };
+  pushCliHistory(opts, `[remote] ${line}`);
+  try { saveCliWorkspaceState(opts); } catch (_err) {}
+  const captured = await captureRemoteControlOutput(async () => {
+    if (line === '/exit' || line === '/quit') {
+      console.log('Remote clients cannot exit the local terminal process. Stop it locally with Ctrl+C.');
+      return;
+    }
+    const localResult = await handleLocalCommand(opts, line);
+    if (localResult.handled) return;
+    const localIntent = classifyLocalPromptIntent(line);
+    if (localIntent?.command) {
+      const intentResult = await handleLocalCommand(opts, localIntent.command);
+      if (intentResult.handled) return;
+    }
+    const naturalFileAction = await runNaturalLocalFileAction(opts, line);
+    if (naturalFileAction.handled) return;
+    if (opts.offline) {
+      console.log('Offline mode: use slash commands and local tools from this remote session.');
+      return;
+    }
+    const data = await askServer(opts, line);
+    printResponse(opts, data);
+  });
+  const output = `${captured.stdout || ''}${captured.stderr || ''}`.trim();
+  return { ok: true, output: output || '(no output)' };
+}
+
+async function startRemoteControlServer(opts, overrides = {}) {
+  if (opts.remoteControlSession?.server) {
+    console.log(`Remote Control already active: ${opts.remoteControlSession.localUrl}`);
+    return opts.remoteControlSession;
+  }
+
+  const http = require('http');
+  const crypto = require('crypto');
+  const host = String(overrides.host || opts.remoteControlHost || '127.0.0.1').trim() || '127.0.0.1';
+  const port = Math.max(0, Math.min(65535, Number(overrides.port ?? opts.remoteControlPort ?? 0) || 0));
+  const token = crypto.randomBytes(24).toString('hex');
+  const state = {
+    id: crypto.randomUUID ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(16).slice(2)}`,
+    name: getRemoteControlDisplayName(opts, overrides),
+    host,
+    port,
+    token,
+    cwd: opts.cwd,
+    startedAt: Date.now(),
+    busy: false,
+    log: []
+  };
+  const appendLog = (role, text) => {
+    state.log.push({ role, text: String(text || ''), ts: Date.now() });
+    if (state.log.length > 200) state.log.splice(0, state.log.length - 200);
+  };
+  appendLog('system', `Remote Control started for ${state.cwd}`);
+
+  const isAuthorized = (req, urlObj) => {
+    const header = String(req.headers['x-bortex-remote-token'] || '');
+    const query = String(urlObj.searchParams.get('token') || '');
+    return header === token || query === token;
+  };
+
+  const server = http.createServer(async (req, res) => {
+    let urlObj;
+    try { urlObj = new URL(req.url, `http://${host === '0.0.0.0' ? '127.0.0.1' : host}`); } catch (_err) {
+      return sendJson(res, 400, { ok: false, error: 'bad url' });
+    }
+    if (req.method === 'GET' && urlObj.pathname === '/') {
+      if (!isAuthorized(req, urlObj)) {
+        res.writeHead(401, { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' });
+        return res.end('Unauthorized: missing or invalid token.');
+      }
+      const body = buildRemoteControlHtml(state);
+      res.writeHead(200, {
+        'content-type': 'text/html; charset=utf-8',
+        'cache-control': 'no-store',
+        'content-length': Buffer.byteLength(body)
+      });
+      return res.end(body);
+    }
+    if (!isAuthorized(req, urlObj)) return sendJson(res, 401, { ok: false, error: 'unauthorized' });
+    if (req.method === 'GET' && urlObj.pathname === '/api/status') {
+      return sendJson(res, 200, {
+        ok: true,
+        id: state.id,
+        name: state.name,
+        version: CLI_VERSION,
+        cwd: opts.cwd,
+        agent: !!opts.agent,
+        busy: !!state.busy,
+        startedAt: state.startedAt,
+        log: state.log
+      });
+    }
+    if (req.method === 'POST' && urlObj.pathname === '/api/prompt') {
+      if (state.busy) return sendJson(res, 409, { ok: false, error: 'remote session busy' });
+      state.busy = true;
+      try {
+        const raw = await readHttpBody(req);
+        let payload;
+        try { payload = JSON.parse(raw || '{}'); } catch (_err) { payload = { text: raw }; }
+        const text = String(payload.text || payload.prompt || '').trim();
+        if (!text) return sendJson(res, 400, { ok: false, error: 'empty prompt' });
+        appendLog('user', text);
+        const result = await runRemoteControlPrompt(opts, text);
+        appendLog('assistant', result.output || '(no output)');
+        return sendJson(res, result.ok ? 200 : 500, { ok: !!result.ok, output: result.output || '' });
+      } catch (err) {
+        appendLog('system', `Error: ${err.message}`);
+        return sendJson(res, 500, { ok: false, error: err.message });
+      } finally {
+        state.busy = false;
+      }
+    }
+    return sendJson(res, 404, { ok: false, error: 'not found' });
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(port, host, resolve);
+  });
+  const actualPort = server.address().port;
+  state.port = actualPort;
+  state.server = server;
+  state.localUrl = `http://127.0.0.1:${actualPort}/?token=${encodeURIComponent(token)}`;
+  state.lanUrls = getRemoteLanAddresses(actualPort, token);
+  state.stop = () => new Promise((resolve) => server.close(() => resolve()));
+  opts.remoteControlSession = state;
+
+  console.log(`Remote Control active: ${state.name}`);
+  console.log(`Local URL: ${state.localUrl}`);
+  if (host === '0.0.0.0' || host === '::') {
+    if (state.lanUrls.length) {
+      console.log('LAN URLs:');
+      state.lanUrls.forEach((u) => console.log(`  ${u}`));
+    }
+    console.log('Security: keep this tokenized URL private. Anyone with the URL can control this Bortex Code session.');
+  } else {
+    console.log('Mobile/LAN access: restart with --remote-lan or /remote-control --lan to bind on 0.0.0.0.');
+  }
+  return state;
+}
+
+async function stopRemoteControlServer(opts) {
+  const state = opts.remoteControlSession;
+  if (!state?.server) {
+    console.log('Remote Control is not active.');
+    return false;
+  }
+  await state.stop();
+  opts.remoteControlSession = null;
+  console.log('Remote Control stopped.');
+  return true;
+}
+
+function getRemoteControlDisplayName(opts, overrides = {}) {
+  return String(overrides.name || opts.remoteControlName || path.basename(opts.cwd || process.cwd()) || os.hostname() || 'Bortex Code').trim();
+}
+
+function getRemoteControlStatus(opts) {
+  if (opts.remoteControlCloudSession?.active) return 'cloud';
+  if (opts.remoteControlSession?.server) return 'local';
+  return 'off';
+}
+
+function getRemoteControlRelayBase(opts, overrides = {}) {
+  return String(overrides.relayUrl || opts.remoteControlRelayUrl || opts.url || 'https://bortex.site').replace(/\/+$/, '');
+}
+
+function remoteControlSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function withRemoteControlQuery(rawUrl, baseUrl, params = {}) {
+  const urlObj = new URL(rawUrl, baseUrl);
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== undefined && value !== null && value !== '') {
+      urlObj.searchParams.set(key, String(value));
+    }
+  });
+  return urlObj.toString();
+}
+
+async function fetchRemoteControlJson(url, options = {}, timeoutMs = 30000) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  if (typeof timeoutId.unref === 'function') timeoutId.unref();
+  try {
+    const res = await fetch(url, {
+      ...options,
+      headers: {
+        Accept: 'application/json',
+        ...(options.headers || {})
+      },
+      signal: controller.signal
+    });
+    const text = await res.text();
+    let data = null;
+    if (text) {
+      try { data = JSON.parse(text); } catch (_err) { data = null; }
+    }
+    if (!res.ok) {
+      const detail = data?.error || data?.message || text || res.statusText || 'request failed';
+      throw new Error(`HTTP ${res.status}: ${detail}`);
+    }
+    if (data?.ok === false) {
+      throw new Error(data.error || data.message || 'request failed');
+    }
+    return data || {};
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+async function postCloudRemoteHeartbeat(state) {
+  const heartbeatUrl = withRemoteControlQuery(
+    state.heartbeatUrl,
+    state.baseUrl,
+    { agentToken: state.agentToken }
+  );
+  await fetchRemoteControlJson(heartbeatUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ cwd: state.cwd, version: CLI_VERSION })
+  }, 12000);
+}
+
+async function postCloudRemoteResult(state, commandId, result) {
+  const resultUrl = withRemoteControlQuery(
+    state.resultUrl,
+    state.baseUrl,
+    { agentToken: state.agentToken }
+  );
+  await fetchRemoteControlJson(resultUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      commandId,
+      ok: !!result.ok,
+      output: String(result.output || '')
+    })
+  }, 35000);
+}
+
+async function pollCloudRemoteControlLoop(opts, state) {
+  let lastHeartbeatAt = 0;
+  while (state.active) {
+    let delayMs = 1200;
+    try {
+      const pollUrl = withRemoteControlQuery(
+        state.pollUrl,
+        state.baseUrl,
+        { agentToken: state.agentToken, after: state.lastCommandId || 0 }
+      );
+      const data = await fetchRemoteControlJson(pollUrl, { method: 'GET' }, 35000);
+      const commands = Array.isArray(data.commands) ? data.commands : [];
+      state.lastSeenAt = Date.now();
+      state.errorCount = 0;
+
+      for (const command of commands) {
+        if (!state.active) break;
+        const commandId = Number(command?.id || 0);
+        if (commandId > (state.lastCommandId || 0)) state.lastCommandId = commandId;
+        const text = String(command?.text || command?.prompt || '').trim();
+        if (!text) continue;
+        state.busy = true;
+        let result;
+        try {
+          result = await runRemoteControlPrompt(opts, text);
+        } catch (err) {
+          result = { ok: false, output: err.stack || err.message || String(err) };
+        } finally {
+          state.busy = false;
+        }
+        await postCloudRemoteResult(state, commandId, result);
+      }
+
+      if (!commands.length && Date.now() - lastHeartbeatAt > 10000) {
+        lastHeartbeatAt = Date.now();
+        await postCloudRemoteHeartbeat(state);
+      }
+      if (commands.length) delayMs = 250;
+    } catch (err) {
+      if (state.active) {
+        state.errorCount = (state.errorCount || 0) + 1;
+        const now = Date.now();
+        if (!state.lastErrorAt || now - state.lastErrorAt > 15000) {
+          console.error(`Cloud Remote Control error: ${err.message || String(err)}`);
+          state.lastErrorAt = now;
+        }
+        delayMs = Math.min(5000, 1000 + state.errorCount * 500);
+      }
+    } finally {
+      state.busy = false;
+    }
+    await remoteControlSleep(delayMs);
+  }
+}
+
+async function startCloudRemoteControlSession(opts, overrides = {}) {
+  if (opts.remoteControlCloudSession?.active) {
+    console.log(`Cloud Remote Control already active: ${opts.remoteControlCloudSession.url}`);
+    return opts.remoteControlCloudSession;
+  }
+
+  const baseUrl = getRemoteControlRelayBase(opts, overrides);
+  const name = getRemoteControlDisplayName(opts, overrides);
+  const payload = {
+    name,
+    cwd: opts.cwd,
+    version: CLI_VERSION,
+    machine: os.hostname(),
+    platform: process.platform,
+    node: process.version,
+    mode: opts.agent ? 'agent' : 'chat'
+  };
+  const data = await fetchRemoteControlJson(`${baseUrl}/api/bortex-code/remote/register`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload)
+  }, 30000);
+
+  const sessionId = String(data.sessionId || '').trim();
+  const agentToken = String(data.agentToken || '').trim();
+  if (!sessionId || !agentToken) {
+    throw new Error('Remote relay registration did not return a session token.');
+  }
+
+  const state = {
+    active: true,
+    cloud: true,
+    baseUrl,
+    sessionId,
+    agentToken,
+    clientToken: data.clientToken || '',
+    name,
+    cwd: opts.cwd,
+    url: data.url || `${baseUrl}/bortex-code/remote?session=${encodeURIComponent(sessionId)}`,
+    pollUrl: data.pollUrl || `${baseUrl}/api/bortex-code/remote/session/${encodeURIComponent(sessionId)}/poll`,
+    resultUrl: data.resultUrl || `${baseUrl}/api/bortex-code/remote/session/${encodeURIComponent(sessionId)}/result`,
+    heartbeatUrl: data.heartbeatUrl || `${baseUrl}/api/bortex-code/remote/session/${encodeURIComponent(sessionId)}/heartbeat`,
+    lastCommandId: 0,
+    startedAt: Date.now(),
+    busy: false,
+    errorCount: 0
+  };
+  state.stop = async () => {
+    state.active = false;
+  };
+  opts.remoteControlCloudSession = state;
+  state.pollPromise = pollCloudRemoteControlLoop(opts, state).catch((err) => {
+    if (state.active) console.error(`Cloud Remote Control stopped unexpectedly: ${err.message || String(err)}`);
+  });
+
+  console.log(`Cloud Remote Control active: ${state.name}`);
+  console.log(`URL: ${state.url}`);
+  console.log('No inbound port required. Keep this process running.');
+  console.log('Security: keep this tokenized URL private. Anyone with the URL can control this Bortex Code session.');
+  return state;
+}
+
+async function stopCloudRemoteControlSession(opts) {
+  const state = opts.remoteControlCloudSession;
+  if (!state?.active) {
+    console.log('Cloud Remote Control is not active.');
+    return false;
+  }
+  await state.stop();
+  opts.remoteControlCloudSession = null;
+  console.log('Cloud Remote Control stopped.');
+  return true;
+}
+
+function parseRemoteControlSlashArgs(rest = [], opts = {}) {
+  const out = {
+    name: '',
+    host: opts.remoteControlHost || '127.0.0.1',
+    port: Number(opts.remoteControlPort || 0) || 0,
+    relayUrl: opts.remoteControlRelayUrl || '',
+    cloud: false
+  };
+  const nameParts = [];
+  for (let i = 0; i < rest.length; i += 1) {
+    const a = String(rest[i] || '');
+    if (a === 'stop' || a === 'off' || a === 'disconnect') {
+      out.stop = true;
+      continue;
+    }
+    if (a === '--lan' || a === '--remote-lan') {
+      out.host = '0.0.0.0';
+      continue;
+    }
+    if (a === 'cloud' || a === '--cloud' || a === '--remote-cloud' || a === '--relay') {
+      out.cloud = true;
+      continue;
+    }
+    if ((a === '--relay-url' || a === '--remote-relay') && rest[i + 1]) {
+      out.relayUrl = String(rest[i + 1]);
+      i += 1;
+      continue;
+    }
+    if (a.startsWith('--relay-url=')) {
+      out.relayUrl = a.slice('--relay-url='.length);
+      continue;
+    }
+    if (a.startsWith('--remote-relay=')) {
+      out.relayUrl = a.slice('--remote-relay='.length);
+      continue;
+    }
+    if ((a === '--host' || a === '--remote-host') && rest[i + 1]) {
+      out.host = String(rest[i + 1]);
+      i += 1;
+      continue;
+    }
+    if (a.startsWith('--host=')) {
+      out.host = a.slice('--host='.length);
+      continue;
+    }
+    if ((a === '--port' || a === '--remote-port') && rest[i + 1]) {
+      out.port = Number(rest[i + 1]) || 0;
+      i += 1;
+      continue;
+    }
+    if (a.startsWith('--port=')) {
+      out.port = Number(a.slice('--port='.length)) || 0;
+      continue;
+    }
+    nameParts.push(a);
+  }
+  out.name = nameParts.join(' ').trim();
+  return out;
+}
+
 function printAgentLocalHelp() {
   console.log('Agent-local (planner CLI):');
   console.log('  /agent-local <goal>   genera un piano operativo CLI');
@@ -5390,6 +6092,38 @@ async function handleLocalCommand(opts, line) {
     });
     return { handled: true };
   }
+  if (lc === '/agent') {
+    const v = String(rest[0] || '').toLowerCase();
+    if (!['on', 'off', 'true', 'false', '1', '0'].includes(v)) {
+      console.log('Uso: /agent on|off');
+      return { handled: true };
+    }
+    opts.agent = v === 'on' || v === 'true' || v === '1';
+    console.log(`Mode: ${opts.agent ? 'agent' : 'chat'}`);
+    return { handled: true };
+  }
+  if (lc === '/status') {
+    const todoItems = Array.isArray(opts.todo) ? opts.todo : [];
+    const done = todoItems.filter((t) => t.done).length;
+    const runPending = Array.isArray(opts.runState?.steps) ? opts.runState.steps.filter((s) => s.status === 'pending').length : 0;
+    console.log(formatModeLine(opts));
+    console.log(`Todo: ${done}/${todoItems.length} | Plan: ${opts.plan?.goal ? 'active' : 'none'} | Run: ${opts.runState?.goal ? `active (${runPending} pending)` : 'none'} | Remote: ${getRemoteControlStatus(opts)}`);
+    return { handled: true };
+  }
+  if (lc === '/remote-control' || lc === '/remote' || lc === '/rc') {
+    const parsed = parseRemoteControlSlashArgs(rest, opts);
+    if (parsed.stop || opts.remoteControlSession?.server || opts.remoteControlCloudSession?.active) {
+      if (opts.remoteControlSession?.server) await stopRemoteControlServer(opts);
+      if (opts.remoteControlCloudSession?.active) await stopCloudRemoteControlSession(opts);
+      return { handled: true };
+    }
+    if (parsed.cloud) {
+      await startCloudRemoteControlSession(opts, parsed);
+      return { handled: true };
+    }
+    await startRemoteControlServer(opts, parsed);
+    return { handled: true };
+  }
   if (lc === '/pwd') {
     console.log(opts.cwd);
     return { handled: true };
@@ -6551,6 +7285,10 @@ const SLASH_COMMANDS = [
   ['/status', 'Show session and workspace state'],
   ['/commands', 'Show this command menu'],
   ['/help', 'Show command help'],
+  ['/remote-control [name]', 'Control this local session from a browser'],
+  ['/remote-control --lan', 'Expose Remote Control on the local network'],
+  ['/remote-control --cloud', 'Control this session through bortex.site relay'],
+  ['/rc', 'Toggle Remote Control'],
   ['/llm-config show', 'Show cached LLM configuration'],
   ['/llm-config sync', 'Sync LLM configuration from Bortex'],
   ['/pwd', 'Show current working directory'],
@@ -6725,6 +7463,20 @@ async function runRepl(opts) {
     return lines.join('\n');
   };
   opts._askInput = async (prompt) => new Promise((resolve) => rl.question(prompt, resolve));
+  if (opts.remoteControl) {
+    if (opts.remoteControlCloud) {
+      await startCloudRemoteControlSession(opts, {
+        name: opts.remoteControlName,
+        relayUrl: opts.remoteControlRelayUrl
+      });
+    } else {
+      await startRemoteControlServer(opts, {
+        name: opts.remoteControlName,
+        host: opts.remoteControlHost,
+        port: opts.remoteControlPort
+      });
+    }
+  }
 
   const question = () => new Promise((resolve) => {
     const prompt = `bortex:${opts.agent ? 'agent' : 'chat'}> `;
@@ -6749,7 +7501,7 @@ async function runRepl(opts) {
       const done = todoItems.filter((t) => t.done).length;
       console.log(formatModeLine(opts));
       const runPending = Array.isArray(opts.runState?.steps) ? opts.runState.steps.filter((s) => s.status === 'pending').length : 0;
-      console.log(`Todo: ${done}/${todoItems.length} | Plan: ${opts.plan?.goal ? 'active' : 'none'} | Run: ${opts.runState?.goal ? `active (${runPending} pending)` : 'none'}`);
+      console.log(`Todo: ${done}/${todoItems.length} | Plan: ${opts.plan?.goal ? 'active' : 'none'} | Run: ${opts.runState?.goal ? `active (${runPending} pending)` : 'none'} | Remote: ${getRemoteControlStatus(opts)}`);
       continue;
     }
     if (line === '/help') {
@@ -6796,6 +7548,12 @@ async function runRepl(opts) {
 
   rl.close();
   uninstallSlashMenu();
+  if (opts.remoteControlSession?.server) {
+    await stopRemoteControlServer(opts);
+  }
+  if (opts.remoteControlCloudSession?.active) {
+    await stopCloudRemoteControlSession(opts);
+  }
   try { saveCliWorkspaceState(opts); } catch (_err) { }
   delete opts._readMultiline;
   delete opts._askInput;
@@ -6846,6 +7604,39 @@ async function main() {
     opts.sessionReused = false;
   }
 
+  if (opts.remoteControlServerMode) {
+    if (opts.remoteControlCloud) {
+      await startCloudRemoteControlSession(opts, {
+        name: opts.remoteControlName,
+        relayUrl: opts.remoteControlRelayUrl
+      });
+    } else {
+      await startRemoteControlServer(opts, {
+        name: opts.remoteControlName,
+        host: opts.remoteControlHost,
+        port: opts.remoteControlPort
+      });
+    }
+    console.log('Server mode: keep this process running. Press Ctrl+C to stop Remote Control.');
+    await new Promise((resolve) => {
+      let stopping = false;
+      const stop = async () => {
+        if (stopping) return;
+        stopping = true;
+        if (opts.remoteControlSession?.server) {
+          try { await stopRemoteControlServer(opts); } catch (_err) {}
+        }
+        if (opts.remoteControlCloudSession?.active) {
+          try { await stopCloudRemoteControlSession(opts); } catch (_err) {}
+        }
+        resolve();
+      };
+      process.once('SIGINT', stop);
+      process.once('SIGTERM', stop);
+    });
+    return;
+  }
+
   if (opts.prompt) {
     await runSinglePrompt(opts);
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bortexcode",
-  "version": "1.2.8",
+  "version": "1.3.0",
   "description": "Bortex Code CLI - AI coding assistant powered by bortex.site",
   "homepage": "https://bortex.site",
   "license": "UNLICENSED",