granttap-mcp 0.8.101 → 0.8.102

package/README.md

@@ -855,3 +855,10 @@ See [repository observations](apps/bridge/src/mesh/repository-details/README.md)
 The relay can retain recipient-encrypted catalogs, Mesh snapshots, capability usage and recent chat heads for reconnect without the computer. This bounded seven-day read cache is separate from the durable encrypted command queue. See [relay state publication](packages/core/retained-state/README.md). The relay never receives decryption keys or readable chat content.
 
 Tools & Skills matches recorded usage to the exact computer, provider and execution. Codex's native history projection supplies actual MCP invocation IDs, results and durations, including calls made through Code Mode. Claude Code uses observed tool-use, result and Skill records, aggregating MCP and skill calls before its recent-detail cache is trimmed. Execution summaries remain available when older call details fall outside the recent-event budget. Counts describe recorded evidence; installation and permission do not prove usage. Missing resource measurements remain unknown. See [native capability history](apps/bridge/src/sessions/native-capability-history/README.md).
+
+## Automatic runtime updates
+
+Installed GrantTap background services check for stable MCP updates automatically.
+Verified updates are staged separately and applied after active requests and pending
+decisions finish. Startup failures restore the previous version. Pairing and task
+policies are retained; source checkouts and running provider processes stay in place.

package/apps/bridge/src/bin/runtime/monitor.ts

@@ -1,3 +1,5 @@
+import { startRuntimeUpdates } from "../../runtime-updates";
+import { runtimeUpdateReadiness } from "../../runtime-updates/readiness";
 /** Persistent, terminal-free task sync for the GrantTap phone app on macOS. */
 import { join } from "node:path";
 import { RelayClient } from "../../../../../packages/core/relay-client";
@@ -25,6 +27,8 @@ let stopEndpointPublisher = () => {};
 let stopTaskDispatch = () => {};
 let stopTaskNetwork = () => {};
 let stopEngineRecovery = () => {};
+let stopRuntimeUpdates = () => {};
+let stopUpdateReadiness = () => {};
 
 try {
   const cfg = applyNetworkRoute(loadConfig(machineConfigPath()));
@@ -40,6 +44,8 @@ try {
   stopTaskNetwork = startTaskNetworkMonitor({ config: cfg, client,
     isLeader: monitor.isLeader, peerAllowed: controllerPeerGate(cfg), publish: monitor.publish });
   stopEndpointPublisher = startEndpointPublisher(cfg);
+  stopRuntimeUpdates = startRuntimeUpdates(monitor.canUpdate);
+  stopUpdateReadiness = runtimeUpdateReadiness(monitor.canUpdate);
 } catch (error) {
   process.stderr.write(
     `[granttap-mcp] monitor is not paired: ${error instanceof Error ? error.message : String(error)}\n`,
@@ -50,6 +56,8 @@ try {
 const stop = (): void => {
   if (stopping) return;
   stopping = true;
+  stopRuntimeUpdates();
+  stopUpdateReadiness();
   stopEngineRecovery();
   stopTaskDispatch();
   stopTaskNetwork();

package/apps/bridge/src/monitor/support/runtime.ts

@@ -1,3 +1,4 @@
+import { runtimeWorkTracker } from "../../runtime-updates/readiness";
 import { refreshCodexHooks } from "../../codex-hook-trust";
 import { computerDisplayName } from "../../../../../packages/core/computer-name";
 import { RelayClient } from "../../../../../packages/core/relay-client";
@@ -38,6 +39,7 @@ import { publishMonitorCapabilities, stopMonitorCapabilities } from "../capabili
 export type SessionMonitor = {
   publish: () => Promise<void>;
   isLeader: () => boolean;
+  canUpdate: () => boolean;
   close: () => void;
 };
 
@@ -163,29 +165,13 @@ async function publishMonitorTick(input: {
 export function startSessionMonitor(client: RelayClient): SessionMonitor {
   const subscriptions = new Set<string>();
   const leadership = monitorLeadership();
-  primeSessionKeys(client);
-  publishedCatalog(client);
+  restoreMonitorState(client);
   let historyCache: { generatedAt: number; sessions: SessionsStatus["sessions"] } | undefined;
   let historyRead: Promise<SessionsStatus["sessions"]> | undefined;
   let lastHistoryPublishedAt = 0;
   let closed = false;
-  const publishMachineLoad = createMachineLoadPublisher({
-    log: (line) => process.stderr.write(`[monitor] ${line}\n`),
-  });
-  const loadLoop = startMachineLoadLoop({
-    connected: () => client.isConnected,
-    // Only the leader reports load. Every MCP server used to run this loop
-    // too, each with the code of the day it started, and the phone flickered
-    // between their answers.
-    publish: (status, intervalMs) => (leadership.acquire()
-      ? publishMachineLoad(client, status, intervalMs)
-      : Promise.resolve(undefined)),
-    onError: (error) => {
-      process.stderr.write(
-        `[monitor] load report failed: ${error instanceof Error ? error.message : String(error)}\n`,
-      );
-    },
-  });
+  const work = runtimeWorkTracker(() => approvalsStatus().pending.length > 0);
+  const loadLoop = monitorLoadLoop(client, leadership);
 
   const history = (force = false): Promise<SessionsStatus["sessions"]> => {
     if (historyRead) return historyRead;
@@ -209,7 +195,7 @@ export function startSessionMonitor(client: RelayClient): SessionMonitor {
     lastHistoryPublishedAt = next.lastHistoryPublishedAt;
   });
 
-  const off = client.onMessage(async (payload: Payload, peerPublicKey) => {
+  const off = client.onMessage((payload: Payload, peerPublicKey) => work.run(async () => {
     if (payload.type === "hello" && payload.role === "phone") {
       confirmPendingController(client.room, peerPublicKey);
       recordControllerName(peerPublicKey, payload.deviceName);
@@ -219,8 +205,8 @@ export function startSessionMonitor(client: RelayClient): SessionMonitor {
         await replayNativeQuestions(client, peerPublicKey);
       }
     }
-    return handleMonitorMessage(client, payload, { leadership, subscriptions, publish, peerPublicKey });
-  });
+    return await handleMonitorMessage(client, payload, { leadership, subscriptions, publish, peerPublicKey });
+  }));
 
   const offConnected = client.onConnected?.(() => publish().catch(() => {}));
 
@@ -244,6 +230,7 @@ export function startSessionMonitor(client: RelayClient): SessionMonitor {
   return {
     publish: () => publish(false),
     isLeader: () => leadership.acquire(),
+    canUpdate: work.idle,
     close: () => {
       closed = true;
       offConnected?.();
@@ -279,3 +266,28 @@ async function replayNativeQuestions(client: RelayClient, peerPublicKey: string)
   const known = publishedCatalog(client);
   if (known) await publishCodexQuestions(client, known.sessions, { replay: true, peerPublicKey }).catch(() => {});
 }
+
+function restoreMonitorState(client: RelayClient): void {
+  primeSessionKeys(client);
+  publishedCatalog(client);
+}
+
+function monitorLoadLoop(client: RelayClient, leadership: ReturnType<typeof monitorLeadership>) {
+  const publishMachineLoad = createMachineLoadPublisher({
+    log: (line) => process.stderr.write(`[monitor] ${line}\n`),
+  });
+  return startMachineLoadLoop({
+    connected: () => client.isConnected,
+    // Only the leader reports load. Every MCP server used to run this loop
+    // too, each with the code of the day it started, and the phone flickered
+    // between their answers.
+    publish: (status, intervalMs) => (leadership.acquire()
+      ? publishMachineLoad(client, status, intervalMs)
+      : Promise.resolve(undefined)),
+    onError: (error) => {
+      process.stderr.write(
+        `[monitor] load report failed: ${error instanceof Error ? error.message : String(error)}\n`,
+      );
+    },
+  });
+}

package/apps/bridge/src/runtime-updates/README.md

@@ -0,0 +1,26 @@
+# Automatic GrantTap runtime updates
+
+The installed background monitor checks the official `granttap-mcp` npm stable
+release every four hours. New versions are installed in a separate private
+version directory under `~/.granttap/runtime-updates`, with lifecycle scripts
+disabled, Node engine checks enabled, and registry integrity verified. A failed
+installation leaves the running version in place.
+
+The stable launcher selects the verified version for future invocations. Owned
+background services switch only after their current requests finish and no
+approval is pending. Existing provider processes and active stdio MCP calls keep
+running. A new service that cannot start restores the previous version; that
+failed version is quarantined until a newer release appears.
+
+Pairing, account credentials, task history, capability policy, and provider
+installations are not modified by runtime updates. Offline checks retry later.
+Source checkouts and test processes do not update themselves. Administrators may
+set `GRANTTAP_DISABLE_AUTO_UPDATE=1` on their service to retain their installed
+version. Private staging consumes space; old versions are retained for rollback.
+
+Public entry: `startRuntimeUpdates`, `runtimeUpdateReadiness`, and the launcher's
+`selection.mjs` / `supervision.mjs` boundary. Tests exercise failed downloads and
+verification, deferred activation, concurrent installation, selection, and startup
+rollback using isolated directories and owned child processes.
+
+License: [GrantTap Commercial Source License](../../../../LICENSE).

package/apps/bridge/src/runtime-updates/http-readiness.ts

@@ -0,0 +1,17 @@
+import type { Express } from 'express';
+
+/** Long-lived HTTP/SSE calls defer replacement until their normal completion. */
+export function trackHttpRuntimeWork(app:Express):()=>boolean {
+  let activeRequests=0;
+  app.use((_req,res,next)=>{
+    activeRequests++;
+    let finished=false;
+    const complete=()=>{
+      if(!finished) {finished=true;activeRequests--;}
+    };
+    res.once('finish',complete);
+    res.once('close',complete);
+    next();
+  });
+  return ()=>activeRequests===0;
+}

package/apps/bridge/src/runtime-updates/index.ts

@@ -0,0 +1,68 @@
+import { closeSync, mkdirSync, openSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { configDir } from '../config/runtime/paths';
+import { latestRelease, trustedRelease, installRelease, verifyRelease, type Release } from './registry';
+import { newerVersion, readState, runtimeVersion, saveState, validRuntime, versionRoot } from './selection.mjs';
+
+type Options={root:string;stateDirectory:string;now?:()=>number;latest?:()=>Promise<unknown>;
+  idle:()=>boolean;install?:(release:Release,directory:string)=>Promise<void>;
+  verify?:(root:string)=>Promise<void>;activate?:(root:string)=>void};
+
+/** Stage verified releases independently; activation waits until no request or decision is pending. */
+export async function checkForRuntimeUpdate(options:Options):Promise<string|undefined> {
+  mkdirSync(options.stateDirectory,{recursive:true,mode:0o700});
+  const lock=join(options.stateDirectory,'install.lock');let fd:number;
+  try {fd=openSync(lock,'wx',0o600);} catch {return undefined;}
+  try {
+    const release=await (options.latest??latestRelease)();
+    const state=readState(options.stateDirectory);
+    if(!trustedRelease(release) || !newerVersion(release.version,runtimeVersion(options.root))
+      || state.rejectedVersion===release.version || (state.version && !newerVersion(release.version,state.version)))return;
+    const candidate=versionRoot(options.stateDirectory,release.version);
+    if(!validRuntime(candidate,options.stateDirectory,release.version)) {
+      await (options.install??installRelease)(release,options.stateDirectory);
+    }
+    await (options.verify??verifyRelease)(candidate);
+    if(!validRuntime(candidate,options.stateDirectory,release.version))throw Error('Runtime verification failed');
+    if(!options.idle())return;
+    saveState(options.stateDirectory,{root:candidate,version:release.version,
+      previous:state.root?{root:state.root,version:state.version}:undefined});
+    options.activate?.(candidate);return candidate;
+  } finally {closeSync(fd);unlinkSync(lock);}
+}
+
+type LoopOptions={root:string;directory:string;idle:()=>boolean;check?:typeof checkForRuntimeUpdate;
+  now?:()=>number;schedule?:typeof setTimeout;report?:()=>void;activate?:()=>void};
+
+/** Check failure never stops sync; timers are owned and cancellation prevents another check. */
+export function runtimeUpdateLoop(options:LoopOptions):()=>void {
+  let stopped=false,timer:NodeJS.Timeout|undefined,lastCheck=0;
+  const now=options.now??Date.now,schedule=options.schedule??setTimeout;
+  const tick=async()=>{
+    if(stopped)return;
+    try {
+      const lock=join(options.directory,'install.lock');
+      try {if(now()-statSync(lock).mtimeMs>10*60_000)unlinkSync(lock);} catch { /* no stale lock */ }
+      if(now()-lastCheck>=4*60*60_000) {
+        await (options.check??checkForRuntimeUpdate)({root:options.root,stateDirectory:options.directory,idle:options.idle,
+          activate:()=>options.activate?.()});
+        lastCheck=options.idle()?now():0;
+      }
+    } catch {options.report?.();}
+    finally {if(!stopped){timer=schedule(()=>void tick(),60_000);timer.unref();}}
+  };
+  timer=schedule(()=>void tick(),60_000);timer.unref();
+  return ()=>{stopped=true;if(timer)clearTimeout(timer);};
+}
+
+/** Only the owned installed background monitor downloads updates; source checkouts stay fixed. */
+export function startRuntimeUpdates(idle:()=>boolean):()=>void {
+  if(process.env.GRANTTAP_DISABLE_AUTO_UPDATE==='1' || process.env.GRANTTAP_LOCAL==='1'
+    || process.env.NODE_TEST_CONTEXT || !process.send)return ()=>{};
+  const root=fileURLToPath(new URL('../../../../',import.meta.url));
+  if(!root.includes('node_modules'))return ()=>{};
+  return runtimeUpdateLoop({root,directory:join(configDir(),'runtime-updates'),idle,
+    activate:()=>process.send?.({type:'granttap.runtime-update-ready'},()=>{}),
+    report:()=>process.stderr.write('[granttap-mcp] Automatic runtime update deferred; current version retained.\n')});
+}

package/apps/bridge/src/runtime-updates/readiness.ts

@@ -0,0 +1,23 @@
+/** Only the launcher's private IPC channel can ask the owned service to drain for an update. */
+export function runtimeUpdateReadiness(idle:()=>boolean):()=>void {
+  const listener=(message:unknown)=>{
+    if((message as {type?:string})?.type==='granttap.runtime-update-check' && idle()) {
+      process.send?.({type:'granttap.runtime-update-ready'},()=>{});
+    }
+  };
+  process.on('message',listener);
+  process.send?.({type:'granttap.runtime-healthy'},()=>{});
+  return ()=>{process.off('message',listener);};
+}
+
+/** Count async work until completion; an update cannot interrupt a partially delivered command. */
+export function runtimeWorkTracker(blocked:()=>boolean) {
+  let count=0;
+  return {
+    idle:()=>count===0 && !blocked(),
+    run:async<T>(work:()=>Promise<T>):Promise<T>=>{
+      count++;
+      try {return await work();} finally {count--;}
+    },
+  };
+}

package/apps/bridge/src/runtime-updates/registry.ts

@@ -0,0 +1,58 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { stableVersion, validRuntime, versionRoot } from './selection.mjs';
+
+export type Release = {name:string;version:string;dist:{integrity:string;tarball:string}};
+const registry='https://registry.npmjs.org';
+export function trustedRelease(value:unknown):value is Release {
+  const r=value as Release|undefined;
+  return r?.name==='granttap-mcp' && stableVersion(r.version)
+    && typeof r.dist?.integrity==='string' && /^sha512-[A-Za-z0-9+/]{86}==$/.test(r.dist.integrity)
+    && r.dist.tarball===`${registry}/granttap-mcp/-/granttap-mcp-${r.version}.tgz`;
+}
+/** Registry metadata is bounded, timed, and never changes the installed runtime by itself. */
+export async function latestRelease():Promise<unknown> {
+  const response=await fetch(registry+'/granttap-mcp/latest',{signal:AbortSignal.timeout(10_000),redirect:'error'});
+  if(!response.ok || !response.body) throw Error('Runtime registry unavailable');
+  const reader=response.body.getReader();let size=0;const chunks:Uint8Array[]=[];
+  try { for(;;) {const {done,value}=await reader.read();if(done)break;
+    size+=value.byteLength;if(size>262_144)throw Error('Runtime metadata exceeds limit');chunks.push(value);
+  } } finally {await reader.cancel();}
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+export function run(command:string,args:string[],timeoutMs=180_000,env:NodeJS.ProcessEnv=process.env):Promise<void> {
+  return new Promise((resolve,reject)=>{
+    const child=spawn(command,args,{env,stdio:'ignore',windowsHide:true});let done=false;
+    const finish=(error?:Error)=>{if(done)return;done=true;clearTimeout(timer);error?reject(error):resolve();};
+    const timer=setTimeout(()=>{child.kill();finish(Error('Runtime update command timed out'));},timeoutMs);
+    child.once('error',()=>finish(Error('Runtime update command could not start')));
+    child.once('exit',code=>finish(code===0?undefined:Error('Runtime update command failed')));
+  });
+}
+function npmCli():string {
+  const bin=dirname(process.execPath);
+  for(const path of [join(bin,'npm'),join(bin,'node_modules','npm','bin','npm-cli.js'),
+    join(bin,'..','lib','node_modules','npm','bin','npm-cli.js')]) {
+    if(existsSync(path) && !path.endsWith('.cmd'))return realpathSync(path);
+  }
+  throw Error('The installed Node runtime has no npm updater');
+}
+/** npm verifies registry integrity and Node compatibility in a version-specific, isolated prefix. */
+export async function installRelease(release:Release,directory:string,runner=run):Promise<void> {
+  await runner(process.execPath,[npmCli(),'install','--prefix',join(directory,'versions',release.version),
+    '--registry',registry,'--ignore-scripts','--engine-strict','--omit=dev','--no-audit','--no-fund',
+    '--save-exact',`granttap-mcp@${release.version}`]);
+  const lock=JSON.parse(readFileSync(join(directory,'versions',release.version,'package-lock.json'),'utf8'));
+  const installed=lock.packages?.['node_modules/granttap-mcp'];
+  if(installed?.version!==release.version || installed?.integrity!==release.dist.integrity
+    || installed?.resolved!==release.dist.tarball || !validRuntime(versionRoot(directory,release.version),directory,release.version)) {
+    throw Error('Installed runtime identity or registry integrity did not match');
+  }
+}
+export async function verifyRelease(root:string):Promise<void> {
+  await run(process.execPath,[join(root,'bin','granttap-mcp.mjs'),'--help'],15_000,
+    {...process.env,GRANTTAP_DISABLE_AUTO_UPDATE:'1'});
+  // Validate the launcher without starting services or reading the live pairing.
+  await run(process.execPath,['--check',join(root,'bin','granttap-mcp.mjs')],15_000);
+}

package/apps/bridge/src/runtime-updates/selection.d.mts

@@ -0,0 +1,10 @@
+export type RuntimeState = {root?:string;version?:string;rejectedVersion?:string;previous?:RuntimeState};
+export function stableVersion(value:unknown):value is string;
+export function newerVersion(candidate:string,current:string):boolean;
+export function readState(directory:string):RuntimeState;
+export function saveState(directory:string,state:RuntimeState):void;
+export function runtimeVersion(root:string):string;
+export function versionRoot(directory:string,version:string):string;
+export function validRuntime(root:string|undefined,directory:string,version:string|undefined):boolean;
+export function selectedRuntime(bundled:string,directory:string):string;
+export function rollbackRuntime(bundled:string,directory:string,failedRoot?:string):boolean;

package/apps/bridge/src/runtime-updates/selection.mjs

@@ -0,0 +1,46 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+export const stableVersion = value => typeof value === 'string' && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(value);
+export function newerVersion(candidate, current) {
+  if (!stableVersion(candidate) || !stableVersion(current)) return false;
+  const a=candidate.split('.').map(Number), b=current.split('.').map(Number);
+  for(let i=0;i<3;i++) { if(a[i]!==b[i]) return a[i]>b[i]; }
+  return false;
+}
+export function readState(directory) {
+  try { return JSON.parse(readFileSync(join(directory,'active.json'),'utf8')); } catch { return {}; }
+}
+export function saveState(directory, state) {
+  mkdirSync(directory,{recursive:true,mode:0o700});
+  const path=join(directory,'active.json'), temporary=path+'.'+process.pid+'.tmp';
+  writeFileSync(temporary,JSON.stringify(state),{mode:0o600});renameSync(temporary,path);
+}
+export function runtimeVersion(root) {
+  const p=JSON.parse(readFileSync(join(root,'package.json'),'utf8'));
+  if(p.name!=='granttap-mcp' || !stableVersion(p.version)) throw Error('Invalid GrantTap runtime package');
+  return p.version;
+}
+export function versionRoot(directory, version) {
+  return join(directory,'versions',version,'node_modules','granttap-mcp');
+}
+export function validRuntime(root, directory, version) {
+  try { return stableVersion(version) && resolve(root)===resolve(versionRoot(directory,version))
+    && runtimeVersion(root)===version && existsSync(join(root,'bin','granttap-mcp.mjs')); } catch { return false; }
+}
+/** The stable launcher accepts only a verified, newer package inside its private version cache. */
+export function selectedRuntime(bundled, directory) {
+  const state=readState(directory);
+  return validRuntime(state.root,directory,state.version) && newerVersion(state.version,runtimeVersion(bundled))
+    ? state.root : bundled;
+}
+/** A new background service that exits during startup restores the last working selection. */
+export function rollbackRuntime(bundled, directory, failedRoot) {
+  const state=readState(directory);
+  if(!state.version || (failedRoot && state.root!==failedRoot)) return false;
+  const rejectedVersion=state.version, previous=state.previous;
+  if(previous && validRuntime(previous.root,directory,previous.version)) {
+    saveState(directory,{...previous,rejectedVersion});
+  } else saveState(directory,{rejectedVersion});
+  return true;
+}

package/apps/bridge/src/runtime-updates/supervision.mjs

@@ -0,0 +1,28 @@
+import { selectedRuntime, rollbackRuntime } from './selection.mjs';
+
+/** Monitor only the child started by this launcher; external providers are never stopped. */
+export function superviseRuntime(child, options) {
+  const {bundled,root,directory}=options;
+  const started=(options.now??Date.now)();let healthy=root===bundled,stopped=false;
+  const read=()=>selectedRuntime(bundled,directory);
+  const changed=()=>read()!==root;
+  const stop=()=>{if(stopped)return;stopped=true;clearInterval(timer);child.off('message',onMessage);};
+  const onMessage=message=>{
+    if(message?.type==='granttap.runtime-healthy')healthy=true;
+    if(message?.type==='granttap.runtime-update-ready' && changed()) {stop();child.kill('SIGTERM');}
+  };
+  const tick=()=>{
+    if(stopped)return;
+    if(!healthy && (options.now??Date.now)()-started>120_000) {
+      rollbackRuntime(bundled,directory,root);stop();child.kill('SIGTERM');return;
+    }
+    if(changed() && child.connected)child.send({type:'granttap.runtime-update-check'},()=>{});
+  };
+  const timer=(options.schedule??setInterval)(tick,10_000);timer.unref?.();child.on('message',onMessage);
+  return {stop,onExit:(code,signal)=>{
+    if(!stopped && !healthy && code!==0 && !['SIGTERM','SIGINT'].includes(signal)) {
+      rollbackRuntime(bundled,directory,root);
+    }
+    stop();
+  }};
+}

package/apps/mcp/src/http/http-server.ts

@@ -1,3 +1,6 @@
+import { trackHttpRuntimeWork } from "../../../bridge/src/runtime-updates/http-readiness";
+import { runtimeUpdateReadiness } from "../../../bridge/src/runtime-updates/readiness";
+import { approvalsStatus } from "../../../bridge/src/approvals/state";
 /**
  * GrantTap MCP over Streamable HTTP + loopback OAuth with website consent.
  *
@@ -63,6 +66,7 @@ export async function startHttpMcpServer(options: ServeOptions = {}): Promise<{
   const issuerUrl = new URL(`http://${host === "::1" ? "[::1]" : host}:${port}`);
   const provider = new GrantTapOAuthProvider(mcpUrl.href);
   const app = createMcpExpressApp({ host });
+  const httpIdle = trackHttpRuntimeWork(app);
   app.use(express.urlencoded({ extended: false }));
   app.use(mcpAuthRouter({
     provider,
@@ -120,11 +124,13 @@ export async function startHttpMcpServer(options: ServeOptions = {}): Promise<{
   const stopAccountRecovery = accountOrigin
     ? startAccountRecoveryPoller(accountOrigin, refreshRecoveredPairing) : () => {};
 
+  const stopUpdateReadiness=runtimeUpdateReadiness(()=>httpIdle() && approvalsStatus().pending.length===0);
   return {
     host,
     port,
     mcpUrl: mcpUrl.href,
     close: async () => {
+      stopUpdateReadiness();
       stopAccountRecovery();
       await sessions.close();
       resetConnectWatchers();

package/bin/granttap-mcp.mjs

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { selectedRuntime, runtimeVersion, rollbackRuntime } from "../apps/bridge/src/runtime-updates/selection.mjs";
+import { superviseRuntime } from "../apps/bridge/src/runtime-updates/supervision.mjs";
 import { createRequire } from "node:module";
 import { delimiter, dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -12,7 +15,12 @@ if (!isSupportedNode(process.versions.node)) {
   process.exit(1);
 }
 
-const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const bundledRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+const updateDirectory = join(process.env.GRANTTAP_CONFIG_DIR ?? process.env.NODVOX_CONFIG_DIR
+  ?? join(homedir(), ".granttap"), "runtime-updates");
+const managed = bundledRoot.includes("node_modules") && process.env.GRANTTAP_LOCAL !== "1"
+  && process.env.GRANTTAP_DISABLE_AUTO_UPDATE !== "1" && !process.env.NODE_TEST_CONTEXT;
+const root = managed ? selectedRuntime(bundledRoot, updateDirectory) : bundledRoot;
 const [command = "mcp", ...commandArgs] = process.argv.slice(2);
 const argument = commandArgs[0];
 
@@ -85,7 +93,7 @@ if (command === "mcp") {
 
 // Cursor (and LaunchAgents) often spawn with cwd=$HOME. Bare `--import tsx` then
 // resolves from home and dies with ERR_MODULE_NOT_FOUND. Pin absolute loaders + cwd.
-const requireFromBin = createRequire(import.meta.url);
+const requireFromBin = createRequire(join(root,"package.json"));
 let preflight;
 let loader;
 try {
@@ -105,6 +113,7 @@ try {
   }
 }
 if (!preflight || !loader) {
+  if (root !== bundledRoot) rollbackRuntime(bundledRoot, updateDirectory, root);
   process.stderr.write(
     "[granttap-mcp] unable to resolve the installed tsx runtime — reinstall granttap-mcp\n",
   );
@@ -114,22 +123,27 @@ if (!preflight || !loader) {
 const forwardedArgs = ["connect", "status", "reset", "mesh", "setup", "restrictions", "phone"].includes(command)
   ? (command === "mesh" || command === "restrictions" ? commandArgs.slice(1) : commandArgs)
   : [];
+const background = command === "internal" && ["monitor", "serve"].includes(argument);
 const child = spawn(
   process.execPath,
   ["--require", preflight, "--import", pathToFileURL(loader).href,
     "--import", pathToFileURL(join(root, "apps", "bridge", "src", "engine", "startup", "activation-entry.ts")).href,
     entry, ...forwardedArgs],
   {
-    stdio: "inherit",
+    stdio: background ? ["inherit", "inherit", "inherit", "ipc"] : "inherit",
     cwd: root,
     env: {
       ...process.env,
+      GRANTTAP_PACKAGE_VERSION: runtimeVersion(root),
       NODE_PATH: [join(root, "node_modules"), process.env.NODE_PATH].filter(Boolean).join(delimiter),
     },
   },
 );
 
+const supervision = background && managed ? superviseRuntime(child, {bundled:bundledRoot, root, directory:updateDirectory}) : undefined;
+
 function stopChild() {
+  supervision?.stop();
   try {
     if (process.platform === "win32") child.kill();
     else child.kill("SIGTERM");
@@ -148,6 +162,7 @@ child.on("error", (error) => {
 });
 
 child.on("exit", (code, signal) => {
+  supervision?.onExit(code, signal);
   if (signal && process.platform !== "win32") {
     try { process.kill(process.pid, signal); } catch { process.exit(code ?? 1); }
   } else process.exit(code ?? 1);

package/cursor-plugin/README.md

@@ -10,7 +10,7 @@ keeps each phone response tied to the exact originating chat and prompt.
 Install the supported CLI on this computer, then run:
 
 ```bash
-npm install -g granttap-mcp@0.8.101
+npm install -g granttap-mcp@0.8.102
 granttap setup
 granttap status
 ```

package/cursor-plugin/mcp.json

@@ -4,7 +4,7 @@
       "command": "node",
       "args": [
         "-e",
-        "\"use strict\";\n\n// Cursor may start this MCP from any cwd. Execute JavaScript entry points with\n// Node itself: Windows batch shims require shell quoting that differs by host.\nconst { spawn } = require(\"node:child_process\");\nconst { existsSync } = require(\"node:fs\");\nconst { delimiter, dirname, join } = require(\"node:path\");\n\nconst PACKAGE = \"granttap-mcp@0.8.101\";\nconst dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === \"1\";\nconst platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM\n  ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;\nconst nodeRoot = dryRun && process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT\n  ? process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT : dirname(process.execPath);\nconst pathRoots = (process.env.PATH || \"\").split(delimiter).filter(Boolean);\nconst appData = process.env.APPDATA;\nconst roots = [nodeRoot, ...pathRoots, ...(appData ? [join(appData, \"npm\")] : [])];\nconst first = (paths) => paths.find((path) => existsSync(path));\n\nfunction launch() {\n  if (platform !== \"win32\") {\n    const installed = first(roots.map((root) => join(root, \"granttap-mcp\")));\n    if (installed) return { command: installed, args: [] };\n    const npx = first(roots.map((root) => join(root, \"npx\"))) || \"npx\";\n    return { command: npx, args: [\"-y\", PACKAGE] };\n  }\n  const installed = first(roots.map((root) =>\n    join(root, \"node_modules\", \"granttap-mcp\", \"bin\", \"granttap-mcp.mjs\")));\n  if (installed) return { command: process.execPath, args: [installed] };\n  const npx = first(roots.map((root) =>\n    join(root, \"node_modules\", \"npm\", \"bin\", \"npx-cli.js\")));\n  if (npx) return { command: process.execPath, args: [npx, \"-y\", PACKAGE] };\n  throw new Error(\"Node.js/npm 22.13.0+ is required on this Windows device. Install npm and retry GrantTap.\");\n}\n\nlet target;\ntry { target = launch(); }\ncatch (error) {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n}\n\nif (dryRun) {\n  process.stdout.write(JSON.stringify(target));\n  process.exit(0);\n}\n\nconst child = spawn(target.command, target.args, { stdio: \"inherit\", windowsHide: true });\nchild.on(\"error\", (error) => {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n});\nchild.on(\"exit\", (code, signal) => {\n  if (signal && platform !== \"win32\") {\n    try { process.kill(process.pid, signal); } catch { process.exit(code ?? 1); }\n    return;\n  }\n  process.exit(code ?? 1);\n});\n"
+        "\"use strict\";\n\n// Cursor may start this MCP from any cwd. Execute JavaScript entry points with\n// Node itself: Windows batch shims require shell quoting that differs by host.\nconst { spawn } = require(\"node:child_process\");\nconst { existsSync } = require(\"node:fs\");\nconst { delimiter, dirname, join } = require(\"node:path\");\n\nconst PACKAGE = \"granttap-mcp@0.8.102\";\nconst dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === \"1\";\nconst platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM\n  ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;\nconst nodeRoot = dryRun && process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT\n  ? process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT : dirname(process.execPath);\nconst pathRoots = (process.env.PATH || \"\").split(delimiter).filter(Boolean);\nconst appData = process.env.APPDATA;\nconst roots = [nodeRoot, ...pathRoots, ...(appData ? [join(appData, \"npm\")] : [])];\nconst first = (paths) => paths.find((path) => existsSync(path));\n\nfunction launch() {\n  if (platform !== \"win32\") {\n    const installed = first(roots.map((root) => join(root, \"granttap-mcp\")));\n    if (installed) return { command: installed, args: [] };\n    const npx = first(roots.map((root) => join(root, \"npx\"))) || \"npx\";\n    return { command: npx, args: [\"-y\", PACKAGE] };\n  }\n  const installed = first(roots.map((root) =>\n    join(root, \"node_modules\", \"granttap-mcp\", \"bin\", \"granttap-mcp.mjs\")));\n  if (installed) return { command: process.execPath, args: [installed] };\n  const npx = first(roots.map((root) =>\n    join(root, \"node_modules\", \"npm\", \"bin\", \"npx-cli.js\")));\n  if (npx) return { command: process.execPath, args: [npx, \"-y\", PACKAGE] };\n  throw new Error(\"Node.js/npm 22.13.0+ is required on this Windows device. Install npm and retry GrantTap.\");\n}\n\nlet target;\ntry { target = launch(); }\ncatch (error) {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n}\n\nif (dryRun) {\n  process.stdout.write(JSON.stringify(target));\n  process.exit(0);\n}\n\nconst child = spawn(target.command, target.args, { stdio: \"inherit\", windowsHide: true });\nchild.on(\"error\", (error) => {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n});\nchild.on(\"exit\", (code, signal) => {\n  if (signal && platform !== \"win32\") {\n    try { process.kill(process.pid, signal); } catch { process.exit(code ?? 1); }\n    return;\n  }\n  process.exit(code ?? 1);\n});\n"
       ]
     }
   }

package/cursor-plugin/stdio-bootstrap.cjs

@@ -7,7 +7,7 @@ const { spawn } = require("node:child_process");
 const { existsSync } = require("node:fs");
 const { delimiter, dirname, join } = require("node:path");
 
-const PACKAGE = "granttap-mcp@0.8.101";
+const PACKAGE = "granttap-mcp@0.8.102";
 const dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === "1";
 const platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM
   ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "granttap-mcp",
-  "version": "0.8.101",
+  "version": "0.8.102",
   "description": "Commercial computer runtime connecting local coding agents to GrantTap on Mac, iPhone, iPad and Apple Watch.",
   "type": "module",
   "bin": {