@blue-soda/dsh-remote 0.5.2 → 0.5.3

package/README.md

@@ -23,7 +23,7 @@ Continue DeepSeek Harness sessions and experimental Codex workspaces from anothe
 Add the current package version to the `web` profile, then restart Harness:
 
 ```sh
-dsh plugin --profile web add -w @blue-soda/dsh-remote@0.5.2
+dsh plugin --profile web add -w @blue-soda/dsh-remote@0.5.3
 ```
 
 ### dsh-TUI Host
@@ -31,7 +31,7 @@ dsh plugin --profile web add -w @blue-soda/dsh-remote@0.5.2
 Remote can also run as a Host in a terminal-only [dsh-TUI](https://github.com/ccch1mneyyy/dsh-TUI) profile:
 
 ```sh
-dsh plugin --profile dsh-tui add -w @blue-soda/dsh-remote@0.5.2
+dsh plugin --profile dsh-tui add -w @blue-soda/dsh-remote@0.5.3
 ```
 
 After starting dsh-TUI, manage Remote with `/remote`, `/remote login`, `/remote status`, and `/remote logout`.

package/dist/index.js

@@ -13162,7 +13162,7 @@ function fromBase64Url2(value) {
 import { platform } from "node:os";
 
 // src/server-credentials.ts
-import { chmod, mkdir, readFile, rm as rm2, stat as stat2, writeFile } from "node:fs/promises";
+import { chmod, mkdir, readFile, rename as rename2, rm as rm2, stat as stat2, writeFile } from "node:fs/promises";
 import { dirname, join as join2 } from "node:path";
 
 // src/atomic-file.ts
@@ -13237,6 +13237,11 @@ function uuidV7(now = Date.now()) {
 }
 
 // src/server-credentials.ts
+var LOCK_ABANDONED_MS = 10 * 6e4;
+var lockOwnerSchema = external_exports.object({
+  pid: external_exports.number().int().positive(),
+  at: external_exports.number().int().nonnegative()
+});
 var credentialSchema = external_exports.object({
   schemaVersion: external_exports.literal(1),
   serverUrl: external_exports.string().url(),
@@ -13254,8 +13259,13 @@ var ServerCredentialStore = class {
     this.path = join2(directory, "server-credentials.json");
   }
   /** Serialize the complete read/refresh/write transaction across processes.
-   * Never steal an old lock: a suspended owner may still consume a one-use token.
-   * After a crash, stop all instances before removing the orphaned lock.
+   *
+   * A lock left by a process that no longer exists can never be released by that process, and being killed
+   * mid-refresh is routine on a phone (the app is backgrounded or swept away) - the old rule then left the user
+   * with `SERVER_CREDENTIALS_BUSY` forever and told them to delete a file they cannot reach. So the lock now
+   * records its owner and a contender reclaims it when that owner is **gone**. Liveness is what is checked, not
+   * age: an owner that is merely suspended still protects its one-use refresh token, which is exactly what the
+   * old unconditional rule was guarding against.
    */
   async withRefreshLock(operation) {
     const lock = `${this.path}.refresh-lock`;
@@ -13263,10 +13273,11 @@ var ServerCredentialStore = class {
     const deadline = Date.now() + 15e3;
     for (; ; ) {
       try {
-        await mkdir(lock, { mode: 448 });
+        await claimRefreshLock(lock);
         break;
       } catch (error) {
         if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") throw error;
+        if (await reclaimAbandonedRefreshLock(lock)) continue;
         if (Date.now() >= deadline) throw new ServerCredentialsBusyError();
         await new Promise((resolve4) => setTimeout(resolve4, 50));
       }
@@ -13274,7 +13285,7 @@ var ServerCredentialStore = class {
     try {
       return await operation();
     } finally {
-      await rm2(lock, { recursive: true });
+      await rm2(lock, { recursive: true, force: true });
     }
   }
   async load(serverUrl, deviceId) {
@@ -13307,6 +13318,49 @@ var ServerCredentialsBusyError = class extends Error {
     super("Credential refresh is locked. Stop other instances; after a crash, stop all instances before removing server-credentials.json.refresh-lock and authorizing again.");
   }
 };
+async function claimRefreshLock(lock) {
+  await mkdir(lock, { mode: 448 });
+  await writeFile(join2(lock, "owner.json"), `${JSON.stringify({ pid: process.pid, at: Date.now() })}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+}
+async function reclaimAbandonedRefreshLock(lock) {
+  const owner = await readRefreshLockOwner(lock);
+  const abandoned = owner === void 0 ? await olderThan(lock, LOCK_ABANDONED_MS) : !processAlive(owner.pid);
+  if (!abandoned) return false;
+  const tomb = `${lock}.${process.pid}.${uuidV7()}.abandoned`;
+  try {
+    await rename2(lock, tomb);
+  } catch {
+    return false;
+  }
+  await rm2(tomb, { recursive: true, force: true });
+  return true;
+}
+async function readRefreshLockOwner(lock) {
+  try {
+    return lockOwnerSchema.parse(JSON.parse(await readFile(join2(lock, "owner.json"), "utf8")));
+  } catch {
+    return void 0;
+  }
+}
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !(error instanceof Error && "code" in error && error.code === "ESRCH");
+  }
+}
+async function olderThan(path, ageMs) {
+  try {
+    return Date.now() - (await stat2(path)).mtimeMs > ageMs;
+  } catch {
+    return false;
+  }
+}
 async function atomicWrite(path, contents) {
   const directory = dirname(path);
   await mkdir(directory, { recursive: true, mode: 448 });
@@ -13462,7 +13516,7 @@ function normalizeServerUrl(value) {
 }
 
 // src/version.ts
-var PLUGIN_VERSION = "0.5.2";
+var PLUGIN_VERSION = "0.5.3";
 
 // src/server-api.ts
 var ENABLED_QR_PROVIDERS = ["github"];
@@ -20291,8 +20345,12 @@ var TypertGatewaySwitch = class {
   installed = false;
   /** Defaults to reachable so a caller that never wires this keeps the old behaviour. */
   remoteAvailability = () => true;
-  constructor(gateway) {
+  /** Supplies the peer carrier calls speak for; see {@link ownerPeer}. */
+  peerFor;
+  peer;
+  constructor(gateway, options = {}) {
     this.runtime = gateway;
+    this.peerFor = options.peer;
     this.originalInvoke = gateway.invoke;
     this.localInvoke = this.originalInvoke.bind(gateway);
     this.originalStream = gateway.stream;
@@ -20300,18 +20358,42 @@ var TypertGatewaySwitch = class {
     this.originalDispatch = this.runtime.dispatchRpc;
     this.localDispatch = this.runtime.dispatchRpc?.bind(gateway);
     this.originalOpen = this.runtime.openWireStream;
-    this.localOpen = createLocalOpen(gateway, this.runtime);
+    this.localOpen = createLocalOpen(gateway, this.runtime, () => this.ownerPeer());
+  }
+  /**
+   * The peer a carrier call speaks for, created once and reused.
+   *
+   * dsh 0.2.1-rc.2 reads `peer.signal` on every carrier call and rejects one that arrives without a peer; a remote
+   * client runs with the Host owner's authority (decided 2026-10-19), which is the same principal dsh gives its own
+   * browser peer, so the plugin serves remote calls as the owner. Releases before rc.2 ignore the argument, and a
+   * profile without a `connection` service simply has no peer to offer.
+   */
+  ownerPeer() {
+    if (this.peer !== void 0) return this.peer;
+    this.peer = this.peerFor?.();
+    return this.peer;
+  }
+  /** Trailing argument the carrier wants when the caller did not supply one. */
+  peerArguments() {
+    const peer = this.ownerPeer();
+    return peer === void 0 ? [] : [peer];
   }
   /** Original local dispatcher, used by the Host bridge without switch recursion. */
   local() {
-    const dispatch = this.localDispatch ?? (async (endpoint, payload, signal) => {
+    const bare = this.localDispatch;
+    const dispatch = bare === void 0 ? (async (endpoint, payload, signal) => {
       try {
         const request = requestFromCarrier(endpoint, payload, signal);
         return { ok: true, value: await this.localInvoke(request) };
       } catch (error) {
         return { ok: false, error: this.failure(error) };
       }
-    });
+    }) : (endpoint, payload, signal, ...rest) => Promise.resolve(bare(
+      endpoint,
+      payload,
+      signal,
+      ...rest.length === 0 ? this.peerArguments() : rest
+    ));
     const open = this.localOpen ?? (async (endpoint, payload, signal) => {
       if (this.localStream === void 0) throw new Error("The local Harness Gateway does not support Remote streams.");
       return this.localStream(requestFromCarrier(endpoint, payload, signal));
@@ -20346,17 +20428,17 @@ var TypertGatewaySwitch = class {
       );
     }
     if (previousDispatch !== void 0) {
-      this.runtime.dispatchRpc = (endpoint, payload, signal) => forwards(endpoint) ? Promise.resolve(previousDispatch(endpoint, payload, signal)).catch((error) => {
+      this.runtime.dispatchRpc = (endpoint, payload, signal, ...rest) => forwards(endpoint) ? Promise.resolve(previousDispatch(endpoint, payload, signal, ...rest)).catch((error) => {
         console.warn("[dsh-remote] local call failed with no remote target selected", {
           endpoint,
           code: typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0,
           message: error instanceof Error ? error.message : String(error)
         });
         throw error;
-      }) : !this.routesToRemote(endpoint) ? this.localDispatch(endpoint, payload, signal) : this.withLocalFallback(
+      }) : !this.routesToRemote(endpoint) ? this.localDispatch(endpoint, payload, signal, ...rest) : this.withLocalFallback(
         endpoint,
         () => Promise.resolve(this.remoteTarget.dispatch(endpoint, payload, signal)),
-        () => this.localDispatch(endpoint, payload, signal)
+        () => this.localDispatch(endpoint, payload, signal, ...rest)
       ).then((result) => normalizeByteResult3(endpoint, result));
     }
     if (previousOpen !== void 0) {
@@ -20495,17 +20577,17 @@ function linkControl(signal) {
   else signal.addEventListener("abort", () => control.abort(signal.reason), { once: true });
   return control;
 }
-function createLocalOpen(gateway, runtime) {
+function createLocalOpen(gateway, runtime, peer = () => void 0) {
   const open = runtime.openWireStream;
   if (open !== void 0) {
-    return usesRc1Arity(open) ? (endpoint, payload, signal) => open.call(runtime, endpoint, payload, endedUplink(), void 0, signal, linkControl(signal)) : (endpoint, payload, signal) => open.call(runtime, endpoint, payload, signal);
+    return usesRc1Arity(open) ? (endpoint, payload, signal) => open.call(runtime, endpoint, payload, endedUplink(), peer(), signal, linkControl(signal)) : (endpoint, payload, signal) => open.call(runtime, endpoint, payload, signal);
   }
   const wire = gateway.wireStream;
   if (wire === void 0) return void 0;
   const wireOpen = wire.open;
   if (usesRc1Arity(wireOpen)) {
     const rc1 = wireOpen;
-    return (endpoint, payload, signal) => rc1.call(wire, endpoint, payload, endedUplink(), void 0, signal);
+    return (endpoint, payload, signal) => rc1.call(wire, endpoint, payload, endedUplink(), peer(), signal);
   }
   const legacy = wireOpen;
   return (endpoint, payload, signal) => legacy.call(wire, endpoint, payload, signal);
@@ -21673,7 +21755,7 @@ var QUICK_RECONNECT_RETRY_DELAY_MS = 5e3;
 var QUICK_RECONNECT_FORCE_RELAY = true;
 var BACKGROUND_RETRY_DELAYS_MS = [5e3, 1e4, 2e4, 3e4, 3e4, 3e4, 3e4];
 var ClientModeRuntime = class {
-  constructor(config, identities, server, apiProxy, typertGateway, logger, host, rtcFactoryProvider = loadNodeRtcFactory, targetStore) {
+  constructor(config, identities, server, apiProxy, typertGateway, logger, host, rtcFactoryProvider = loadNodeRtcFactory, targetStore, peer) {
     this.config = config;
     this.identities = identities;
     this.server = server;
@@ -21681,8 +21763,9 @@ var ClientModeRuntime = class {
     this.host = host;
     this.rtcFactoryProvider = rtcFactoryProvider;
     this.targetStore = targetStore;
+    this.peer = peer;
     this.proxySwitch = apiProxy === void 0 ? void 0 : new ApiProxySwitch(apiProxy);
-    this.gatewaySwitch = new TypertGatewaySwitch(typertGateway);
+    this.gatewaySwitch = new TypertGatewaySwitch(typertGateway, { peer: this.peer });
     this.gatewaySwitch.setRemoteAvailability(() => this.connected !== void 0);
   }
   preview;
@@ -30269,8 +30352,18 @@ async function activate(ctx, readConfig, entryId, tuiBinding) {
   const deviceDirectory = config.serverUrl === void 0 ? defaultIdentityDirectory : await ensureDeviceDirectory(defaultIdentityDirectory, config.serverUrl);
   const hostIdentities = new IdentityStore({ directory: deviceDirectory });
   const apiProxy = ctx.get("apiProxy");
+  const connectionService = ctx.get("connection", false);
+  let ownerPeerResolved = false;
+  let ownerPeer;
+  const peerFor = () => {
+    if (!ownerPeerResolved) {
+      ownerPeerResolved = true;
+      ownerPeer = connectionService?.createPeer?.({ principal: { kind: "owner" } });
+    }
+    return ownerPeer;
+  };
   const nativeTypertGateway = ctx.get("typertGateway");
-  const localTypertGateway = new TypertGatewaySwitch(nativeTypertGateway).local();
+  const localTypertGateway = new TypertGatewaySwitch(nativeTypertGateway, { peer: peerFor }).local();
   const subprocess = ctx.get("subprocess", false);
   const deepseekAccount = ctx.get("deepseekAccount", false);
   const deepseekSession = deepseekAccount === void 0 ? void 0 : {
@@ -30319,7 +30412,8 @@ async function activate(ctx, readConfig, entryId, tuiBinding) {
       hostControl,
       // The RTC factory keeps its default; the target store lives beside the plugin state.
       void 0,
-      new ClientTargetStore(defaultIdentityDirectory)
+      new ClientTargetStore(defaultIdentityDirectory),
+      peerFor
     );
   }
   const controlRuntime = connection === void 0 ? void 0 : new PluginControlRuntime(config, defaultIdentityDirectory, settingsBinding, clientRuntime, hostControl, deepseekSession);