@rubytech/create-maxy-code 0.1.351 → 0.1.353

package/payload/platform/plugins/cloudflare/skills/calendar-site/template/public/booking.js

@@ -1,13 +1,29 @@
 // Public booking page (calendar-site skill). Dependency-free.
 // 1. Fetch open slots from the brand tunnel free/busy endpoint.
-// 2. Let the visitor pick one, then collect name/email/note.
+// 2. Page the horizon five days at a time, let the visitor pick a slot
+//    (and, when the operator allows it, extend to back-to-back slots).
 // 3. POST the booking to the same-origin Pages Function (/api/book → D1).
 (function () {
   'use strict'
 
-  var DAYS_AHEAD = 14
-  var apiBaseMeta = document.querySelector('meta[name="api-base"]')
-  var apiBase = (apiBaseMeta && apiBaseMeta.getAttribute('content')) || ''
+  var WINDOW_DAYS = 5
+
+  function metaContent(name) {
+    var el = document.querySelector('meta[name="' + name + '"]')
+    return el ? el.getAttribute('content') : null
+  }
+
+  // Operator-set booking horizon. The skill rewrites the meta at assemble time;
+  // fall back to 14 only when it is absent or left unsubstituted, so pages
+  // assembled before this change behave exactly as they did.
+  var parsedDaysAhead = parseInt(metaContent('days-ahead'), 10)
+  var daysAhead = isFinite(parsedDaysAhead) && parsedDaysAhead > 0 ? parsedDaysAhead : 14
+
+  // Operator choice: may a visitor combine consecutive open slots into one
+  // longer booking? Anything other than the literal "true" is off.
+  var allowMultiSlot = metaContent('allow-multi-slot') === 'true'
+
+  var apiBase = metaContent('api-base') || ''
 
   var statusEl = document.getElementById('bk-status')
   var slotsEl = document.getElementById('bk-slots')
@@ -18,7 +34,12 @@
   var durationEl = document.getElementById('bk-duration')
   var backBtn = document.getElementById('bk-back')
 
-  var chosenSlot = null
+  // The slots that share the chosen block's day, the index of the first slot
+  // in that block, and how many back-to-back slots it spans. count stays 1
+  // unless the operator enabled multi-slot bookings.
+  var block = null
+  // Extend/shorten controls, built lazily once and reused.
+  var multiControls = null
 
   function setStatus(msg) {
     statusEl.textContent = msg || ''
@@ -27,9 +48,57 @@
   function fmtDayHeading(d) {
     return d.toLocaleDateString([], { weekday: 'long', month: 'long', day: 'numeric' })
   }
+  function fmtShortDay(d) {
+    return d.toLocaleDateString([], { month: 'short', day: 'numeric' })
+  }
   function fmtTime(d) {
     return d.toLocaleTimeString([], { hour: 'numeric', minute: '2-digit' })
   }
+  function dayKey(d) {
+    return d.toDateString()
+  }
+  function startOfLocalDay(d) {
+    var x = new Date(d)
+    x.setHours(0, 0, 0, 0)
+    return x
+  }
+  function clear(el) {
+    while (el.firstChild) el.removeChild(el.firstChild)
+  }
+
+  // ---- horizon state, set once per free/busy load -------------------------
+  var allDays = [] // local-midnight Date per calendar day in the horizon
+  var slotsByDay = {} // dayKey -> ordered slot array
+  var windowStart = 0 // index into allDays, advances in WINDOW_DAYS steps
+
+  // The first and last slot of the chosen block — the single source of the
+  // block's index arithmetic, shared by the formatters and the submit payload.
+  function firstSlot() {
+    return block.daySlots[block.startIdx]
+  }
+  function lastSlot() {
+    return block.daySlots[block.startIdx + block.count - 1]
+  }
+  function blockStart() {
+    return new Date(firstSlot().start)
+  }
+  function blockEnd() {
+    return new Date(lastSlot().end)
+  }
+  // The slot immediately after the current block, if it is open and back-to-back.
+  function nextContiguousSlot() {
+    var next = block.daySlots[block.startIdx + block.count]
+    if (!next) return null
+    return next.start === lastSlot().end ? next : null
+  }
+
+  function fmtChosen() {
+    var start = blockStart()
+    if (block.count === 1) {
+      return fmtDayHeading(start) + ' at ' + fmtTime(start)
+    }
+    return fmtDayHeading(start) + ', ' + fmtTime(start) + ' – ' + fmtTime(blockEnd())
+  }
 
   function renderSlots(data) {
     var slots = (data && data.slots) || []
@@ -37,69 +106,184 @@
       durationEl.textContent = data.durationMins + ' minute meeting'
     }
     if (slots.length === 0) {
-      setStatus('No open times in the next two weeks. Please check back later.')
+      setStatus('No open times in the next ' + daysAhead + ' day' + (daysAhead === 1 ? '' : 's') + '. Please check back later.')
       return
     }
     setStatus('')
 
-    var byDay = {}
-    var order = []
+    // The full calendar-day list for the horizon, today first. setDate keeps
+    // local midnight across DST, unlike adding fixed millisecond spans.
+    var today = startOfLocalDay(new Date())
+    allDays = []
+    for (var i = 0; i < daysAhead; i++) {
+      var d = new Date(today)
+      d.setDate(today.getDate() + i)
+      allDays.push(d)
+    }
+
+    slotsByDay = {}
     slots.forEach(function (s) {
-      var start = new Date(s.start)
-      var key = start.toDateString()
-      if (!byDay[key]) {
-        byDay[key] = []
-        order.push(key)
-      }
-      byDay[key].push(s)
+      var k = dayKey(new Date(s.start))
+      if (!slotsByDay[k]) slotsByDay[k] = []
+      slotsByDay[k].push(s)
+    })
+    Object.keys(slotsByDay).forEach(function (k) {
+      slotsByDay[k].sort(function (a, b) {
+        return new Date(a.start) - new Date(b.start)
+      })
     })
 
-    order.forEach(function (key) {
-      var group = document.createElement('div')
-      group.className = 'bk-day'
-      var h = document.createElement('h2')
-      h.className = 'bk-day-title'
-      h.textContent = fmtDayHeading(new Date(key))
-      group.appendChild(h)
-
-      var row = document.createElement('div')
-      row.className = 'bk-day-slots'
-      byDay[key].forEach(function (s) {
-        var btn = document.createElement('button')
-        btn.type = 'button'
-        btn.className = 'bk-slot'
-        btn.textContent = fmtTime(new Date(s.start))
-        btn.addEventListener('click', function () {
-          chooseSlot(s)
-        })
-        row.appendChild(btn)
+    windowStart = 0
+    console.log('[booking] daysAhead=' + daysAhead + ' allowMultiSlot=' + allowMultiSlot + ' windowStart=' + windowStart)
+    renderWindow()
+  }
+
+  function renderWindow() {
+    clear(slotsEl)
+
+    var nav = document.createElement('div')
+    nav.className = 'bk-nav'
+
+    var back = document.createElement('button')
+    back.type = 'button'
+    back.className = 'bk-arrow'
+    back.setAttribute('aria-label', 'Previous days')
+    back.textContent = '‹'
+    back.disabled = windowStart === 0
+    back.addEventListener('click', function () {
+      windowStart = Math.max(0, windowStart - WINDOW_DAYS)
+      console.log('[booking] windowStart=' + windowStart)
+      renderWindow()
+    })
+
+    var label = document.createElement('span')
+    label.className = 'bk-nav-label'
+    var lastIdx = Math.min(windowStart + WINDOW_DAYS, allDays.length) - 1
+    label.textContent = fmtShortDay(allDays[windowStart]) + ' – ' + fmtShortDay(allDays[lastIdx])
+
+    var fwd = document.createElement('button')
+    fwd.type = 'button'
+    fwd.className = 'bk-arrow'
+    fwd.setAttribute('aria-label', 'Next days')
+    fwd.textContent = '›'
+    fwd.disabled = windowStart + WINDOW_DAYS >= allDays.length
+    fwd.addEventListener('click', function () {
+      // Reachable only when not disabled, so a full step always has room.
+      windowStart += WINDOW_DAYS
+      console.log('[booking] windowStart=' + windowStart)
+      renderWindow()
+    })
+
+    nav.appendChild(back)
+    nav.appendChild(label)
+    nav.appendChild(fwd)
+    slotsEl.appendChild(nav)
+
+    for (var i = windowStart; i < windowStart + WINDOW_DAYS && i < allDays.length; i++) {
+      slotsEl.appendChild(renderDayGroup(allDays[i]))
+    }
+  }
+
+  // One day's heading plus its slot buttons (or the empty note). Kept as its own
+  // function so each slot button closes over that day's own slot array — a shared
+  // loop-scoped var would leave every handler pointing at the last day rendered.
+  function renderDayGroup(day) {
+    var group = document.createElement('div')
+    group.className = 'bk-day'
+
+    var h = document.createElement('h2')
+    h.className = 'bk-day-title'
+    h.textContent = fmtDayHeading(day)
+    group.appendChild(h)
+
+    var daySlots = slotsByDay[dayKey(day)]
+    if (!daySlots || daySlots.length === 0) {
+      var note = document.createElement('p')
+      note.className = 'bk-day-empty'
+      note.textContent = 'No availability'
+      group.appendChild(note)
+      return group
+    }
+
+    var row = document.createElement('div')
+    row.className = 'bk-day-slots'
+    daySlots.forEach(function (s, idx) {
+      var btn = document.createElement('button')
+      btn.type = 'button'
+      btn.className = 'bk-slot'
+      btn.textContent = fmtTime(new Date(s.start))
+      btn.addEventListener('click', function () {
+        chooseSlot(daySlots, idx)
       })
-      group.appendChild(row)
-      slotsEl.appendChild(group)
+      row.appendChild(btn)
+    })
+    group.appendChild(row)
+    return group
+  }
+
+  function ensureMultiControls() {
+    if (multiControls) return multiControls
+    multiControls = document.createElement('div')
+    multiControls.className = 'bk-extend'
+
+    var shorten = document.createElement('button')
+    shorten.type = 'button'
+    shorten.className = 'bk-extend-btn'
+    shorten.id = 'bk-shorten'
+    shorten.textContent = '− Shorten'
+    shorten.addEventListener('click', function () {
+      if (block.count > 1) {
+        block.count--
+        refreshChosen()
+      }
     })
+
+    var extend = document.createElement('button')
+    extend.type = 'button'
+    extend.className = 'bk-extend-btn'
+    extend.id = 'bk-extend'
+    extend.textContent = '+ Add next slot'
+    extend.addEventListener('click', function () {
+      if (nextContiguousSlot()) {
+        block.count++
+        refreshChosen()
+      }
+    })
+
+    multiControls.appendChild(shorten)
+    multiControls.appendChild(extend)
+    chosenEl.insertAdjacentElement('afterend', multiControls)
+    return multiControls
+  }
+
+  function refreshChosen() {
+    chosenEl.textContent = fmtChosen()
+    if (!allowMultiSlot) return
+    ensureMultiControls()
+    document.getElementById('bk-shorten').disabled = block.count <= 1
+    document.getElementById('bk-extend').disabled = !nextContiguousSlot()
   }
 
-  function chooseSlot(slot) {
-    chosenSlot = slot
-    var start = new Date(slot.start)
-    chosenEl.textContent = fmtDayHeading(start) + ' at ' + fmtTime(start)
+  function chooseSlot(daySlots, idx) {
+    block = { daySlots: daySlots, startIdx: idx, count: 1 }
+    refreshChosen()
     slotsEl.hidden = true
     formEl.hidden = false
   }
 
   backBtn.addEventListener('click', function () {
-    chosenSlot = null
+    block = null
     formEl.hidden = true
     slotsEl.hidden = false
   })
 
   formEl.addEventListener('submit', function (e) {
     e.preventDefault()
-    if (!chosenSlot) return
+    if (!block) return
     var fd = new FormData(formEl)
     var payload = {
-      slotStart: chosenSlot.start,
-      slotEnd: chosenSlot.end,
+      slotStart: firstSlot().start,
+      slotEnd: lastSlot().end,
       name: fd.get('name'),
       email: fd.get('email'),
       note: fd.get('note'),
@@ -125,8 +309,7 @@
         }
         formEl.hidden = true
         doneEl.hidden = false
-        var start = new Date(chosenSlot.start)
-        doneMsg.textContent = 'Confirmed for ' + fmtDayHeading(start) + ' at ' + fmtTime(start) + '. A confirmation will follow by email.'
+        doneMsg.textContent = 'Confirmed for ' + fmtChosen() + '. A confirmation will follow by email.'
       })
       .catch(function (err) {
         submitBtn.disabled = false
@@ -137,8 +320,14 @@
 
   function load() {
     setStatus('Loading available times…')
+    // Fetch exactly the horizon the page renders: from now through the end of
+    // the last calendar day in [today, today + daysAhead). Bounding `to` to a
+    // local-midnight day edge (not now + daysAhead*24h) keeps the fetched range
+    // and the rendered `allDays` window in the same local frame, so no slot is
+    // returned for a day the window cannot show.
     var from = new Date()
-    var to = new Date(from.getTime() + DAYS_AHEAD * 24 * 60 * 60 * 1000)
+    var to = startOfLocalDay(from)
+    to.setDate(to.getDate() + daysAhead)
     var url = apiBase + '/api/calendar/free-busy?from=' + encodeURIComponent(from.toISOString()) + '&to=' + encodeURIComponent(to.toISOString())
     fetch(url)
       .then(function (res) {

package/payload/platform/plugins/cloudflare/skills/calendar-site/template/public/index.html

@@ -6,6 +6,12 @@
   <!-- The calendar-site skill rewrites the content of this tag to the brand
        tunnel origin that serves /api/calendar/free-busy. -->
   <meta name="api-base" content="__API_BASE__" />
+  <!-- Operator-set booking horizon (positive integer days). The skill rewrites
+       the content; booking.js falls back to 14 when it is left unsubstituted. -->
+  <meta name="days-ahead" content="__DAYS_AHEAD__" />
+  <!-- Operator choice: may a visitor combine consecutive open slots into one
+       longer booking? "true" or "false"; booking.js falls back to false. -->
+  <meta name="allow-multi-slot" content="__ALLOW_MULTI_SLOT__" />
   <title>Book a time</title>
   <link rel="stylesheet" href="/booking.css" />
 </head>

package/payload/platform/plugins/connector/.claude-plugin/plugin.json

@@ -0,0 +1,21 @@
+{
+  "name": "connector",
+  "description": "Generic credentialed connector — register a named REST API with a static credential, then make host-bound authenticated requests to it. Admin-driven.",
+  "version": "0.1.0",
+  "author": {
+    "name": "Rubytech LLC"
+  },
+  "mcpServers": {
+    "connector": {
+      "type": "stdio",
+      "command": "node",
+      "args": [
+        "${CLAUDE_PLUGIN_ROOT}/lib/mcp-spawn-tee/index.js",
+        "${CLAUDE_PLUGIN_ROOT}/mcp/dist/index.js"
+      ],
+      "env": {
+        "MCP_SPAWN_TEE_NAME": "connector"
+      }
+    }
+  }
+}

package/payload/platform/plugins/connector/PLUGIN.md

@@ -0,0 +1,55 @@
+---
+name: connector
+description: "Generic credentialed connector — register a named REST API with a static credential, then make host-bound authenticated requests to it. Admin-driven."
+tools:
+  - name: connector-register
+    publicAllowlist: false
+    adminAllowlist: true
+  - name: connector-call
+    publicAllowlist: false
+    adminAllowlist: true
+  - name: connector-list
+    publicAllowlist: false
+    adminAllowlist: true
+  - name: connector-deregister
+    publicAllowlist: false
+    adminAllowlist: true
+metadata: {"platform":{"optional":true,"pluginKey":"connector"}}
+mcp:
+  command: node
+  args:
+    - ${PLATFORM_ROOT}/lib/mcp-spawn-tee/dist/index.js
+    - ${PLATFORM_ROOT}/plugins/connector/mcp/dist/index.js
+  env:
+    MCP_SPAWN_TEE_NAME: connector
+    LOG_DIR: ${LOG_DIR}
+    PLATFORM_ROOT: ${PLATFORM_ROOT}
+    ACCOUNT_ID: ${ACCOUNT_ID}
+    SESSION_ID: ${SESSION_ID}
+mcp-manifest: auto
+---
+
+# Connector
+
+A generic, credentialed bridge to any third-party REST API. Register an API once by name with its base URL and a static credential; the agent can then make authenticated requests to it without a bespoke plugin per integration. This is the capability that lets self-serve agent and skill authoring reach the long tail of niche APIs.
+
+The credential is stored in the account's secrets file and is never returned by a tool or written to a log. Every request is confined to the registered API's host: a request aimed at any other host, at a private or loopback address, or a redirect that leaves the host, is refused.
+
+## Capabilities
+
+- **connector-register** — store a named API's base URL and a static credential. The credential scheme is one of bearer, api-key-header (a named header), or basic. Returns the non-secret record only.
+- **connector-call** — make a request (GET or a mutating method) to a registered connector. The credential is injected from the secret store; the request is host-bound and SSRF-guarded. Returns the status, redacted response headers, and the (size-capped) body.
+- **connector-list** — the registered connectors for this account: names and base URLs only.
+- **connector-deregister** — remove a connector and its stored credential.
+
+## Who can use it
+
+These tools are admin-driven. The operator's admin agent registers connectors and makes calls; the tools are not granted to any specialist agent, given their reach (arbitrary authenticated outbound requests and a credential store). A vertical agent that needs an external API is served by the admin acting on its behalf.
+
+## Credentials and isolation
+
+Credentials live only in this account's secrets directory (mode 0600), inside the brand-isolated install — the same store the other credentialed connectors use. Each connector is keyed by name and scoped to the account. A standing audit periodically confirms no stored credential has reached a log and that every registered connector still has its credential.
+
+## Scope
+
+Static credentials only — OAuth client-credentials and refresh-token flows are a separate capability. HTTP(S) REST only; no GraphQL or SOAP transport. The business logic an operator layers on top of a connected API is authored as a skill, not part of this transport.

package/payload/platform/plugins/connector/lib/mcp-spawn-tee/index.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * MCP spawn-tee — in-process stderr capture + lifecycle observability.
+ *
+ * Claude Code spawns each MCP server itself; the platform never holds a
+ * ChildProcess handle. This shim sits between Claude Code and the real MCP
+ * server: Claude Code runs `node <this> <real-entry>`, and the shim runs the
+ * real entry IN ITS OWN PROCESS via dynamic import() — one node runtime, not
+ * two. Before importing, it replaces process.stderr.write with a tee so every
+ * stderr byte the server writes is mirrored to the log sinks; stdin and stdout
+ * (the JSON-RPC channel) are never touched.
+ *
+ *   Claude Code CLI → shim (this file) = node running <real-entry> in-process
+ *        stdin/stdout : untouched (JSON-RPC channel)
+ *        stderr       : process.stderr.write teed → per-date + per-session + passthrough
+ *
+ * Destinations (Task 706) — unchanged:
+ *   - `${LOG_DIR}/mcp-<name>-stderr-<date>.log`  — per-date raw (back-compat;
+ *     the in-process mcp-stderr-tee and the [mcp-init-error] probe read it).
+ *   - `${LOG_DIR}/mcp-<name>-<SESSION_ID>.log`   — per-session raw + lifecycle
+ *     lines. Authoritative sink. Absent when SESSION_ID is unset (enumeration
+ *     spawn) — then the per-date file is the fallback.
+ *   - `server.log` via the loopback log-ingest route — best-effort mirror of
+ *     the [mcp-helper] lifecycle lines.
+ *
+ * Lifecycle lines, correlation key `session=<id8> server=<name>` — unchanged:
+ *   [mcp-helper] op=spawn ... pid= entry=
+ *   [mcp-helper] op=boot  ... head=<first stderr bytes>
+ *   [mcp-helper] op=exit  ... code= signal= lifetimeMs= stderr-tail=
+ *
+ * Process model (Task 989): the shim IS the server's process. op=exit fires
+ * from process.on("exit"), so it covers a normal exit, a non-zero exit, an
+ * uncaught throw (code 1), and a catchable-signal exit (SIGTERM/SIGINT/SIGHUP,
+ * whose handlers record the signal name). An external SIGKILL is uncatchable
+ * and leaves no op=exit line — the per-session stderr tail already on disk and
+ * Claude Code's own transport-drop are the evidence for that death mode.
+ *
+ * The shim never writes to fd 1 (stdout) — that is the JSON-RPC channel.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const SERVER_NAME = process.env.MCP_SPAWN_TEE_NAME ?? "unknown";
+const LOG_DIR = process.env.LOG_DIR;
+const SESSION_ID = process.env.SESSION_ID;
+const PLATFORM_PORT = process.env.PLATFORM_PORT;
+const ENTRY = process.argv[2];
+const SESSION_ID8 = SESSION_ID ? SESSION_ID.slice(0, 8) : "—";
+const spawnStamp = Date.now();
+// Per-session raw + lifecycle log (Task 706). Empty SESSION_ID (enumeration
+// spawn) → undefined, and the per-date file is the fallback.
+const perSessionPath = LOG_DIR && SESSION_ID
+    ? (0, node_path_1.resolve)(LOG_DIR, `mcp-${SERVER_NAME}-${SESSION_ID}.log`)
+    : undefined;
+const perDatePath = LOG_DIR
+    ? (0, node_path_1.resolve)(LOG_DIR, `mcp-${SERVER_NAME}-stderr-${new Date(spawnStamp).toISOString().slice(0, 10)}.log`)
+    : undefined;
+// Rolling tail of entry stderr for op=exit. Capped so a chatty server cannot
+// grow the buffer without bound.
+const TAIL_CAP = 2048;
+let stderrTail = "";
+let bootEmitted = false;
+let exitEmitted = false;
+let exitSignal;
+// The real stderr writer, captured before the tee replaces it. Lifecycle lines
+// and stderr passthrough both go through this so they are never re-teed into
+// the per-date sink nor recursed back into the patched writer.
+const rawStderrWrite = process.stderr.write.bind(process.stderr);
+// LOG_DIR is created once, lazily, on the first successful append — not per
+// chunk. teeWrite runs on the server's own stderr hot path now, so a per-call
+// mkdirSync would be two syscalls per log line for nothing.
+let logDirReady = false;
+function appendSafe(path, data) {
+    if (!path || !LOG_DIR)
+        return;
+    try {
+        if (!logDirReady) {
+            (0, node_fs_1.mkdirSync)(LOG_DIR, { recursive: true });
+            logDirReady = true;
+        }
+        (0, node_fs_1.appendFileSync)(path, data);
+    }
+    catch {
+        /* unwritable destination — never mask primary output */
+    }
+}
+// Best-effort mirror of a lifecycle line to server.log via the loopback
+// log-ingest route. Fire-and-forget: the per-session file is authoritative, so
+// a dropped POST loses nothing. On the "exit" event the loop is stopping, so
+// the op=exit mirror may not flush — the per-session line, written sync, holds.
+function postToServerLog(suffix, level) {
+    if (!PLATFORM_PORT)
+        return;
+    try {
+        const ctrl = new AbortController();
+        const t = setTimeout(() => ctrl.abort(), 500);
+        t.unref?.(); // never let the abort timer keep the shim's event loop alive
+        void fetch(`http://127.0.0.1:${PLATFORM_PORT}/api/admin/log-ingest`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ tag: "mcp-helper", level, line: suffix }),
+            signal: ctrl.signal,
+        }).then(() => clearTimeout(t)).catch(() => clearTimeout(t));
+    }
+    catch {
+        /* fetch threw synchronously — best-effort only */
+    }
+}
+// Emit one [mcp-helper] lifecycle line: authoritative per-session file (sync,
+// survives process.exit), the shim's own stderr via the RAW writer (journald /
+// Claude Code visibility, never re-teed), and a best-effort server.log mirror.
+// `suffix` is the line body after the tag and carries no newline (the
+// log-ingest route rejects newlines).
+function emitLifecycle(suffix, level) {
+    const line = `[mcp-helper] ${suffix}\n`;
+    appendSafe(perSessionPath, line);
+    try {
+        rawStderrWrite(line);
+    }
+    catch { /* stderr closed */ }
+    postToServerLog(suffix, level);
+}
+if (!ENTRY) {
+    emitLifecycle(`op=error session=${SESSION_ID8} server=${SERVER_NAME} reason="no entry given (argv[2] missing)"`, "error");
+    process.exit(2);
+}
+// Replace process.stderr.write with a tee: mirror every server stderr byte to
+// the per-date and per-session sinks, keep a rolling tail for op=exit, emit
+// op=boot on the first bytes, then pass the write through to the real stderr.
+const teeWrite = ((...args) => {
+    const chunk = args[0];
+    appendSafe(perDatePath, chunk); // per-date raw (back-compat)
+    appendSafe(perSessionPath, chunk); // per-session raw (Task 706)
+    const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    stderrTail = (stderrTail + text).slice(-TAIL_CAP);
+    if (!bootEmitted) {
+        bootEmitted = true;
+        const head = text.split("\n")[0].slice(0, 200);
+        emitLifecycle(`op=boot session=${SESSION_ID8} server=${SERVER_NAME} head=${JSON.stringify(head)}`, "info");
+    }
+    return rawStderrWrite(...args); // passthrough
+});
+process.stderr.write = teeWrite;
+// Catchable-signal handling. The shim drives the exit ONLY when it is the sole
+// listener for the signal — i.e. the imported entry installed no handler of its
+// own. In that case it records the signal (so op=exit carries signal=<sig>) and
+// exits with 128+signum, mirroring the prior wrapper's exit-status convention.
+//
+// When the entry DID install a handler, the shim defers entirely and records
+// nothing: the entry's handler decides the exit code, and op=exit reflects that
+// exit verbatim. This matches the prior two-process model, where a child that
+// caught the signal and exited cleanly was observed as code=0 signal=— (a clean
+// self-exit), not as a signal death. Setting exitSignal here unconditionally
+// would mislabel every graceful signal-driven shutdown as a signal kill.
+function onSignal(sig, code) {
+    return () => {
+        if (process.listenerCount(sig) === 1) {
+            exitSignal = sig;
+            process.exit(code);
+        }
+    };
+}
+process.on("SIGTERM", onSignal("SIGTERM", 143));
+process.on("SIGINT", onSignal("SIGINT", 130));
+process.on("SIGHUP", onSignal("SIGHUP", 129));
+// op=exit, emitted once from the process "exit" event. Sync-only — the loop is
+// stopping. When a catchable signal caused the exit, report code=— signal=<sig>
+// to match the prior wrapper's format; otherwise code=<exit code> signal=—.
+process.on("exit", (code) => {
+    if (exitEmitted)
+        return;
+    exitEmitted = true;
+    const lifetimeMs = Date.now() - spawnStamp;
+    const tail = stderrTail.slice(-200);
+    const codeField = exitSignal ? "—" : String(code);
+    const level = exitSignal || code !== 0 ? "error" : "info";
+    emitLifecycle(`op=exit session=${SESSION_ID8} server=${SERVER_NAME} pid=${process.pid} ` +
+        `code=${codeField} signal=${exitSignal ?? "—"} lifetimeMs=${lifetimeMs} stderr-tail=${JSON.stringify(tail)}`, level);
+});
+emitLifecycle(`op=spawn session=${SESSION_ID8} server=${SERVER_NAME} pid=${process.pid} entry=${ENTRY}`, "info");
+// Run the real MCP server in THIS process. Dynamic import() (not top-level
+// await — this file compiles to CommonJS) loads the ESM entry; a load-time
+// failure mirrors the old child spawn-error path (op=error, exit 127). The
+// op=exit handler is suppressed on this path so op=error stays the sole record.
+import((0, node_url_1.pathToFileURL)(ENTRY).href).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    exitEmitted = true;
+    emitLifecycle(`op=error session=${SESSION_ID8} server=${SERVER_NAME} reason=${JSON.stringify(`import error: ${msg}`)}`, "error");
+    process.exit(127);
+});
+//# sourceMappingURL=index.js.map

package/payload/platform/plugins/connector/lib/mcp-spawn-tee/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/payload/platform/plugins/connector/mcp/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/payload/platform/plugins/connector/mcp/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}