@remcp/runtime 0.2.19 → 0.2.20

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.2.20
+
+- `set_config_value`: a model may change this runtime’s own preferences (telemetry opt-out, read
+  and buffer line limits, result size) while it is running; the change applies immediately and is
+  saved to runtime.json. Access roots, blocked commands, the command guardrail, the shell and the
+  write limit stay with the person at this computer and are refused by the tool.
+
 ## 0.2.16
 
 - Mark cursor-consuming `read_process_output` as non-idempotent so clients do not assume retries

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.19",
+  "version": "0.2.20",
   "description": "First-party ReMCP local device runtime: file, search, terminal and process tools over MCP for computers paired with ReMCP.",
   "type": "module",
   "license": "MIT",

package/src/catalog.mjs

@@ -3,6 +3,7 @@ import { searchToolHandlers } from './tools/search.mjs';
 import { terminalToolHandlers } from './tools/terminal.mjs';
 import { systemToolHandlers } from './tools/system.mjs';
 import { statsToolHandlers } from './tools/stats.mjs';
+import { configToolHandlers } from './tools/config.mjs';
 
 // Every tool answers with a text result (image tools add an image part as well), so the
 // declared output schema is the same shape everywhere and clients can rely on it.
@@ -737,6 +738,23 @@ export const toolDefinitions = [
     annotations: readOnly,
     handler: statsToolHandlers.get_runtime_stats,
   },
+  {
+    name: 'set_config_value',
+    title: 'Change runtime setting',
+    description: 'Change one of this runtime’s own preferences on this computer: telemetryEnabled, maxReadLines, maxBufferedLines or maxOutputBytes. The change applies immediately and is saved to runtime.json. Access roots, blocked commands, the command guardrail, the shell and the write limit cannot be set through MCP — they stay with the person at this computer.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        key: { type: 'string', description: 'telemetryEnabled (true/false), maxReadLines, maxBufferedLines or maxOutputBytes.' },
+        value: { description: 'New value: a boolean for telemetryEnabled, a number for the limits.' },
+      },
+      required: ['key', 'value'],
+      additionalProperties: false,
+    },
+    // Preference only, and the same call twice leaves the same state.
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: configToolHandlers.set_config_value,
+  },
 ];
 
 export function advertisedTools() {

package/src/config.mjs

@@ -1,6 +1,6 @@
 import os from 'node:os';
 import path from 'node:path';
-import { readFileSync } from 'node:fs';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { expandHome } from './util.mjs';
 
 const configDir = process.env.REMCP_RUNTIME_CONFIG_DIR || path.join(os.homedir(), '.config', 'remcp');
@@ -97,6 +97,61 @@ export const runtimeConfig = Object.freeze({
   telemetryEnabled,
 });
 
+// --- settings a model may change, and nothing else ------------------------------------------------
+//
+// Desktop Commander lets a model rewrite any of its own configuration, including the directories it
+// may touch and the commands it must refuse. On ReMCP those two decide what the computer exposes, so
+// they stay with the person at the computer: `allowedRoots`, `blockedCommands`, `dangerousCommands`
+// (the command guardrail), `defaultShell`, `maxWriteBytes` and `name` are not settable from a tool.
+//
+// What is settable is a preference and two context limits — telemetry opt-out, the read and buffer
+// line limits, and the result size — all of which the person can also change in runtime.json. The
+// values apply immediately (the tool handlers read them through liveConfig) and are written back to
+// runtime.json so they survive a restart.
+const SETTABLE = Object.freeze({
+  telemetryEnabled: { type: 'boolean' },
+  maxReadLines: { type: 'integer', min: 1, max: 100_000 },
+  maxBufferedLines: { type: 'integer', min: 1, max: 1_000_000 },
+  maxOutputBytes: { type: 'integer', min: 1024, max: HARD_OUTPUT_CEILING_BYTES },
+});
+export const settableKeys = Object.freeze(Object.keys(SETTABLE));
+
+const live = new Map();
+
+// Every read of a settable value goes through here, so a change applies to the next call.
+export function liveConfig(key) {
+  return live.has(key) ? live.get(key) : runtimeConfig[key];
+}
+
+export function validateConfigValue(key, raw) {
+  const rule = SETTABLE[key];
+  if (!rule) {
+    throw new Error(`Unsupported setting: ${key || '(empty)'}. Settable here: ${settableKeys.join(', ')}. Access roots, blocked commands, the command guardrail, the shell and write limits are changed by the person at this computer.`);
+  }
+  if (rule.type === 'boolean') {
+    if (typeof raw === 'boolean') return raw;
+    if (typeof raw === 'string') return booleanValue(raw, null) ?? (() => { throw new Error(`${key} must be true or false`); })();
+    throw new Error(`${key} must be true or false`);
+  }
+  const value = Math.trunc(Number(raw));
+  if (!Number.isFinite(value)) throw new Error(`${key} must be a number`);
+  if (value < rule.min || value > rule.max) throw new Error(`${key} must be between ${rule.min} and ${rule.max}`);
+  return value;
+}
+
+export function applyLiveConfig(key, value) {
+  live.set(key, value);
+}
+
+// Writes only the changed key back, with the file mode the rest of the runtime expects.
+export function persistConfigValue(key, value) {
+  const file = readConfigFile();
+  const next = { ...file, [key]: value };
+  mkdirSync(runtimeConfigDir, { recursive: true, mode: 0o700 });
+  writeFileSync(runtimeConfigPath, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+  return runtimeConfigPath;
+}
+
 // A configuration the user cannot read is not a configuration we should quietly ignore:
 // it is how allowedRoots and an opt-out silently disappear.
 export function configurationError() {

package/src/sessions.mjs

@@ -1,5 +1,5 @@
 import process from 'node:process';
-import { runtimeConfig } from './config.mjs';
+import { liveConfig, runtimeConfig } from './config.mjs';
 
 const processSessions = new Map();
 const searchSessions = new Map();
@@ -13,7 +13,7 @@ const MAX_PARTIAL_BYTES = 64 * 1024;
 const MAX_BUFFERED_CHARS = 8 * 1024 * 1024;
 
 function trimBuffer(session) {
-  const overflow = session.lines.length - runtimeConfig.maxBufferedLines;
+  const overflow = session.lines.length - liveConfig('maxBufferedLines');
   if (overflow > 0) {
     const removed = session.lines.splice(0, overflow);
     for (const line of removed) session.bufferedChars -= line.length;

package/src/telemetry.mjs

@@ -1,5 +1,5 @@
 import process from 'node:process';
-import { runtimeConfig } from './config.mjs';
+import { liveConfig, runtimeConfig } from './config.mjs';
 import { VERSION } from './version.mjs';
 
 // Event fields are whitelisted: an event can never carry a file path, a command
@@ -20,7 +20,7 @@ const FLUSH_INTERVAL_MS = 15_000;
 const FLUSH_THRESHOLD = 20;
 
 const state = {
-  enabled: runtimeConfig.telemetryEnabled,
+  enabled: liveConfig('telemetryEnabled'),
   buffer: [],
   sink: null,
   timer: null,
@@ -39,8 +39,10 @@ const state = {
   toolCounts: new Map(),
 };
 
+// Live: a runtime setting changed through set_config_value applies to the next call, not the next
+// restart.
 export function telemetryEnabled() {
-  return state.enabled;
+  return liveConfig('telemetryEnabled');
 }
 
 export function telemetryStatus() {
@@ -97,7 +99,7 @@ export function recordEvent(event, detail = {}) {
   if (name === 'policy_block') state.counters.policyBlocks += 1;
   if (name === 'session_started') state.counters.sessionsStarted += 1;
   if (name === 'write_denied') state.counters.writeDenials += 1;
-  if (!state.enabled) return;
+  if (!telemetryEnabled()) return;
   if (state.buffer.length >= BUFFER_LIMIT) {
     state.dropped += 1;
     return;

package/src/tools/config.mjs

@@ -0,0 +1,31 @@
+import { applyLiveConfig, liveConfig, persistConfigValue, runtimeConfig, settableKeys, validateConfigValue } from '../config.mjs';
+import { text } from '../util.mjs';
+
+// The one write into this runtime's own configuration, and a deliberately narrow one.
+//
+// Desktop Commander exposes its whole config object to the model, including the directories it may
+// touch and the commands it must refuse. Those two decide what this computer exposes, so they stay
+// with the person at the computer: only the telemetry opt-out and the read/buffer/output limits can be
+// changed here, and the change is written back to runtime.json so it survives a restart.
+export async function setConfigValueTool(args = {}) {
+  const key = String(args.key || '').trim();
+  const value = validateConfigValue(key, args.value);
+  applyLiveConfig(key, value);
+  const file = persistConfigValue(key, value);
+  return text(JSON.stringify({
+    ok: true,
+    key,
+    value,
+    applied: 'immediately',
+    savedTo: file,
+    note: `Effective now and after a restart. Settable through MCP: ${settableKeys.join(', ')}. Access roots, blocked commands, the command guardrail, the shell and the write limit stay with the person at this computer.`,
+    effective: Object.fromEntries(settableKeys.map(name => [name, liveConfig(name)])),
+  }, null, 2));
+}
+
+export const configToolHandlers = {
+  set_config_value: args => setConfigValueTool(args),
+};
+
+// Kept so a future tool can report the settable surface without duplicating the list.
+export const configSurface = Object.freeze({ settableKeys, roots: runtimeConfig.allowedRoots });

package/src/tools/files.mjs

@@ -5,7 +5,7 @@ import { createHash } from 'node:crypto';
 import { constants, createReadStream } from 'node:fs';
 import { access, chmod, chown, copyFile, cp, lstat, mkdir, open, readFile, readdir, rename, rm, stat, unlink, writeFile } from 'node:fs/promises';
 import { pipeline } from 'node:stream/promises';
-import { runtimeConfig } from '../config.mjs';
+import { liveConfig, runtimeConfig } from '../config.mjs';
 import { diffStats, unifiedDiff } from '../diff.mjs';
 import { applyHunks, parseUnifiedDiff } from '../patch.mjs';
 import { countEvent, recordEvent } from '../telemetry.mjs';
@@ -97,7 +97,7 @@ export async function readFileTool(args) {
   const { content, encoding, eol } = await readTextFile(absolute);
   const lines = splitLines(content);
   const offset = Number.isFinite(Number(args.offset)) ? Math.trunc(Number(args.offset)) : 0;
-  const length = clampInteger(args.length, runtimeConfig.maxReadLines, 1, 10000);
+  const length = clampInteger(args.length, liveConfig('maxReadLines'), 1, 10000);
   const { start, end, slice } = pageLines(lines, offset, length);
   const notes = `${encoding === 'utf8' ? '' : ` ${encoding}`}${eol === '\r\n' ? ' CRLF' : ''}`;
   const header = lines.length
@@ -121,7 +121,7 @@ export async function readMultipleFilesTool(args) {
     try {
       const { content } = await readTextFile(absolute);
       const lines = splitLines(content);
-      const limit = runtimeConfig.maxReadLines;
+      const limit = liveConfig('maxReadLines');
       const slice = lines.slice(0, limit);
       const suffix = lines.length > limit ? `\n… ${lines.length - limit} more lines truncated` : '';
       sections.push(`${displayPath(absolute)}:\n${slice.join('\n')}${suffix}`);
@@ -506,7 +506,7 @@ export async function readFilesTool(args) {
   const root = await resolveSafePath(args.path || '.');
   const pattern = typeof args.pattern === 'string' && args.pattern.trim() ? args.pattern.trim() : '**/*';
   const maxFiles = clampInteger(args.max_files, 100, 1, 500);
-  const maxLinesPerFile = clampInteger(args.max_lines_per_file, runtimeConfig.maxReadLines, 1, 20000);
+  const maxLinesPerFile = clampInteger(args.max_lines_per_file, liveConfig('maxReadLines'), 1, 20000);
   const includeIgnored = args.include_ignored === true;
   const matcher = globToRegExp(pattern);
   const rootInfo = await stat(root).catch(() => null);

package/src/tools/stats.mjs

@@ -1,5 +1,5 @@
 import process from 'node:process';
-import { describeConfig, runtimeConfig } from '../config.mjs';
+import { describeConfig, liveConfig, runtimeConfig } from '../config.mjs';
 import { dangerousPatternIds } from '../policy.mjs';
 import { listProcessSessions, listSearchSessions } from '../sessions.mjs';
 import { telemetryStatus } from '../telemetry.mjs';
@@ -29,9 +29,9 @@ export async function getRuntimeInfoTool() {
       remoteFeatureFlags: telemetry.remoteFeatureFlags,
     },
     limits: {
-      maxOutputBytes: runtimeConfig.maxOutputBytes,
-      maxReadLines: runtimeConfig.maxReadLines,
-      maxBufferedLines: runtimeConfig.maxBufferedLines,
+      maxOutputBytes: liveConfig('maxOutputBytes'),
+      maxReadLines: liveConfig('maxReadLines'),
+      maxBufferedLines: liveConfig('maxBufferedLines'),
       maxWriteBytes: runtimeConfig.maxWriteBytes,
       maxConcurrentConnections: 1,
     },

package/src/util.mjs

@@ -1,7 +1,7 @@
 import os from 'node:os';
 import path from 'node:path';
 import { realpath } from 'node:fs/promises';
-import { runtimeConfig } from './config.mjs';
+import { liveConfig, runtimeConfig } from './config.mjs';
 
 export class ToolError extends Error {}
 
@@ -111,7 +111,7 @@ function frameBytes(text) {
 }
 
 export function truncate(text, maxBytes) {
-  const limit = maxBytes || runtimeConfig.maxOutputBytes;
+  const limit = maxBytes || liveConfig('maxOutputBytes');
   const value = String(text);
   if (Buffer.byteLength(value, 'utf8') <= limit && frameBytes(value) <= limit) return value;
   // Shrink until the escaped frame fits, so the escaped size is what the caller gets is bounded.
@@ -191,7 +191,7 @@ export function pageLines(lines, offset, length) {
     return { start: total - count, end: total, slice: lines.slice(total - count) };
   }
   const start = Math.min(requested, total);
-  const end = Math.min(start + Math.max(1, Math.trunc(length || runtimeConfig.maxReadLines)), total);
+  const end = Math.min(start + Math.max(1, Math.trunc(length || liveConfig('maxReadLines'))), total);
   return { start, end, slice: lines.slice(start, end) };
 }