bortexcode 1.4.0 → 1.6.0

package/README.md

@@ -107,6 +107,10 @@ The browser UI includes Cancel and Revoke controls. Cancel requests termination
 of the running command. Revoke invalidates the tokenized URL and stops the
 server-mode cloud session.
 
+Remote output streams live for shell commands and CLI output: stdout/stderr
+chunks appear in the browser while the command is still running, then the final
+result replaces the streaming buffer when the command completes.
+
 Inside the REPL:
 
 ```text

package/bin/bortex.js

@@ -3983,6 +3983,13 @@ function runChild(command, args, { cwd, shell = false } = {}) {
     let stderr = '';
     let settled = false;
     let canceled = false;
+    const emitChunk = (stream, text) => {
+      try {
+        if (cancelState && typeof cancelState.onChunk === 'function') {
+          cancelState.onChunk(stream, text);
+        }
+      } catch (_err) {}
+    };
     const finish = (result) => {
       if (settled) return;
       settled = true;
@@ -3996,8 +4003,16 @@ function runChild(command, args, { cwd, shell = false } = {}) {
       }
     }, 250) : null;
     if (cancelTimer && typeof cancelTimer.unref === 'function') cancelTimer.unref();
-    child.stdout.on('data', (c) => { stdout += String(c || ''); });
-    child.stderr.on('data', (c) => { stderr += String(c || ''); });
+    child.stdout.on('data', (c) => {
+      const text = String(c || '');
+      stdout += text;
+      emitChunk('stdout', text);
+    });
+    child.stderr.on('data', (c) => {
+      const text = String(c || '');
+      stderr += text;
+      emitChunk('stderr', text);
+    });
     child.on('error', (err) => finish({ ok: false, code: null, stdout, stderr: err.message }));
     child.on('close', (code) => {
       const finalStderr = canceled
@@ -4363,10 +4378,12 @@ function buildRemoteControlHtml(state) {
     const statusEl = document.getElementById('status');
     const promptEl = document.getElementById('prompt');
     const sendEl = document.getElementById('send');
-    let lastCount = -1;
+    let lastSignature = '';
     function renderLog(items) {
-      if (!Array.isArray(items) || items.length === lastCount) return;
-      lastCount = items.length;
+      if (!Array.isArray(items)) return;
+      const signature = items.map((item, index) => String(item.id || index) + ':' + String(item.ts || '') + ':' + String(item.text || '').length).join('|');
+      if (signature === lastSignature) return;
+      lastSignature = signature;
       logEl.innerHTML = items.map((item) => {
         const role = String(item.role || 'system');
         const text = String(item.text || '');
@@ -4412,17 +4429,21 @@ function buildRemoteControlHtml(state) {
 </html>`;
 }
 
-async function captureRemoteControlOutput(fn) {
+async function captureRemoteControlOutput(fn, onChunk) {
   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 ?? '');
+    const text = Buffer.isBuffer(chunk) ? chunk.toString(typeof encoding === 'string' ? encoding : 'utf8') : String(chunk ?? '');
+    stdout += text;
+    try { if (typeof onChunk === 'function') onChunk('stdout', text); } catch (_err) {}
     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 ?? '');
+    const text = Buffer.isBuffer(chunk) ? chunk.toString(typeof encoding === 'string' ? encoding : 'utf8') : String(chunk ?? '');
+    stderr += text;
+    try { if (typeof onChunk === 'function') onChunk('stderr', text); } catch (_err) {}
     return originalStderrWrite.apply(process.stderr, arguments);
   };
   try {
@@ -4434,7 +4455,7 @@ async function captureRemoteControlOutput(fn) {
   return { stdout, stderr };
 }
 
-async function runRemoteControlPrompt(opts, text) {
+async function runRemoteControlPrompt(opts, text, onChunk) {
   const line = String(text || '').trim();
   if (!line) return { ok: false, output: 'Empty prompt.' };
   const permission = assessRemoteControlPromptPermission(opts, line);
@@ -4447,7 +4468,10 @@ async function runRemoteControlPrompt(opts, text) {
   pushCliHistory(opts, `[remote] ${line}`);
   try { saveCliWorkspaceState(opts); } catch (_err) {}
   const previousRemoteExecution = ACTIVE_REMOTE_CONTROL_EXECUTION_STATE;
-  ACTIVE_REMOTE_CONTROL_EXECUTION_STATE = opts._remoteControlExecutionState || null;
+  ACTIVE_REMOTE_CONTROL_EXECUTION_STATE = {
+    ...(opts._remoteControlExecutionState || {}),
+    onChunk
+  };
   let captured;
   try {
     captured = await captureRemoteControlOutput(async () => {
@@ -4477,7 +4501,7 @@ async function runRemoteControlPrompt(opts, text) {
       }
       const data = await askServer(opts, line);
       printResponse(opts, data);
-    });
+    }, onChunk);
   } finally {
     ACTIVE_REMOTE_CONTROL_EXECUTION_STATE = previousRemoteExecution;
   }
@@ -4506,10 +4530,37 @@ async function startRemoteControlServer(opts, overrides = {}) {
     cwd: opts.cwd,
     startedAt: Date.now(),
     busy: false,
-    log: []
+    log: [],
+    nextLogId: 1
   };
   const appendLog = (role, text) => {
-    state.log.push({ role, text: String(text || ''), ts: Date.now() });
+    state.log.push({ id: state.nextLogId++, role, text: String(text || ''), ts: Date.now() });
+    if (state.log.length > 200) state.log.splice(0, state.log.length - 200);
+  };
+  const appendStreamChunk = (streamKey, text, commandId) => {
+    const chunk = String(text || '');
+    if (!chunk) return;
+    let item = null;
+    for (let i = state.log.length - 1; i >= 0; i -= 1) {
+      const candidate = state.log[i];
+      if (candidate?.streaming && candidate.commandId === commandId) {
+        item = candidate;
+        break;
+      }
+    }
+    if (!item) {
+      item = {
+        id: state.nextLogId++,
+        role: streamKey === 'stderr' ? 'system' : 'assistant',
+        text: '',
+        ts: Date.now(),
+        streaming: true,
+        commandId
+      };
+      state.log.push(item);
+    }
+    item.text = `${item.text || ''}${chunk}`.slice(-20000);
+    item.ts = Date.now();
     if (state.log.length > 200) state.log.splice(0, state.log.length - 200);
   };
   appendLog('system', `Remote Control started for ${state.cwd}`);
@@ -4562,8 +4613,17 @@ async function startRemoteControlServer(opts, overrides = {}) {
         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)');
+        const commandId = state.nextLogId;
+        const result = await runRemoteControlPrompt(opts, text, (stream, chunk) => appendStreamChunk(stream, chunk, commandId));
+        const streamLog = state.log.find((item) => item?.streaming && item.commandId === commandId);
+        if (streamLog) {
+          streamLog.streaming = false;
+          streamLog.role = result.ok ? 'assistant' : 'system';
+          streamLog.text = result.output || streamLog.text || '(no output)';
+          streamLog.ts = Date.now();
+        } else {
+          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}`);
@@ -4692,6 +4752,7 @@ function assessRemoteControlPromptPermission(opts, line) {
   const mode = getRemoteControlPermissionMode(opts);
   const text = String(line || '').trim();
   if (!text) return { ok: false, mode, reason: 'empty prompt' };
+  if (opts._remoteControlApprovalBypass) return { ok: true, mode, approved: true };
   if (mode === 'full') return { ok: true, mode };
   if (!text.startsWith('/')) return { ok: true, mode, skipNaturalActions: true };
   if (mode === 'read-only') {
@@ -4777,6 +4838,91 @@ async function postCloudRemoteResult(state, commandId, result) {
   }, 35000);
 }
 
+async function postCloudRemoteChunk(state, commandId, stream, text) {
+  if (!state?.chunkUrl || !text) return;
+  const chunkUrl = withRemoteControlQuery(
+    state.chunkUrl,
+    state.baseUrl,
+    { agentToken: state.agentToken }
+  );
+  await fetchRemoteControlJson(chunkUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      commandId,
+      stream: stream === 'stderr' ? 'stderr' : 'stdout',
+      text: String(text || '')
+    })
+  }, 12000);
+}
+
+async function postCloudRemoteApprovalRequest(state, commandId, permission, text) {
+  const approvalUrl = withRemoteControlQuery(
+    state.approvalUrl || `${state.baseUrl}/api/bortex-code/remote/session/${encodeURIComponent(state.sessionId)}/approval-request`,
+    state.baseUrl,
+    { agentToken: state.agentToken }
+  );
+  await fetchRemoteControlJson(approvalUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      commandId,
+      text: String(text || ''),
+      mode: permission?.mode || state.permission || 'balanced',
+      reason: permission?.reason || 'This command requires explicit approval.'
+    })
+  }, 12000);
+}
+
+function createCloudRemoteChunkStreamer(state, commandId) {
+  const queue = [];
+  let timer = null;
+  let flushing = false;
+  const schedule = (ms = 250) => {
+    if (timer) return;
+    timer = setTimeout(() => {
+      timer = null;
+      flush().catch(() => {});
+    }, ms);
+    if (typeof timer.unref === 'function') timer.unref();
+  };
+  const flush = async () => {
+    if (flushing) return;
+    flushing = true;
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    try {
+      while (queue.length) {
+        const pending = queue.splice(0, queue.length);
+        const grouped = new Map();
+        for (const item of pending) {
+          const stream = item.stream === 'stderr' ? 'stderr' : 'stdout';
+          grouped.set(stream, `${grouped.get(stream) || ''}${item.text || ''}`);
+        }
+        for (const [stream, text] of grouped.entries()) {
+          if (!text) continue;
+          await postCloudRemoteChunk(state, commandId, stream, text).catch((err) => {
+            state.lastChunkError = err.message || String(err);
+          });
+        }
+      }
+    } finally {
+      flushing = false;
+    }
+  };
+  return {
+    push(stream, text) {
+      if (!text || !state.active) return;
+      queue.push({ stream, text: String(text || '') });
+      const queuedSize = queue.reduce((n, item) => n + String(item.text || '').length, 0);
+      schedule(queuedSize > 3000 ? 25 : 250);
+    },
+    flush
+  };
+}
+
 async function pollCloudRemoteControlControlLoop(state) {
   while (state.active) {
     try {
@@ -4845,16 +4991,42 @@ async function pollCloudRemoteControlLoop(opts, state) {
         if (!text) continue;
         state.cancelRequested = false;
         state.cancelCommandId = null;
+        const approved = !!command.approved;
+        const permission = assessRemoteControlPromptPermission(opts, text);
+        if (!permission.ok && !approved) {
+          state.busy = true;
+          opts._remoteControlExecutionState = state;
+          try {
+            await postCloudRemoteApprovalRequest(state, commandId, permission, text);
+            console.log(`Cloud Remote Control approval requested for command #${commandId}: ${permission.reason}.`);
+          } catch (err) {
+            const message = err.message || String(err);
+            await postCloudRemoteResult(state, commandId, {
+              ok: false,
+              output: `Approval request failed: ${message}`
+            }).catch(() => {});
+          } finally {
+            state.busy = false;
+            delete opts._remoteControlExecutionState;
+          }
+          continue;
+        }
         state.busy = true;
         opts._remoteControlExecutionState = state;
+        const streamer = createCloudRemoteChunkStreamer(state, commandId);
         let result;
+        const previousApprovalBypass = opts._remoteControlApprovalBypass;
+        if (approved) opts._remoteControlApprovalBypass = true;
         try {
-          result = await runRemoteControlPrompt(opts, text);
+          result = await runRemoteControlPrompt(opts, text, (stream, chunk) => streamer.push(stream, chunk));
         } catch (err) {
           result = { ok: false, output: err.stack || err.message || String(err) };
         } finally {
+          await streamer.flush().catch(() => {});
           state.busy = false;
           delete opts._remoteControlExecutionState;
+          if (previousApprovalBypass === undefined) delete opts._remoteControlApprovalBypass;
+          else opts._remoteControlApprovalBypass = previousApprovalBypass;
         }
         if (state.cancelRequested && result.ok) {
           result = { ok: false, output: 'Canceled by remote request.' };
@@ -4903,6 +5075,11 @@ async function startCloudRemoteControlSession(opts, overrides = {}) {
   const name = getRemoteControlDisplayName(opts, overrides);
   const permission = getRemoteControlPermissionMode(opts, overrides);
   opts.remoteControlPermission = permission;
+  const sharedSettings = loadSharedSettings();
+  const registerCookie = getCookieHeaderFromSharedSettings();
+  const registerApiKey = String(
+    opts.apiKey || process.env.BORTEX_API_KEY || sharedSettings?.llmSettings?.apiKey || ''
+  ).trim();
   const payload = {
     name,
     cwd: opts.cwd,
@@ -4913,9 +5090,12 @@ async function startCloudRemoteControlSession(opts, overrides = {}) {
     mode: opts.agent ? 'agent' : 'chat',
     permission
   };
+  const registerHeaders = { 'Content-Type': 'application/json' };
+  if (registerCookie) registerHeaders.Cookie = registerCookie;
+  if (registerApiKey) registerHeaders['x-api-key'] = registerApiKey;
   const data = await fetchRemoteControlJson(`${baseUrl}/api/bortex-code/remote/register`, {
     method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
+    headers: registerHeaders,
     body: JSON.stringify(payload)
   }, 30000);
 
@@ -4938,6 +5118,8 @@ async function startCloudRemoteControlSession(opts, overrides = {}) {
     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`,
+    chunkUrl: data.chunkUrl || `${baseUrl}/api/bortex-code/remote/session/${encodeURIComponent(sessionId)}/chunk`,
+    approvalUrl: data.approvalUrl || `${baseUrl}/api/bortex-code/remote/session/${encodeURIComponent(sessionId)}/approval-request`,
     heartbeatUrl: data.heartbeatUrl || `${baseUrl}/api/bortex-code/remote/session/${encodeURIComponent(sessionId)}/heartbeat`,
     controlUrl: data.controlUrl || `${baseUrl}/api/bortex-code/remote/session/${encodeURIComponent(sessionId)}/control`,
     lastCommandId: 0,
@@ -4958,6 +5140,8 @@ async function startCloudRemoteControlSession(opts, overrides = {}) {
 
   console.log(`Cloud Remote Control active: ${state.name}`);
   console.log(`URL: ${state.url}`);
+  if (data.accountUrl) console.log(`Account URL: ${data.accountUrl}`);
+  if (data.sessionsUrl) console.log(`Sessions: ${data.sessionsUrl}`);
   console.log(`Permission: ${state.permission}`);
   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.');

package/package.json

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