replica-bridge 0.3.6 → 0.3.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replica-bridge",
-  "version": "0.3.6",
+  "version": "0.3.9",
   "description": "Lets the ChatReplica iPhone app use Codex on this computer through a relay, end-to-end encrypted.",
   "type": "module",
   "bin": {

package/src/bridge/install.js

@@ -1,6 +1,7 @@
 // Keeping the bridge running after its terminal closes, the way Codex keeps its app-server: a per-user background
 // service that starts at login and restarts when it fails. macOS: a launchd agent. Linux: a systemd user service.
-// Windows: a Task Scheduler task at logon that runs a hidden script, which restarts the bridge when it exits.
+// Windows: a Task Scheduler task at logon (and checked every minute) that runs a hidden script, which restarts the
+// bridge when it exits.
 // The service runs a copy installed under ~/.config/replica-bridge/app, not the npx cache, which npm may clear.
 import fs from "node:fs";
 import os from "node:os";
@@ -24,10 +25,15 @@ export const PACKAGE_VERSION         = JSON.parse(fs.readFileSync(path.resolve(i
               
                                                                  
                 
+                                                                                             
+                   
+                                                                                      
+             
  
 
                               
-                                             
+                                                                                             
+                                                                   
                                                                                    
                                                                      
                                                                        
@@ -39,6 +45,7 @@ export const serviceLabel = () => process.env.REPLICA_BRIDGE_LABEL ?? "replica-b
 export const logPath = (home = bridgeHome()) => path.join(home, "bridge.log");
 const infoPath = () => path.join(bridgeHome(), "service.json");
 const pidPath = () => path.join(bridgeHome(), "bridge.pid");
+const pausedPath = () => path.join(bridgeHome(), "service-paused");
 
 const xml = (text        ) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 /** systemd unit-file quoting: specifiers (%) doubled, backslashes and quotes escaped. */
@@ -126,6 +133,7 @@ WantedBy=default.target
     }
     case "win32": {
       const script = path.join(spec.bridgeHome, "run-bridge.vbs");
+      const task = path.join(spec.bridgeHome, "replica-bridge-task.xml");
       // wscript shows no window; the loop brings the bridge back ten seconds after it fails. Exit code 0 means another
       // bridge took this computer over (or it was told to stop), so the loop ends.
       const content = [
@@ -139,11 +147,42 @@ WantedBy=default.target
         `Loop`,
         "",
       ].join("\r\n");
+      // `schtasks /SC ONLOGON` left Task Scheduler's defaults, which stopped the bridge on a laptop that went on battery
+      // (and never started it on one), stopped it after three days, and started it again only at the next login: the
+      // computer went offline for the phones until someone logged in. The task XML turns those off, retries a failed
+      // start, and checks every minute that the task runs (IgnoreNew: never a second copy while one runs). The logon
+      // trigger is this account's alone; one for every user needs an elevated terminal.
+      const user = spec.account ? `<UserId>${xml(spec.account)}</UserId>` : "";
+      // Without a zone Task Scheduler reads it as local time; a UTC one would delay the first check by the offset.
+      const now = spec.now ?? new Date();
+      const start = new Date(now.getTime() - now.getTimezoneOffset() * 60_000).toISOString().slice(0, 19);
+      const taskXML = `<?xml version="1.0" encoding="UTF-16"?>
+<!-- Elements in the order Task Scheduler exports them. -->
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo><Description>replica-bridge: ChatReplica phones use Codex on this computer. Made by "replica-bridge install".</Description></RegistrationInfo>
+  <Triggers>
+    <LogonTrigger><Enabled>true</Enabled>${user}</LogonTrigger>
+    <TimeTrigger><Repetition><Interval>PT1M</Interval><StopAtDurationEnd>false</StopAtDurationEnd></Repetition><StartBoundary>${start}</StartBoundary><Enabled>true</Enabled></TimeTrigger>
+  </Triggers>
+  <Principals><Principal id="Author">${user}<LogonType>InteractiveToken</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal></Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <IdleSettings><StopOnIdleEnd>false</StopOnIdleEnd><RestartOnIdle>false</RestartOnIdle></IdleSettings>
+    <Enabled>true</Enabled>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure><Interval>PT1M</Interval><Count>3</Count></RestartOnFailure>
+  </Settings>
+  <Actions Context="Author"><Exec><Command>wscript.exe</Command><Arguments>${xml(`"${script}"`)}</Arguments></Exec></Actions>
+</Task>
+`;
       return {
-        files: [{ path: script, content }],
+        files: [{ path: script, content }, { path: task, content: taskXML, encoding: "utf16le" }],
         install: [
           { command: "schtasks", args: ["/End", "/TN", spec.label], optional: true },
-          { command: "schtasks", args: ["/Create", "/F", "/TN", spec.label, "/SC", "ONLOGON", "/RL", "LIMITED", "/TR", `wscript.exe "${script}"`] },
+          { command: "schtasks", args: ["/Create", "/F", "/TN", spec.label, "/XML", task] },
           { command: "schtasks", args: ["/Run", "/TN", spec.label] },
         ],
         uninstall: [
@@ -242,7 +281,8 @@ export function readServiceInfo()                     {
 
 function spec(program          )              {
   const { uid, username } = os.userInfo();
-  return { platform: process.platform, label: serviceLabel(), home: os.homedir(), bridgeHome: bridgeHome(), program, env: serviceEnv(), uid, user: username };
+  const account = process.env.USERDOMAIN ? `${process.env.USERDOMAIN}\\${username}` : username;
+  return { platform: process.platform, label: serviceLabel(), home: os.homedir(), bridgeHome: bridgeHome(), program, env: serviceEnv(), uid, user: username, account };
 }
 
 /** Installs (or replaces) the background service and starts it. `startArgs` are the options `start` keeps. */
@@ -254,8 +294,9 @@ export function installService(startArgs          , say                        )
   fs.mkdirSync(bridgeHome(), { recursive: true, mode: 0o700 });
   for (const file of plan.files) {
     fs.mkdirSync(path.dirname(file.path), { recursive: true });
-    fs.writeFileSync(file.path, file.content);
+    fs.writeFileSync(file.path, file.encoding === "utf16le" ? Buffer.concat([Buffer.from([0xff, 0xfe]), Buffer.from(file.content, "utf16le")]) : file.content);
   }
+  fs.rmSync(pausedPath(), { force: true });
   run(plan.install);
   const info              = { platform: process.platform, label: serviceLabel(), version: PACKAGE_VERSION, program, installedAt: new Date().toISOString() };
   fs.writeFileSync(infoPath(), JSON.stringify(info, null, 2) + "\n");
@@ -306,6 +347,20 @@ export function runningPid()                {
   try { process.kill(pid, 0); return pid; } catch (error) { return (error                         ).code === "EPERM" ? pid : null; }
 }
 
+/**
+ * Another bridge took this computer over at the relay. The Windows task's every-minute check would start this one
+ * again, and the two would take turns kicking each other off; this marks the service stopped until the next install
+ * or the next boot, the way launchd and systemd leave a service that exited 0.
+ */
+export function pauseService() {
+  fs.mkdirSync(bridgeHome(), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(pausedPath(), new Date().toISOString() + "\n");
+}
+
+export function servicePaused()          {
+  try { return !writtenBeforeBoot(fs.statSync(pausedPath()).mtimeMs); } catch { return false; }
+}
+
 /** The service manager stops its own process; on Windows the loop's bridge is left, so it goes by pid. */
 function stopRunning() {
   const pid = runningPid();

package/src/bridge/main.js

@@ -18,7 +18,7 @@ import { parseArgs, format } from "node:util";
 import { relayRequest } from "../http.js";
 import { spawnCommandSync } from "./command.js";
 import { defaultRelayURL, enroll, ensureEnrolled, ensureRelay } from "./enroll.js";
-import { PACKAGE_VERSION, clearPid, installService, logPath, readServiceInfo, runningPid, servicePlan, uninstallService, writePid } from "./install.js";
+import { PACKAGE_VERSION, clearPid, installService, logPath, pauseService, readServiceInfo, runningPid, servicePaused, servicePlan, uninstallService, writePid } from "./install.js";
 import { pair, publicRelayURL } from "./pair.js";
 import { BridgeService } from "./service.js";
 import { loadState, saveState } from "./state.js";
@@ -73,7 +73,12 @@ function startArgs()           {
 
 function startBridge()                {
   // Exit 0: the background services restart the bridge only when it fails, so the newer bridge keeps the computer.
-  const service = new BridgeService({ codexPath: values.codex, loginShell: !values["no-login-shell"], streamTTLSeconds: Number(values["stream-ttl"]), onReplaced: () => process.exit(0) });
+  // The Windows task also checks every minute, so there the service is marked paused first.
+  const onReplaced = () => {
+    if (process.env.REPLICA_BRIDGE_SERVICE === "1" && process.platform === "win32") pauseService();
+    process.exit(0);
+  };
+  const service = new BridgeService({ codexPath: values.codex, loginShell: !values["no-login-shell"], streamTTLSeconds: Number(values["stream-ttl"]), onReplaced });
   service.start();
   return service;
 }
@@ -108,6 +113,8 @@ async function wantBackground()                   {
 
 function install()       {
   const plan = installService(startArgs(), console.log);
+  // The service writes its pid once it has started; `status` right after the install said "not running" before that.
+  for (let waited = 0; !runningPid() && waited < 10_000; waited += 200) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
   console.log(`Running in the background: ${plan.where}. It starts at login and comes back if it stops, so this terminal can be closed.`);
   console.log(`Log: ${logPath()}. Remove it with "npx replica-bridge uninstall".`);
   // The install asked for lingering (the service starts at boot, not at login); some systems only let root grant it.
@@ -210,6 +217,10 @@ async function main() {
     case "start": {
       await ensureEnrolled(values.relay, console.log, values.name);
       const asService = process.env.REPLICA_BRIDGE_SERVICE === "1";
+      if (asService && servicePaused()) {
+        console.log(`another bridge took this computer over; the background service stays stopped until "npx replica-bridge install" or the next restart`);
+        return;
+      }
       if (runningPid()) throw new Error(`a bridge already runs for this computer (pid ${runningPid()})${asService ? "" : '; "npx replica-bridge uninstall" stops the background one'}`);
       const bridge = startBridge();
       if (asService) { writePid(); process.on("exit", clearPid); }

package/src/bridge/service.js

@@ -37,6 +37,8 @@ import { annotateWriterError } from "./writer.js";
                           
                                                                                           
                                                             
+                                                                                                                          
+                            
  
 
                   
@@ -100,7 +102,18 @@ export class BridgeService {
     const state = loadState();
     const ws = new WebSocket(relaySocketURL(state.relay, "/v1/host"), { headers: { authorization: `Bearer ${state.hostToken}` }, maxPayload: MAX_FRAME_BYTES + 4096, perMessageDeflate: false });
     this.relay = ws;
-    ws.on("open", () => { this.retry = 0; this.log(`connected to relay ${state.relay} as ${state.hostId}`); });
+    // A laptop that sleeps or changes networks keeps a socket the relay dropped long ago, and nothing here would
+    // notice until the bridge sent something: the computer stayed offline for the phones. A missed pong ends it.
+    let answered = true;
+    const ping = setInterval(() => {
+      if (!answered) { this.log("relay did not answer a ping; reconnecting"); return ws.terminate(); }
+      answered = false;
+      // Still connecting counts as a missed pong too, so a handshake that never finishes ends at the next tick.
+      if (ws.readyState === WebSocket.OPEN) ws.ping();
+    }, (this.options.relayPingSeconds ?? 30) * 1000);
+    ws.on("pong", () => { answered = true; });
+    ws.on("ping", () => { answered = true; });
+    ws.on("open", () => { answered = true; this.retry = 0; this.log(`connected to relay ${state.relay} as ${state.hostId}`); });
     ws.on("message", (data         ) => {
       let envelope              ;
       try { envelope = JSON.parse(data.toString()); } catch { return; }
@@ -116,6 +129,7 @@ export class BridgeService {
     });
     ws.on("error", (error) => this.log(`relay connection error: ${error.message}`));
     ws.on("close", (code) => {
+      clearInterval(ping);
       if (ws !== this.relay) return; // a socket this bridge already replaced itself
       for (const conn of this.conns.values()) this.detach(conn);
       this.conns.clear();
@@ -236,6 +250,9 @@ export class BridgeService {
     const resumed = !!stream && stream.deviceId === conn.deviceId;
     if (!resumed) {
       stream = await this.openStream(conn.deviceId);
+      // The phone may have left while the app-server came up. It never heard this stream's id, so it cannot come back
+      // for it, and detach found no stream to start the timer on: left alone, its proxy stays as long as the bridge.
+      if (this.stopped || this.conns.get(conn.id) !== conn) return this.endStream(stream, "the phone left before its stream opened");
     }
     const s = stream ;
     if (s.conn && s.conn !== conn) this.closeConn(s.conn, "resumed elsewhere");