machine-bridge-mcp 0.2.5 → 0.4.0

package/src/local/log.mjs

@@ -1,7 +1,6 @@
 import process from "node:process";
 
 const COLORS = {
-  dim: "\x1b[2m",
   reset: "\x1b[0m",
   blue: "\x1b[34m",
   green: "\x1b[32m",
@@ -10,10 +9,14 @@ const COLORS = {
   gray: "\x1b[90m",
 };
 
+const SENSITIVE_KEY = /(authorization|cookie|password|passwd|secret|token|api[_-]?key|private[_-]?key|credential)/i;
+const SECRET_VALUE = /\b(?:mcp_password|daemon_secret|token_version|mcp_at|mcp_code)_[A-Za-z0-9_-]+\b/g;
+const BEARER_VALUE = /\bBearer\s+[A-Za-z0-9._~+\/-]+=*\b/gi;
+
 export function createLogger(options = {}) {
   const quiet = Boolean(options.quiet);
   const verbose = Boolean(options.verbose);
-  const component = options.component ? String(options.component) : "cli";
+  const component = sanitizeLogText(options.component ? String(options.component) : "cli");
   const useColor = shouldUseColor(options);
 
   const write = (stream, level, label, color, message, fields) => {
@@ -21,7 +24,7 @@ export function createLogger(options = {}) {
     if (level === "debug" && !verbose) return;
     const prefix = useColor ? `${color}${label}${COLORS.reset}` : label;
     const suffix = formatFields(fields);
-    stream.write(`${prefix} ${component}: ${String(message)}${suffix}\n`);
+    stream.write(`${prefix} ${component}: ${sanitizeLogText(message)}${suffix}\n`);
   };
 
   return {
@@ -39,18 +42,37 @@ export function createLogger(options = {}) {
 }
 
 export function redactSecret(value) {
-  const text = String(value || "");
-  if (!text) return "<empty>";
-  if (text.length <= 12) return "<redacted>";
-  return `${text.slice(0, 6)}...${text.slice(-4)}`;
+  return value ? "<redacted>" : "<empty>";
 }
 
 export function formatFields(fields) {
   if (!fields || typeof fields !== "object" || !Object.keys(fields).length) return "";
-  return ` ${JSON.stringify(fields, (_key, value) => {
-    if (value instanceof Error) return value.message;
-    return value;
-  })}`;
+  return ` ${JSON.stringify(sanitizeLogValue(fields))}`;
+}
+
+export function sanitizeLogValue(value, key = "", seen = new WeakSet(), depth = 0) {
+  if (SENSITIVE_KEY.test(key)) return "<redacted>";
+  if (value instanceof Error) return sanitizeLogText(value.message || value.name);
+  if (typeof value === "string") return sanitizeLogText(value);
+  if (typeof value === "bigint") return value.toString();
+  if (value === null || typeof value !== "object") return value;
+  if (depth >= 8) return "<max-depth>";
+  if (seen.has(value)) return "<circular>";
+  seen.add(value);
+  if (Array.isArray(value)) return value.slice(0, 100).map(item => sanitizeLogValue(item, "", seen, depth + 1));
+  const out = {};
+  for (const [childKey, childValue] of Object.entries(value).slice(0, 100)) {
+    out[childKey] = sanitizeLogValue(childValue, childKey, seen, depth + 1);
+  }
+  return out;
+}
+
+export function sanitizeLogText(value) {
+  return String(value ?? "")
+    .replace(SECRET_VALUE, "<redacted-secret>")
+    .replace(BEARER_VALUE, "Bearer <redacted>")
+    .replace(/[\r\n\t]/g, match => match === "\t" ? "\\t" : "\\n")
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "?");
 }
 
 function shouldUseColor(options) {

package/src/local/patch.mjs

@@ -0,0 +1,140 @@
+const BEGIN = "*** Begin Patch";
+const END = "*** End Patch";
+const SECTION_PREFIXES = ["*** Add File: ", "*** Update File: ", "*** Delete File: "];
+
+export function parsePatchEnvelope(input) {
+  const text = String(input ?? "").replaceAll("\r\n", "\n");
+  const lines = text.split("\n");
+  if (lines[0] !== BEGIN) throw new Error(`patch must start with ${BEGIN}`);
+  const endIndex = lines.lastIndexOf(END);
+  if (endIndex < 1) throw new Error(`patch must end with ${END}`);
+  if (lines.slice(endIndex + 1).some((line) => line !== "")) throw new Error("unexpected content after patch envelope");
+
+  const operations = [];
+  let index = 1;
+  while (index < endIndex) {
+    if (!lines[index]) {
+      index += 1;
+      continue;
+    }
+    const header = lines[index];
+    const kind = header.startsWith(SECTION_PREFIXES[0])
+      ? "add"
+      : header.startsWith(SECTION_PREFIXES[1])
+        ? "update"
+        : header.startsWith(SECTION_PREFIXES[2])
+          ? "delete"
+          : "";
+    if (!kind) throw new Error(`invalid patch section header at line ${index + 1}`);
+    const prefix = SECTION_PREFIXES[kind === "add" ? 0 : kind === "update" ? 1 : 2];
+    const path = header.slice(prefix.length).trim();
+    if (!path) throw new Error(`patch ${kind} path is empty`);
+    index += 1;
+
+    if (kind === "add") {
+      const contentLines = [];
+      while (index < endIndex && !isSectionHeader(lines[index])) {
+        const line = lines[index];
+        if (!line.startsWith("+")) throw new Error(`added file content must start with + at line ${index + 1}`);
+        contentLines.push(line.slice(1));
+        index += 1;
+      }
+      operations.push({ kind, path, content: contentLines.length ? `${contentLines.join("\n")}\n` : "" });
+      continue;
+    }
+
+    if (kind === "delete") {
+      if (index < endIndex && !isSectionHeader(lines[index]) && lines[index] !== "") {
+        throw new Error(`delete section must not contain patch body at line ${index + 1}`);
+      }
+      operations.push({ kind, path });
+      continue;
+    }
+
+    let moveTo = "";
+    if (lines[index]?.startsWith("*** Move to: ")) {
+      moveTo = lines[index].slice("*** Move to: ".length).trim();
+      if (!moveTo) throw new Error("move destination is empty");
+      index += 1;
+    }
+    const hunks = [];
+    while (index < endIndex && !isSectionHeader(lines[index])) {
+      if (!lines[index]) {
+        index += 1;
+        continue;
+      }
+      if (!lines[index].startsWith("@@")) throw new Error(`update hunk must start with @@ at line ${index + 1}`);
+      const headerText = lines[index].slice(2).trim();
+      index += 1;
+      const hunkLines = [];
+      while (index < endIndex && !isSectionHeader(lines[index]) && !lines[index].startsWith("@@")) {
+        const line = lines[index];
+        if (!line || ![" ", "+", "-"].includes(line[0])) {
+          throw new Error(`invalid update line prefix at line ${index + 1}`);
+        }
+        hunkLines.push({ type: line[0], text: line.slice(1) });
+        index += 1;
+      }
+      if (!hunkLines.length) throw new Error("empty update hunk");
+      if (!hunkLines.some((line) => line.type !== "+")) throw new Error("update hunk needs context or removed lines");
+      hunks.push({ header: headerText, lines: hunkLines });
+    }
+    if (!hunks.length) throw new Error(`update section for ${path} contains no hunks`);
+    operations.push({ kind, path, moveTo: moveTo || undefined, hunks });
+  }
+
+  if (!operations.length) throw new Error("patch contains no file operations");
+  const touched = new Set();
+  for (const operation of operations) {
+    for (const path of [operation.path, operation.moveTo].filter(Boolean)) {
+      if (touched.has(path)) throw new Error(`patch touches the same path more than once: ${path}`);
+      touched.add(path);
+    }
+  }
+  return operations;
+}
+
+export function applyUpdateHunks(content, hunks, path = "file") {
+  const normalized = String(content).replaceAll("\r\n", "\n");
+  const trailingNewline = normalized.endsWith("\n");
+  let lines = normalized.split("\n");
+  if (trailingNewline) lines.pop();
+  let searchFrom = 0;
+
+  for (const [hunkIndex, hunk] of hunks.entries()) {
+    const oldLines = hunk.lines.filter((line) => line.type !== "+").map((line) => line.text);
+    const newLines = hunk.lines.filter((line) => line.type !== "-").map((line) => line.text);
+    const matches = findSequenceMatches(lines, oldLines, searchFrom);
+    if (matches.length === 0) {
+      throw new Error(`patch context not found for ${path} hunk ${hunkIndex + 1}`);
+    }
+    if (matches.length > 1) {
+      throw new Error(`patch context is ambiguous for ${path} hunk ${hunkIndex + 1}`);
+    }
+    const at = matches[0];
+    lines.splice(at, oldLines.length, ...newLines);
+    searchFrom = at + newLines.length;
+  }
+
+  return `${lines.join("\n")}${trailingNewline ? "\n" : ""}`;
+}
+
+function findSequenceMatches(lines, sequence, start) {
+  const matches = [];
+  if (!sequence.length) return matches;
+  for (let index = Math.max(0, start); index <= lines.length - sequence.length; index += 1) {
+    let matched = true;
+    for (let offset = 0; offset < sequence.length; offset += 1) {
+      if (lines[index + offset] !== sequence[offset]) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) matches.push(index);
+  }
+  return matches;
+}
+
+function isSectionHeader(line) {
+  return SECTION_PREFIXES.some((prefix) => line.startsWith(prefix));
+}

package/src/local/process-sessions.mjs

@@ -0,0 +1,352 @@
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { basename } from "node:path";
+import { executionEnv } from "./shell.mjs";
+
+export const MAX_COMMAND_BYTES = 64 * 1024;
+export const MAX_ARGV_ITEMS = 256;
+export const MAX_PROCESS_SESSIONS = 8;
+export const MAX_SESSION_OUTPUT_BYTES = 1024 * 1024;
+export const MAX_PROCESS_STDIN_BYTES = 64 * 1024;
+export const PROCESS_SESSION_RETENTION_MS = 30 * 60 * 1000;
+
+export class ProcessSessionManager {
+  constructor({ workspace, policy, runtimeDir, activeProcesses, callProcesses, resolveCwd, displayPath, throwIfCancelled }) {
+    this.workspace = workspace;
+    this.policy = policy;
+    this.runtimeDir = runtimeDir;
+    this.activeProcesses = activeProcesses;
+    this.callProcesses = callProcesses;
+    this.resolveCwd = resolveCwd;
+    this.displayPath = displayPath;
+    this.throwIfCancelled = throwIfCancelled;
+    this.sessions = new Map();
+  }
+
+  status() {
+    return {
+      active: [...this.sessions.values()].filter((session) => session.closedAt === null).length,
+      retained: this.sessions.size,
+      maximum: MAX_PROCESS_SESSIONS,
+    };
+  }
+
+  clear() {
+    this.sessions.clear();
+  }
+
+  notifyCancellation() {
+    for (const session of this.sessions.values()) notifySessionWaiters(session);
+  }
+
+  async start(args, context = {}) {
+    this.assertEnabled("start_process");
+    const argv = validateArgv(args.argv);
+    const cwd = await this.resolveCwd(args.cwd || ".");
+    this.prune();
+    if (this.sessions.size >= MAX_PROCESS_SESSIONS) throw new Error(`process session limit reached (${MAX_PROCESS_SESSIONS})`);
+    this.throwIfCancelled(context);
+
+    const child = spawn(argv[0], argv.slice(1), {
+      cwd,
+      env: executionEnv(this.workspace, { fullEnv: this.policy.minimalEnv === false, runtimeDir: this.runtimeDir }),
+      detached: process.platform !== "win32",
+      windowsHide: true,
+    });
+    const session = {
+      id: `proc_${randomBytes(24).toString("base64url")}`,
+      child,
+      argv0: basename(argv[0]),
+      cwd,
+      stdout: createSessionStream(),
+      stderr: createSessionStream(),
+      startedAt: Date.now(),
+      lastActivity: Date.now(),
+      closedAt: null,
+      exitCode: null,
+      signal: null,
+      stdinClosed: false,
+      waiters: new Set(),
+    };
+    this.sessions.set(session.id, session);
+    this.trackChild(child, context.callId);
+
+    child.stdout.on("data", (chunk) => {
+      appendSessionStream(session.stdout, chunk);
+      session.lastActivity = Date.now();
+      notifySessionWaiters(session);
+    });
+    child.stderr.on("data", (chunk) => {
+      appendSessionStream(session.stderr, chunk);
+      session.lastActivity = Date.now();
+      notifySessionWaiters(session);
+    });
+    child.on("close", (code, signal) => {
+      session.exitCode = Number.isInteger(code) ? code : null;
+      session.signal = signal ? String(signal) : null;
+      session.closedAt = Date.now();
+      session.lastActivity = Date.now();
+      session.stdinClosed = true;
+      this.untrackChild(child);
+      notifySessionWaiters(session);
+    });
+
+    try {
+      await waitForSpawn(child);
+    } catch (error) {
+      this.sessions.delete(session.id);
+      this.untrackChild(child);
+      throw error;
+    }
+
+    child.on("error", (error) => {
+      appendSessionStream(session.stderr, Buffer.from(`${boundedErrorMessage(error)}\n`));
+      session.lastActivity = Date.now();
+      notifySessionWaiters(session);
+    });
+    this.throwIfCancelled(context);
+    return this.summary(session);
+  }
+
+  async read(args, context = {}) {
+    this.assertEnabled("read_process");
+    const session = this.get(args.session_id);
+    const stdoutOffset = clampInt(args.stdout_offset, 0, 0, Number.MAX_SAFE_INTEGER);
+    const stderrOffset = clampInt(args.stderr_offset, 0, 0, Number.MAX_SAFE_INTEGER);
+    const maxBytes = clampInt(args.max_bytes, 64 * 1024, 1, 256 * 1024);
+    const waitMs = clampInt(args.wait_ms, 0, 0, 30_000);
+    this.throwIfCancelled(context);
+    const waitForExit = args.wait_for_exit === true;
+    if (waitMs > 0 && session.closedAt === null) {
+      const deadline = Date.now() + waitMs;
+      if (waitForExit) {
+        while (session.closedAt === null && Date.now() < deadline) {
+          await waitForSessionChange(session, Math.max(1, deadline - Date.now()), () => this.throwIfCancelled(context));
+        }
+      } else if (!sessionHasOutputAfter(session, stdoutOffset, stderrOffset)) {
+        await waitForSessionChange(session, waitMs, () => this.throwIfCancelled(context));
+      }
+    }
+    this.throwIfCancelled(context);
+    session.lastActivity = Date.now();
+    return {
+      ...this.summary(session),
+      stdout: readSessionStream(session.stdout, stdoutOffset, maxBytes),
+      stderr: readSessionStream(session.stderr, stderrOffset, maxBytes),
+    };
+  }
+
+  async write(args, context = {}) {
+    this.assertEnabled("write_process");
+    const session = this.get(args.session_id);
+    if (session.closedAt !== null) throw new Error("process session has already exited");
+    const data = String(args.data ?? "");
+    if (Buffer.byteLength(data) > MAX_PROCESS_STDIN_BYTES) throw new Error(`stdin data exceeds maximum size (${MAX_PROCESS_STDIN_BYTES} bytes)`);
+    if (session.stdinClosed || session.child.stdin.destroyed) throw new Error("process session stdin is closed");
+    this.throwIfCancelled(context);
+    if (data) {
+      await new Promise((resolvePromise, rejectPromise) => {
+        session.child.stdin.write(data, (error) => error ? rejectPromise(error) : resolvePromise());
+      });
+    }
+    if (args.close_stdin === true) {
+      session.child.stdin.end();
+      session.stdinClosed = true;
+    }
+    session.lastActivity = Date.now();
+    return { ...this.summary(session), bytes_written: Buffer.byteLength(data) };
+  }
+
+  async kill(args, context = {}) {
+    this.assertEnabled("kill_process");
+    const session = this.get(args.session_id);
+    this.throwIfCancelled(context);
+    const wasRunning = session.closedAt === null;
+    if (wasRunning) terminateProcessTree(session.child, args.force === true ? "SIGKILL" : "SIGTERM");
+    session.lastActivity = Date.now();
+    return { ...this.summary(session), termination_requested: wasRunning, force: args.force === true };
+  }
+
+  get(sessionId) {
+    this.prune();
+    const id = String(sessionId || "");
+    if (!/^proc_[A-Za-z0-9_-]{20,}$/.test(id)) throw new Error("invalid process session id");
+    const session = this.sessions.get(id);
+    if (!session) throw new Error("process session not found or expired");
+    return session;
+  }
+
+  summary(session) {
+    return {
+      session_id: session.id,
+      command: session.argv0,
+      cwd: this.displayPath(session.cwd),
+      running: session.closedAt === null,
+      exit_code: session.exitCode,
+      signal: session.signal,
+      stdin_closed: session.stdinClosed,
+      started_at: new Date(session.startedAt).toISOString(),
+      closed_at: session.closedAt ? new Date(session.closedAt).toISOString() : null,
+      stdout_offset: session.stdout.totalBytes,
+      stderr_offset: session.stderr.totalBytes,
+    };
+  }
+
+  prune() {
+    const cutoff = Date.now() - PROCESS_SESSION_RETENTION_MS;
+    for (const [id, session] of this.sessions) {
+      if (session.closedAt !== null && session.lastActivity < cutoff) this.sessions.delete(id);
+    }
+    if (this.sessions.size < MAX_PROCESS_SESSIONS) return;
+    const exited = [...this.sessions.values()]
+      .filter((session) => session.closedAt !== null)
+      .sort((left, right) => left.lastActivity - right.lastActivity);
+    for (const session of exited) {
+      if (this.sessions.size < MAX_PROCESS_SESSIONS) break;
+      this.sessions.delete(session.id);
+    }
+  }
+
+  assertEnabled(tool) {
+    if (this.policy.execMode !== "direct" && this.policy.execMode !== "shell") throw new Error(`${tool} is disabled by daemon policy`);
+  }
+
+  trackChild(child, callId) {
+    this.activeProcesses.add(child);
+    if (!callId) return;
+    const set = this.callProcesses.get(callId) || new Set();
+    set.add(child);
+    this.callProcesses.set(callId, set);
+  }
+
+  untrackChild(child) {
+    this.activeProcesses.delete(child);
+    for (const [callId, set] of this.callProcesses) {
+      set.delete(child);
+      if (!set.size) this.callProcesses.delete(callId);
+    }
+  }
+}
+
+export function validateArgv(value) {
+  if (!Array.isArray(value) || !value.length || value.length > MAX_ARGV_ITEMS) throw new Error(`argv must contain 1-${MAX_ARGV_ITEMS} strings`);
+  const argv = value.map((item) => {
+    if (typeof item !== "string" || item.includes("\0")) throw new Error("argv entries must be strings without NUL bytes");
+    return item;
+  });
+  if (!argv[0]) throw new Error("argv[0] must not be empty");
+  if (Buffer.byteLength(JSON.stringify(argv)) > MAX_COMMAND_BYTES) throw new Error(`argv exceeds maximum size (${MAX_COMMAND_BYTES} bytes)`);
+  return argv;
+}
+
+export function terminateProcessTree(child, signal) {
+  if (!child?.pid) return;
+  if (process.platform === "win32") {
+    try {
+      const killer = spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+      killer.unref();
+      return;
+    } catch {}
+  }
+  try { process.kill(-child.pid, signal); } catch {
+    try { child.kill(signal); } catch {}
+  }
+}
+
+function waitForSpawn(child) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const onSpawn = () => { cleanup(); resolvePromise(); };
+    const onError = (error) => { cleanup(); rejectPromise(error); };
+    const cleanup = () => {
+      child.off("spawn", onSpawn);
+      child.off("error", onError);
+    };
+    child.once("spawn", onSpawn);
+    child.once("error", onError);
+  });
+}
+
+function createSessionStream() {
+  return { buffer: Buffer.alloc(0), baseOffset: 0, totalBytes: 0 };
+}
+
+function appendSessionStream(stream, chunk) {
+  const input = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk ?? ""));
+  stream.totalBytes += input.length;
+  let combined = stream.buffer.length ? Buffer.concat([stream.buffer, input]) : Buffer.from(input);
+  if (combined.length > MAX_SESSION_OUTPUT_BYTES) {
+    const dropped = combined.length - MAX_SESSION_OUTPUT_BYTES;
+    combined = combined.subarray(dropped);
+    stream.baseOffset += dropped;
+  }
+  stream.buffer = combined;
+}
+
+function readSessionStream(stream, requestedOffset, maxBytes) {
+  const clampedOffset = Math.min(requestedOffset, stream.totalBytes);
+  const effectiveOffset = Math.max(clampedOffset, stream.baseOffset);
+  const start = effectiveOffset - stream.baseOffset;
+  const slice = stream.buffer.subarray(start, Math.min(stream.buffer.length, start + maxBytes));
+  let data;
+  let dataBase64;
+  let encoding = "utf8";
+  try {
+    data = new TextDecoder("utf-8", { fatal: true }).decode(slice);
+  } catch {
+    data = new TextDecoder("utf-8").decode(slice);
+    dataBase64 = slice.toString("base64");
+    encoding = "base64";
+  }
+  return {
+    data,
+    ...(dataBase64 ? { data_base64: dataBase64 } : {}),
+    encoding,
+    requested_offset: requestedOffset,
+    start_offset: effectiveOffset,
+    next_offset: effectiveOffset + slice.length,
+    total_offset: stream.totalBytes,
+    truncated_before: requestedOffset < stream.baseOffset,
+    truncated_after: effectiveOffset + slice.length < stream.totalBytes,
+  };
+}
+
+function sessionHasOutputAfter(session, stdoutOffset, stderrOffset) {
+  return session.stdout.totalBytes > stdoutOffset || session.stderr.totalBytes > stderrOffset;
+}
+
+function notifySessionWaiters(session) {
+  for (const waiter of [...session.waiters]) waiter();
+}
+
+function waitForSessionChange(session, waitMs, cancellationCheck) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    let timer;
+    const done = () => {
+      cleanup();
+      try {
+        cancellationCheck();
+        resolvePromise();
+      } catch (error) {
+        rejectPromise(error);
+      }
+    };
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      session.waiters.delete(done);
+    };
+    session.waiters.add(done);
+    timer = setTimeout(done, waitMs);
+    timer.unref?.();
+  });
+}
+
+function boundedErrorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/[\r\n]+/g, " ").slice(0, 4096) || "process failed";
+}
+
+function clampInt(value, fallback, min, max) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  const number = Number.isFinite(parsed) ? parsed : fallback;
+  return Math.min(Math.max(number, min), max);
+}

package/src/local/service.mjs

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, closeSync, existsSync, fstatSync, mkdirSync, openSync, readSync, rmSync, statSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { run } from "./shell.mjs";
@@ -7,8 +7,8 @@ import { ensureOwnerOnlyDir, expandHome } from "./state.mjs";
 const LABEL = "dev.machine-bridge-mcp.daemon";
 const WINDOWS_TASK = "MachineBridgeMCP";
 
-export async function installAutostart({ workspace, stateRoot, entryScript, policy, logger = console }) {
-  const spec = serviceSpec({ workspace, stateRoot, entryScript, policy });
+export async function installAutostart({ workspace, stateRoot, entryScript, logger = console }) {
+  const spec = serviceSpec({ workspace, stateRoot, entryScript });
   if (process.platform === "darwin") return installLaunchd(spec, logger);
   if (process.platform === "win32") return installWindowsTask(spec, logger);
   return installSystemd(spec, logger);
@@ -38,11 +38,42 @@ export async function stopAutostart({ logger = console } = {}) {
   return run("systemctl", ["--user", "stop", "machine-bridge-mcp.service"], { capture: true, allowFailure: true });
 }
 
-function serviceSpec({ workspace, stateRoot, entryScript, policy = {} }) {
+
+export function trimAutostartLogs(stateRoot, options = {}) {
+  const root = expandHome(stateRoot);
+  const maxBytes = Number.isFinite(Number(options.maxBytes)) ? Math.max(1024, Number(options.maxBytes)) : 2 * 1024 * 1024;
+  const keepBytes = Math.min(maxBytes, Number.isFinite(Number(options.keepBytes)) ? Math.max(1024, Number(options.keepBytes)) : 1024 * 1024);
+  const logs = path.join(root, "logs");
+  for (const name of ["daemon.out.log", "daemon.err.log"]) {
+    const file = path.join(logs, name);
+    try {
+      const info = statSync(file);
+      if (info.size > maxBytes) {
+        const fd = openSync(file, "r");
+        try {
+          const current = fstatSync(fd);
+          const length = Math.min(keepBytes, current.size);
+          const buffer = Buffer.alloc(length);
+          readSync(fd, buffer, 0, length, Math.max(0, current.size - length));
+          writeFileSync(file, buffer, { mode: 0o600 });
+        } finally {
+          closeSync(fd);
+        }
+      }
+      chmodSync(file, 0o600);
+    } catch {}
+  }
+}
+
+function serviceSpec({ workspace, stateRoot, entryScript }) {
   const root = expandHome(stateRoot);
   const logs = path.join(root, "logs");
   ensureOwnerOnlyDir(root);
   ensureOwnerOnlyDir(logs);
+  for (const file of [path.join(logs, "daemon.out.log"), path.join(logs, "daemon.err.log")]) {
+    writeFileSync(file, "", { flag: "a", mode: 0o600 });
+    try { chmodSync(file, 0o600); } catch {}
+  }
   return {
     workspace,
     stateRoot: root,
@@ -50,17 +81,11 @@ function serviceSpec({ workspace, stateRoot, entryScript, policy = {} }) {
     node: process.execPath,
     stdout: path.join(logs, "daemon.out.log"),
     stderr: path.join(logs, "daemon.err.log"),
-    policy: {
-      allowWrite: policy.allowWrite !== false,
-      allowExec: policy.allowExec !== false,
-      minimalEnv: policy.minimalEnv !== false,
-      apiEnabled: policy.apiEnabled !== false,
-    },
   };
 }
 
-function daemonArgs(spec) {
-  const args = [
+export function daemonArgs(spec) {
+  return [
     spec.entryScript,
     "start",
     "--daemon-only",
@@ -69,11 +94,6 @@ function daemonArgs(spec) {
     "--no-print-credentials",
     "--quiet",
   ];
-  if (spec.policy.allowWrite === false) args.push("--no-write");
-  if (spec.policy.allowExec === false) args.push("--no-exec");
-  if (spec.policy.minimalEnv === false) args.push("--full-env");
-  if (spec.policy.apiEnabled === false) args.push("--no-api");
-  return args;
 }
 
 function launchdPlistPath() {
@@ -220,8 +240,15 @@ function winQuote(value) {
   return `"${String(value).replaceAll('"', '\\"')}"`;
 }
 
-function systemdQuote(value) {
-  return `'${String(value).replaceAll("'", "'\\''")}'`;
+export function systemdQuote(value) {
+  const escaped = String(value)
+    .replaceAll("\\", "\\\\")
+    .replaceAll("\"", "\\\"")
+    .replaceAll("%", "%%")
+    .replaceAll("\n", "\\n")
+    .replaceAll("\r", "\\r")
+    .replaceAll("\t", "\\t");
+  return `"${escaped}"`;
 }
 
 function escapeXml(value) {