machine-bridge-mcp 0.8.0 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.8.1 - 2026-07-11
+
+### Fixed
+
+- Recognize and validate the Worker's pre-handshake `welcome` control message instead of reporting it as an unknown WebSocket warning. A valid welcome remains debug-only and does not imply authenticated readiness; identity or version mismatch still fails immediately.
+- Add a versioned autostart-log schema migration. On the first daemon start after this logging-format change, bounded prior logs are copied to owner-only `daemon.*.legacy.log` snapshots and the active logs are cleared, preventing historical raw close-code lines from appearing to be current behavior.
+
+### Tests and documentation
+
+- Add relay/runtime regression coverage for valid welcome handling and welcome metadata validation, plus service tests for one-time bounded legacy-log migration and schema-marker idempotence.
+- Record the protocol producer/consumer contract rule and document how current and legacy daemon logs are separated.
+
 ## 0.8.0 - 2026-07-11
 
 ### Architecture

package/docs/ENGINEERING.md

@@ -32,6 +32,7 @@ Rules:
 - Transport lifecycle, domain execution, persistence, and presentation are separate modules.
 - Pure classification and normalization functions are exported and tested directly when practical.
 - Adapters may translate data but should not duplicate policy or schemas.
+- Every protocol control message emitted by one side must be explicitly accepted, rejected, or version-gated by the other side, with an end-to-end contract test covering the message name and semantics.
 - State transitions are explicit; readiness is not inferred from a lower-level event. For example, an open WebSocket is not an authenticated relay until `hello_ack` is received.
 - Every externally controlled input is bounded before expensive allocation, traversal, parsing, storage, or execution.
 - Repository text must not contain invisible ASCII controls other than tab, CR, and LF; architecture tests enforce this even when JavaScript syntax remains valid.

package/docs/LOGGING.md

@@ -97,6 +97,8 @@ logs/daemon.err.log
 
 Existing files are opened without following symbolic links where supported and tail-trimmed on UTF-8/line boundaries before startup. Background services use `warn`, so ordinary tool traffic and brief relay interruptions do not cause sustained growth.
 
+The log format has an explicit schema marker. When the schema changes, the daemon copies a bounded tail of each prior active log to an owner-only `daemon.out.legacy.log` or `daemon.err.legacy.log` snapshot, clears the active file, and advances the marker. The migration is idempotent and keeps historical transport-format lines visibly separate from current behavior.
+
 Each managed job has owner-only runner diagnostic logs. Child-step output is retained only in bounded, redacted job results according to `capture_output`; it is not copied into daemon or runner operational logs.
 
 ## MCP host boundary

package/docs/OPERATIONS.md

@@ -32,7 +32,7 @@ Use `--verbose` only when close codes, close reasons, heartbeat timeouts, and re
 
 ## Logs
 
-Remote autostart definitions prefer a stable PATH alias that resolves to the currently running Node executable and persist a sanitized absolute-only service `PATH` containing the Node/CLI directories, the installer's absolute PATH entries, and platform defaults. This avoids versioned Homebrew-style paths becoming invalid after upgrades and prevents launchd/systemd from falling back to a minimal system-only PATH. Re-run `machine-mcp service install` after changing Node installation families or PATH layout. Autostart logs are stored under the state root in `logs/daemon.out.log` and `logs/daemon.err.log`. Files are owner-only where supported and tail-trimmed before daemon startup.
+Remote autostart definitions prefer a stable PATH alias that resolves to the currently running Node executable and persist a sanitized absolute-only service `PATH` containing the Node/CLI directories, the installer's absolute PATH entries, and platform defaults. This avoids versioned Homebrew-style paths becoming invalid after upgrades and prevents launchd/systemd from falling back to a minimal system-only PATH. Re-run `machine-mcp service install` after changing Node installation families or PATH layout. Autostart logs are stored under the state root in `logs/daemon.out.log` and `logs/daemon.err.log`. Files are owner-only where supported and tail-trimmed before daemon startup. On a logging-schema upgrade, bounded prior content is moved into `daemon.out.legacy.log` and `daemon.err.legacy.log`; use the active filenames when diagnosing current behavior.
 
 Logging is level-based:
 

package/docs/TESTING.md

@@ -36,8 +36,8 @@ The suite includes:
 - daemon/startup locking and state corruption recovery;
 - guarded state-root removal, schema migration, policy-origin persistence, and legacy implicit-default migration;
 - no filename-based sensitive-file denial under unrestricted policy;
-- log redaction, control-character handling, message/field bounds, suppression of both successful and failed per-tool events outside debug, and service warning-level configuration;
-- deterministic relay connection lifecycle coverage for transport construction/error, authenticated `hello_ack` readiness, identity/version mismatch, handshake and heartbeat timeout, brief-outage suppression, sustained-outage escalation, recovery summaries, and supersession;
+- log redaction, control-character handling, message/field bounds, suppression of both successful and failed per-tool events outside debug, service warning-level configuration, and idempotent bounded migration of legacy log formats;
+- deterministic relay connection lifecycle coverage for transport construction/error, pre-handshake `welcome` validation, authenticated `hello_ack` readiness, identity/version mismatch, handshake and heartbeat timeout, brief-outage suppression, sustained-outage escalation, recovery summaries, and supersession;
 - shared no-follow bounded-file reads for normal files, over-limit data, directories, and symbolic links;
 - CLI parsing, policy profiles, and client configuration boundaries;
 - live stdio MCP initialization, discovery, calls, rich content, sessions, cancellation, managed-job acceptance, and a detached job/finally phase that survives stdio shutdown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "machine-bridge-mcp",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Cross-client MCP bridge for canonical local automation, files, Git, SSH resources, managed jobs, and processes over stdio or an OAuth-protected remote relay.",
   "type": "module",
   "license": "MIT",

package/src/local/relay-connection.mjs

@@ -94,6 +94,19 @@ export class RelayConnection {
     return this.sendOnSocket(this.socket, value);
   }
 
+  observeWelcome(message = {}) {
+    const socket = this.socket;
+    if (this.closed || this.ready || !this.isSocketOpen(socket)) return false;
+    const mismatch = welcomeMismatch(message, this.expectedServer, this.expectedVersion);
+    if (mismatch) {
+      this.logger.debug?.("remote relay welcome rejected", { reason: mismatch });
+      this.failPermanently("relay_protocol_mismatch");
+      return false;
+    }
+    this.logger.debug?.("remote relay welcome received");
+    return true;
+  }
+
   acknowledge(message = {}) {
     const socket = this.socket;
     if (this.closed || this.ready || !this.isSocketOpen(socket)) return false;
@@ -435,6 +448,15 @@ function relayCloseUserCause(category) {
   return causes[String(category || "")] || "connection interrupted";
 }
 
+export function welcomeMismatch(message, expectedServer = "", expectedVersion = "") {
+  if (!message || typeof message !== "object" || Array.isArray(message)) return "invalid_welcome";
+  if (message.type !== "welcome") return "unexpected_welcome_type";
+  if (expectedServer && message.server !== expectedServer) return "server_identity_mismatch";
+  if (expectedVersion && message.version !== expectedVersion) return "server_version_mismatch";
+  if (typeof message.server !== "string" || !message.server || typeof message.version !== "string" || !message.version) return "incomplete_welcome";
+  return "";
+}
+
 export function acknowledgementMismatch(message, expectedServer = "", expectedVersion = "") {
   if (!message || typeof message !== "object" || Array.isArray(message)) return "invalid_acknowledgement";
   if (message.type !== "hello_ack") return "unexpected_acknowledgement_type";

package/src/local/runtime.mjs

@@ -188,6 +188,10 @@ export class LocalRuntime {
   }
 
   handleRelayControlMessage(message) {
+    if (message.type === "welcome") {
+      this.relay?.observeWelcome(message);
+      return true;
+    }
     if (message.type === "hello_ack") {
       this.relay?.acknowledge(message);
       return true;

package/src/local/service.mjs

@@ -4,10 +4,12 @@ import path from "node:path";
 import { run } from "./shell.mjs";
 import { ensureOwnerOnlyDir, expandHome, ownerOnlyFile } from "./state.mjs";
 import { replaceFileSync } from "./atomic-fs.mjs";
+import { readBoundedRegularFileSync } from "./secure-file.mjs";
 
 const LABEL = "dev.machine-bridge-mcp.daemon";
 const WINDOWS_TASK = "MachineBridgeMCP";
 const SERVICE_COMMAND_OUTPUT_BYTES = 64 * 1024;
+const AUTOSTART_LOG_SCHEMA_VERSION = 2;
 
 function serviceRun(command, args) {
   return run(command, args, {
@@ -53,33 +55,67 @@ 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 schemaVersion = String(Number.isInteger(Number(options.schemaVersion)) && Number(options.schemaVersion) > 0
+    ? Number(options.schemaVersion)
+    : AUTOSTART_LOG_SCHEMA_VERSION);
   const logs = path.join(root, "logs");
+  const schemaFile = path.join(logs, ".log-schema");
+  const migrate = readLogSchema(schemaFile) !== schemaVersion;
+  let migrationComplete = true;
+
   for (const name of ["daemon.out.log", "daemon.err.log"]) {
     const file = path.join(logs, name);
     let fd;
     try {
       if (!existsSync(file)) continue;
       const before = lstatSync(file);
-      if (before.isSymbolicLink() || !before.isFile()) continue;
+      if (before.isSymbolicLink() || !before.isFile()) {
+        if (migrate) migrationComplete = false;
+        continue;
+      }
       const noFollow = Number(fsConstants.O_NOFOLLOW || 0);
       fd = openSync(file, Number(fsConstants.O_RDWR) | noFollow);
       const info = fstatSync(fd);
-      if (!info.isFile()) continue;
-      if (info.size > maxBytes) {
-        const length = Math.min(keepBytes, info.size);
-        const buffer = Buffer.alloc(length);
-        readSync(fd, buffer, 0, length, Math.max(0, info.size - length));
-        const tail = lineSafeTail(buffer);
+      if (!info.isFile()) {
+        if (migrate) migrationComplete = false;
+        continue;
+      }
+      if (migrate && info.size > 0) {
+        const legacy = readLogTail(fd, info.size, maxBytes);
+        if (legacy.length) writePrivateServiceFile(path.join(logs, legacyLogName(name)), legacy);
+        ftruncateSync(fd, 0);
+      } else if (info.size > maxBytes) {
+        const tail = readLogTail(fd, info.size, keepBytes);
         ftruncateSync(fd, 0);
         if (tail.length) writeSync(fd, tail, 0, tail.length, 0);
       }
       try { chmodSync(file, 0o600); } catch {}
     } catch {
+      if (migrate) migrationComplete = false;
       // Operational log maintenance is best effort and must not stop startup.
     } finally {
       if (fd !== undefined) try { closeSync(fd); } catch {}
     }
   }
+
+  if (migrate && migrationComplete) {
+    try { writePrivateServiceFile(schemaFile, `${schemaVersion}\n`); } catch {}
+  }
+}
+
+function readLogSchema(file) {
+  try { return readBoundedRegularFileSync(file, 64).toString("utf8").trim(); } catch { return ""; }
+}
+
+function readLogTail(fd, size, limit) {
+  const length = Math.min(limit, size);
+  const buffer = Buffer.alloc(length);
+  readSync(fd, buffer, 0, length, Math.max(0, size - length));
+  return lineSafeTail(buffer);
+}
+
+function legacyLogName(name) {
+  return name.endsWith(".log") ? `${name.slice(0, -4)}.legacy.log` : `${name}.legacy`;
 }
 
 function lineSafeTail(buffer) {

package/src/worker/index.ts

@@ -3,7 +3,7 @@ import toolCatalog from "../shared/tool-catalog.json";
 import serverMetadata from "../shared/server-metadata.json";
 
 const SERVER_NAME = String(serverMetadata.name);
-const SERVER_VERSION = "0.8.0";
+const SERVER_VERSION = "0.8.1";
 const MCP_PROTOCOL_VERSION = String(serverMetadata.protocolVersion);
 const MCP_SUPPORTED_PROTOCOL_VERSIONS = serverMetadata.supportedProtocolVersions.map((value) => String(value));
 const JSONRPC_VERSION = "2.0";