mindwire 0.1.29 → 0.1.32

package/dist/computer/lifecycle.d.ts

@@ -12,12 +12,17 @@ export interface ComputerConfig {
     websocketPort: number;
     relay: RelayOptions;
 }
+export declare const CONTROLLER_PROTOCOL = 2;
 export interface ControllerState extends ProcessState {
+    protocol?: number;
+    cliVersion?: string;
     ready: boolean;
     phase?: string;
     error?: string;
+    errorCode?: string;
     recovering?: boolean;
     routes?: ComputerRoute[];
+    checkedAt?: number;
 }
 export declare const defaultStateDirectory: () => string;
 export declare const defaultComputerConfig: () => ComputerConfig;

package/dist/computer/relay-health.d.ts

@@ -0,0 +1,21 @@
+import type { LookupFunction } from "node:net";
+import type { ComputerRoute } from "../computer.js";
+import type { RelayOptions } from "./relay.js";
+export declare class RelayCheckError extends Error {
+    readonly code: "dns" | "timeout" | "proxy" | "connection" | "response";
+    constructor(code: "dns" | "timeout" | "proxy" | "connection" | "response", message: string, cause?: Error);
+}
+/** A resolver's negative cache says nothing about the helper's connection.
+ * Rotating a live tunnel for NXDOMAIN creates another hostname to cache and
+ * strands phones with the previous address. Process exits are handled separately. */
+export declare function relayNeedsRestart(error: unknown, failures: number, failedForMs: number): boolean;
+/** Check the actual WebSocket byte path, not just the helper's PID or its logs.
+ * The phone still authenticates and pins the SSH host before sending secrets. */
+export declare function checkRelay(route: ComputerRoute, options?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    lookup?: LookupFunction;
+}): Promise<void>;
+/** Don't rotate a quick-tunnel address during an ordinary internet outage.
+ * Let the provider reconnect with the same address until it is reachable again. */
+export declare function relayProviderReachable(options: RelayOptions, signal?: AbortSignal): Promise<boolean>;

package/dist/computer/relay-output.d.ts

@@ -0,0 +1,19 @@
+/** A provider must not inherit pipes whose reader dies during a controller
+ * upgrade. Use a private append-only file descriptor, consume startup output,
+ * then discard it. A successor can adopt the same file without touching the
+ * provider or its address. Raw provider output is never copied to our logs. */
+export declare class RelayOutput {
+    readonly file: string;
+    private readonly handle;
+    private position;
+    private timer?;
+    private pending;
+    private closing?;
+    private constructor();
+    static create(directory?: string): Promise<RelayOutput>;
+    static adopt(directory: string, file: string): Promise<RelayOutput | undefined>;
+    get fd(): number;
+    read(): Promise<Buffer>;
+    discard(): void;
+    close(): Promise<void>;
+}

package/dist/computer/relay.d.ts

@@ -11,13 +11,16 @@ export interface RelayHandle {
     route?: ComputerRoute;
     process?: ChildProcess;
     owner?: OwnedProcess;
+    outputFile?: string;
     close(): void | Promise<void>;
 }
+export declare function adoptRelay(owner: OwnedProcess, route: ComputerRoute | undefined, directory: string, outputFile?: string): Promise<RelayHandle>;
 export declare function websocketURL(value: string): string;
 /** Both providers forward encrypted SSH bytes to one loopback WebSocket bridge. */
 export declare function startRelay(options: RelayOptions, port: number, runtime?: {
     cacheDir?: string;
+    outputDirectory?: string;
     onProgress?: (message: string) => void | Promise<void>;
     signal?: AbortSignal;
-    onSpawn?: (owner: OwnedProcess) => Promise<void>;
+    onSpawn?: (owner: OwnedProcess, outputFile: string) => Promise<void>;
 }): Promise<RelayHandle>;

package/dist/computer.d.ts

@@ -40,7 +40,9 @@ export interface ComputerDevice {
 }
 /** Signature is a base64 Ed25519 proof over
  * `mindwire-computer-pairing-v1\n${pairingId}\n${id}\n${name}\n${publicKey}`.
- * With pairingVersion >= 2 an already approved key reconnects without a prompt. */
+ * With pairingVersion >= 2 an already approved key reconnects without a prompt.
+ * Version 3 requires a signature on every device POST /pair (including retries).
+ * Owner-facing pairing status omits the proof; GET /pair/{id} never returns a token. */
 export interface ComputerPairRequest {
     id: string;
     name: string;
@@ -74,7 +76,8 @@ export interface ComputerInfo {
     sshPort: number;
     websocketPort: number;
     portForwardingVersion?: number;
-    /** 2 supports signed reconnection and atomic replacement of lost device keys. */
+    /** 2 supports signed reconnection and atomic replacement of lost device keys.
+     * 3 requires signed pairing acknowledgements and expires/revokes pairing transports. */
     pairingVersion?: number;
 }
 export interface ComputerForwardRequest {