@remcp/runtime 0.2.188 → 0.2.190

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.2.190 — 2026-10-27
+
+- Publish the runtime alongside the compatible ReMCP agent; the device HTTPS network probe is agent-owned and does not add runtime MCP tools.
+- Preserve the existing 84-tool runtime contract while verifying public package source and release parity.
+
 ## 0.2.186 — 2026-10-26
 
 - Return from same-document CDP navigation promptly when Page.navigate provides no new loaderId instead of awaiting a full load event that never fires.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.188",
+  "version": "0.2.190",
   "description": "First-party ReMCP local device runtime: filesystem, terminal, computer-use, browser, diagnostics and document tools over MCP.",
   "type": "module",
   "license": "MIT",

package/src/core-catalog-part2.mjs

@@ -228,8 +228,8 @@ export const coreToolDefinitionsPart2 = [
       properties: {
         pid: { type: 'number', description: 'Session pid returned by start_process.' },
         offset: { type: 'number', description: 'Zero-based line number to start from, counted across everything the session has produced; a negative value reads the last N lines. Omit for new output. Lines evicted by the buffer cap are no longer available.' },
-        length: { type: 'number', description: 'Maximum number of lines to return.' },
-        timeout_ms: { type: 'number', description: 'How long to wait for new output when no offset is given, in milliseconds.' },
+        length: { type: 'number', description: 'Maximum number of lines to return per call (default 200). Without offset, unreturned lines remain available; use hasMore to fetch the next page.' },
+        timeout_ms: { type: 'number', description: 'With no offset, wait up to this many milliseconds for output/exit; 0 returns immediately (default). Use 1000–2000 to avoid repeated remote polls when output is expected.' },
       },
       required: ['pid'],
       additionalProperties: false,
@@ -288,7 +288,7 @@ export const coreToolDefinitionsPart2 = [
       required: ['pid'],
       additionalProperties: false,
     },
-    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
     outputSchema: TERMINATE_PROCESS_OUTPUT_SCHEMA,
     handler: terminalToolHandlers.force_terminate,
   },
@@ -335,7 +335,7 @@ export const coreToolDefinitionsPart2 = [
       required: ['pid'],
       additionalProperties: false,
     },
-    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
     handler: systemToolHandlers.kill_process,
   },
   {

package/src/core-catalog-shared.mjs

@@ -45,7 +45,8 @@ export const READ_PROCESS_OUTPUT_SCHEMA = terminalOutputSchema({
   range:{ type:'string' },
   output:{ type:'string' },
   explicitOffset:{ type:'boolean' },
-}, ['range','output','explicitOffset']);
+  hasMore:{ type:'boolean' },
+}, ['range','output','explicitOffset','hasMore']);
 export const WAIT_PROCESS_OUTPUT_SCHEMA = terminalOutputSchema({
   pattern:{ type:'string' },
   matched:{ type:'boolean' },

package/src/sessions.mjs

@@ -37,13 +37,15 @@ function notify(session) {
 
 // A waiter whose timer fires first must remove itself, otherwise finished sessions keep
 // holding closures until the next append (which may never come).
-function waiter(session, timeoutMs) {
+function waiter(session, timeoutMs, signal = null) {
+  if (signal?.aborted) return Promise.resolve();
   return new Promise(resolve => {
     let settled = false;
     const finish = () => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
+      signal?.removeEventListener('abort', finish);
       const index = session.waiters.indexOf(finish);
       if (index !== -1) session.waiters.splice(index, 1);
       resolve();
@@ -51,6 +53,9 @@ function waiter(session, timeoutMs) {
     const timer = setTimeout(finish, Math.max(0, timeoutMs));
     timer.unref?.();
     session.waiters.push(finish);
+    signal?.addEventListener('abort', finish, { once:true });
+    // The signal can abort between the initial check and listener registration.
+    if (signal?.aborted) finish();
   });
 }
 
@@ -65,6 +70,8 @@ export function createProcessSession({ pid, child, command, shell }) {
     lines: [],
     partial: '',
     lastPartialRead: null,
+    lastPartialLineIndex: null,
+    cursorColumn: 0,
     droppedLines: 0,
     bufferedChars: 0,
     cursor: 0,
@@ -131,13 +138,64 @@ export function totalLines(session) {
   return session.droppedLines + session.lines.length + (session.partial ? 1 : 0);
 }
 
-export function readNewOutput(session) {
-  const from = Math.max(0, session.cursor - session.droppedLines);
-  const complete = session.lines.slice(from);
-  session.cursor = session.droppedLines + session.lines.length;
-  const parts = [...complete];
-  if (session.partial && session.partial !== session.lastPartialRead) parts.push(session.partial);
-  session.lastPartialRead = session.partial || null;
+export function readNewOutput(session, maxLines = Infinity, maxChars = Infinity) {
+  const parts = [];
+  const lineLimit = Math.max(1, maxLines);
+  let remaining = Math.max(1, maxChars);
+  // If the buffer evicted a partially read line, its character offset does
+  // not belong to the first remaining line; never skip that fresh output.
+  if (session.cursor < session.droppedLines) {
+    session.cursor = session.droppedLines;
+    session.cursorColumn = 0;
+    session.lastPartialRead = null;
+    session.lastPartialLineIndex = null;
+  }
+  let from = session.cursor - session.droppedLines;
+  while (from < session.lines.length && parts.length < lineLimit && remaining > 0) {
+    const absolute = session.droppedLines + from;
+    const line = session.lines[from];
+    let skip = session.cursorColumn || 0;
+    if (session.lastPartialLineIndex === absolute && session.lastPartialRead
+        && line.startsWith(session.lastPartialRead)) {
+      skip = Math.max(skip, session.lastPartialRead.length);
+    }
+    const suffix = line.slice(skip);
+    const room = remaining - (parts.length ? 1 : 0);
+    if (room <= 0) break;
+    if (suffix.length > room) {
+      // Preserve the undispatched tail rather than consuming then truncating it.
+      parts.push(suffix.slice(0, room));
+      session.cursorColumn = skip + room;
+      break;
+    }
+    parts.push(suffix);
+    remaining -= suffix.length + (parts.length > 1 ? 1 : 0);
+    from++;
+    session.cursor = session.droppedLines + from;
+    session.cursorColumn = 0;
+    if (session.lastPartialLineIndex === absolute) {
+      session.lastPartialRead = null;
+      session.lastPartialLineIndex = null;
+    }
+  }
+  // Partial lines may be updated without a newline. Send only newly appended
+  // characters, and track even a partial page of that unfinished line.
+  if (session.cursor === session.droppedLines + session.lines.length
+      && parts.length < lineLimit && remaining > 0 && session.partial
+      && session.partial !== session.lastPartialRead) {
+    const sent = session.lastPartialLineIndex === session.cursor
+      && session.partial.startsWith(session.lastPartialRead || '')
+      ? session.lastPartialRead || '' : '';
+    const room = remaining - (parts.length ? 1 : 0);
+    if (room > 0) {
+      const delta = session.partial.slice(sent.length, sent.length + room);
+      if (delta) {
+        parts.push(delta);
+        session.lastPartialRead = sent + delta;
+        session.lastPartialLineIndex = session.cursor;
+      }
+    }
+  }
   return parts;
 }
 
@@ -164,9 +222,9 @@ export function readOutputRange(session, offset, length) {
   return { slice: snapshot.slice(start, end), start: session.droppedLines + start + 1, end: session.droppedLines + end, total };
 }
 
-export async function waitForProcessActivity(session, timeoutMs) {
-  if (session.exited) return;
-  await waiter(session, timeoutMs);
+export async function waitForProcessActivity(session, timeoutMs, signal = null) {
+  if (session.exited || signal?.aborted) return;
+  await waiter(session, timeoutMs, signal);
 }
 
 export async function waitForProcessExit(session, timeoutMs) {

package/src/tools/terminal.mjs

@@ -129,7 +129,9 @@ export async function startProcessTool(args, extra = {}) {
   const output = session.lines.slice(-200).join('\n');
   const partial = session.partial;
   session.cursor = session.droppedLines + session.lines.length;
+  session.cursorColumn = 0;
   session.lastPartialRead = session.partial || null;
+  session.lastPartialLineIndex = session.partial ? session.cursor : null;
   const warning = verdict.note ? String(verdict.note) : '';
   const rendered = [warning, headline, output, partial].filter(Boolean).join('\n');
   const status = describeSession(session);
@@ -147,6 +149,7 @@ export async function readProcessOutputTool(args, extra = {}) {
   const session = getProcessSession(pid);
   if (!session) fail(`No ReMCP session with pid ${pid}`);
   const timeoutMs = clampInteger(args.timeout_ms, 0, 0, 120000);
+  const maxLines = clampInteger(args.length, 200, 1, 5000);
   const hasOffset = args.offset !== undefined && args.offset !== null;
   let slice;
   let range;
@@ -154,22 +157,28 @@ export async function readProcessOutputTool(args, extra = {}) {
     // An explicit offset is a peek at a line range: it does not consume the new-output
     // cursor, so a caller can look at the tail and still read everything afterwards.
     // Zero-based from the first line the session produced; negative reads the last N.
-    const page = readOutputRange(session, Number(args.offset), clampInteger(args.length, 200, 1, 5000));
+    const page = readOutputRange(session, Number(args.offset), maxLines);
     slice = page.slice;
     range = `${page.start}-${page.end} of ${page.total}`;
   } else {
-    // Never sleep over output that is already buffered.
+    // Wait for a process event, exit, cancellation or deadline. Repeated
+    // 200ms wakeups multiplied unnecessarily across many concurrent sessions.
     if (timeoutMs && !hasNewOutput(session)) {
-      const deadline = Date.now() + timeoutMs;
-      while (!hasNewOutput(session) && !session.exited && Date.now() < deadline) {
+      const deadline = performance.now() + timeoutMs;
+      while (!hasNewOutput(session) && !session.exited && performance.now() < deadline) {
         throwIfAborted(extra.signal);
-        await waitForProcessActivity(session, Math.min(200, Math.max(20, deadline - Date.now())));
+        await waitForProcessActivity(session, Math.max(0, deadline - performance.now()), extra.signal);
       }
     }
-    slice = readNewOutput(session);
+    throwIfAborted(extra.signal);
+    const before = Math.max(session.cursor, session.droppedLines);
+    // 32K code units keep each structured + text mirror below the 128K
+    // truncation boundary, even for multi-byte Unicode lines.
+    slice = readNewOutput(session, maxLines, 32 * 1024);
     session.waitCursor = session.cursor;
-    const first = Math.max(1, session.cursor - slice.length + 1);
-    range = slice.length ? `${first}-${session.cursor} of ${totalLines(session)}` : `no new output (${totalLines(session)} lines total)`;
+    range = slice.length
+      ? `${before + 1}-${before + slice.length} of ${totalLines(session)}`
+      : `no new output (${totalLines(session)} lines total)`;
   }
   const status = describeSession(session);
   const header = `pid ${pid} ${status.status} · lines ${range}`;
@@ -179,6 +188,7 @@ export async function readProcessOutputTool(args, extra = {}) {
     range,
     output,
     explicitOffset:hasOffset,
+    hasMore:!hasOffset && hasNewOutput(session),
   }, `${header}\n${output}`);
 }
 
@@ -216,8 +226,10 @@ export async function waitForProcessOutputTool(args, extra = {}) {
   }
   const matched = waiterMatches(slice, matcher);
   session.cursor = session.droppedLines + session.lines.length;
+  session.cursorColumn = 0;
   session.waitCursor = session.cursor;
   session.lastPartialRead = session.partial || null;
+  session.lastPartialLineIndex = session.partial ? session.cursor : null;
   const status = describeSession(session);
   const headline = matched
     ? `pid ${pid} ${status.status} · pattern matched${bufferedMatch ? ' (already buffered)' : ''}`
@@ -243,8 +255,10 @@ export async function interactWithProcessTool(args, extra = {}) {
    const timeoutMs = clampInteger(args.timeout_ms, 1000, 0, 120000);
 
   session.cursor = session.droppedLines + session.lines.length;
+  session.cursorColumn = 0;
   session.waitCursor = session.cursor;
   session.lastPartialRead = null;
+  session.lastPartialLineIndex = null;
   throwIfAborted(extra.signal);
   const stdin = session.child?.stdin;
   if (!stdin || stdin.destroyed || session.stdinClosed) {