@dev-anywhere/relay 0.4.80 → 0.4.82

package/dist/{chunk-L2KEGMDB.js → chunk-5B2OTBDL.js}

@@ -617,6 +617,21 @@ var relayControlDefinitions = [
     url: z8.string().optional(),
     expiresAt: z8.number().int().nonnegative().optional()
   }),
+  control("remote_file_metadata_request", {
+    ...RequiredRequestIdShape,
+    sessionId: IdSchema,
+    path: z8.string().min(1)
+  }),
+  control("remote_file_metadata_response", {
+    ...RequiredRequestIdShape,
+    ...RequestErrorShape,
+    sessionId: IdSchema,
+    path: z8.string().optional(),
+    success: z8.boolean(),
+    mimeType: z8.string().optional(),
+    size: z8.number().int().nonnegative().optional(),
+    fileName: z8.string().optional()
+  }),
   control("remote_file_stream_request", {
     streamId: IdSchema,
     sessionId: IdSchema,
@@ -1768,6 +1783,10 @@ function handleProxyConnection(ws, registry, logger, chaos, remoteFileBridge) {
         remoteFileBridge?.handleProxyControl(proxyWs.proxyId, result.message);
         return;
       }
+      if (proxyWs.proxyId && result.message.type === "remote_file_metadata_response") {
+        remoteFileBridge?.handleProxyControl(proxyWs.proxyId, result.message);
+        return;
+      }
       if (proxyWs.proxyId && result.message.type === "remote_file_stream_complete") {
         remoteFileBridge?.handleProxyControl(proxyWs.proxyId, result.message);
         return;
@@ -2773,24 +2792,44 @@ function handleClientConnection(ws, registry, logger, chaos, voiceConfigStore, v
           );
           return;
         }
-        const { url, expiresAt } = remoteFileBridge.createUrl({
+        void remoteFileBridge.createUrl({
           clientId: clientWs.clientId,
           proxyId: targetProxyId,
           sessionId: msg.sessionId,
           path: msg.path,
           disposition: msg.disposition
+        }).then((result2) => {
+          if (clientWs.readyState !== WebSocket7.OPEN) return;
+          if (!result2.success) {
+            sendRemoteFileUrlFailure(
+              clientWs,
+              msg.requestId,
+              msg.sessionId,
+              result2.error,
+              result2.errorCode
+            );
+            return;
+          }
+          clientWs.send(
+            serializeControl({
+              type: "remote_file_url_response",
+              requestId: msg.requestId,
+              sessionId: msg.sessionId,
+              path: result2.path,
+              success: true,
+              url: result2.url,
+              expiresAt: result2.expiresAt
+            })
+          );
+        }).catch((err) => {
+          if (clientWs.readyState !== WebSocket7.OPEN) return;
+          sendRemoteFileUrlFailure(
+            clientWs,
+            msg.requestId,
+            msg.sessionId,
+            err instanceof Error ? err.message : String(err)
+          );
         });
-        clientWs.send(
-          serializeControl({
-            type: "remote_file_url_response",
-            requestId: msg.requestId,
-            sessionId: msg.sessionId,
-            path: msg.path,
-            success: true,
-            url,
-            expiresAt
-          })
-        );
         return;
       }
       if (msg.type === "remote_file_upload_url_request") {
@@ -2993,12 +3032,20 @@ function handleClientConnection(ws, registry, logger, chaos, voiceConfigStore, v
       closeRejectedClientProtocol(clientWs);
     }
   });
-  clientWs.on("close", () => {
+  clientWs.on("close", (code, reason) => {
     registry.removeClientWs(clientWs);
     if (clientWs.clientId) {
       registry.unbindClientById(clientWs.clientId);
     }
-    logger.info({ clientId: clientWs.clientId }, "Client disconnected");
+    logger.info(
+      {
+        clientId: clientWs.clientId,
+        boundProxyId: clientWs.boundProxyId,
+        code,
+        reason: reason.toString() || void 0
+      },
+      "Client disconnected"
+    );
   });
   clientWs.on("error", (err) => {
     logger.error({ err }, "Client WebSocket error");
@@ -3009,7 +3056,7 @@ function handleClientConnection(ws, registry, logger, chaos, voiceConfigStore, v
 function markAlive(ws) {
   ws.isAlive = true;
 }
-function setupHeartbeat(wss, interval = 3e4) {
+function setupHeartbeat(wss, interval = 3e4, options = {}) {
   wss.on("connection", (ws) => {
     markAlive(ws);
     ws.on("pong", () => {
@@ -3020,6 +3067,13 @@ function setupHeartbeat(wss, interval = 3e4) {
     for (const ws of wss.clients) {
       const sock = ws;
       if (sock.isAlive === false) {
+        options.logger?.warn(
+          {
+            peerType: options.peerType,
+            ...options.describePeer?.(ws) ?? {}
+          },
+          "WebSocket heartbeat timeout"
+        );
         sock.terminate();
         continue;
       }
@@ -3578,8 +3632,10 @@ function encodeContentDisposition(disposition, fileName) {
 function statusForErrorCode(errorCode) {
   switch (errorCode) {
     case ControlErrorCode.SESSION_NOT_FOUND:
+    case ControlErrorCode.PATH_NOT_FOUND:
       return 404;
     case ControlErrorCode.INVALID_PATH:
+    case ControlErrorCode.PATH_NOT_DIRECTORY:
       return 400;
     case ControlErrorCode.PATH_ACCESS_DENIED:
       return 403;
@@ -3594,22 +3650,54 @@ var RemoteFileBridge = class {
   deps;
   tokens = /* @__PURE__ */ new Map();
   uploadTokens = /* @__PURE__ */ new Map();
+  pendingUrlMetadata = /* @__PURE__ */ new Map();
   pendingStreams = /* @__PURE__ */ new Map();
   pendingUploads = /* @__PURE__ */ new Map();
   createUrl(input) {
     this.cleanupExpiredTokens();
-    const token = nanoid3(32);
-    const expiresAt = Date.now() + REMOTE_FILE_TOKEN_TTL_MS;
-    this.tokens.set(token, {
-      token,
-      clientId: input.clientId,
-      proxyId: input.proxyId,
-      sessionId: input.sessionId,
-      path: input.path,
-      disposition: input.disposition,
-      expiresAt
+    const proxyWs = this.deps.registry.getProxy(input.proxyId);
+    if (!proxyWs || proxyWs.readyState !== WebSocket11.OPEN) {
+      return Promise.resolve({
+        success: false,
+        path: input.path,
+        error: "\u5F53\u524D\u672A\u8FDE\u63A5\u5F00\u53D1\u673A",
+        errorCode: ControlErrorCode.PROXY_OFFLINE
+      });
+    }
+    const requestId = nanoid3(21);
+    return new Promise((resolve2) => {
+      const timer = setTimeout(() => {
+        this.pendingUrlMetadata.delete(requestId);
+        resolve2({
+          success: false,
+          path: input.path,
+          error: "\u8BFB\u53D6\u6587\u4EF6\u5143\u6570\u636E\u8D85\u65F6",
+          errorCode: ControlErrorCode.UNKNOWN
+        });
+      }, REMOTE_FILE_METADATA_TIMEOUT_MS);
+      this.pendingUrlMetadata.set(requestId, {
+        requestId,
+        clientId: input.clientId,
+        proxyId: input.proxyId,
+        sessionId: input.sessionId,
+        path: input.path,
+        disposition: input.disposition,
+        timer,
+        resolve: resolve2
+      });
+      proxyWs.send(
+        serializeControl({
+          type: "remote_file_metadata_request",
+          requestId,
+          sessionId: input.sessionId,
+          path: input.path
+        })
+      );
+      this.deps.logger.info(
+        { requestId, proxyId: input.proxyId, sessionId: input.sessionId, path: input.path },
+        "Remote file URL metadata requested"
+      );
     });
-    return { url: `/api/remote-files/${token}`, expiresAt };
   }
   createUploadUrl(input) {
     this.cleanupExpiredTokens();
@@ -3748,6 +3836,9 @@ var RemoteFileBridge = class {
     if (msg.type === "remote_file_upload_stream_response") {
       return this.handleUploadResponse(proxyId, msg);
     }
+    if (msg.type === "remote_file_metadata_response") {
+      return this.handleUrlMetadataResponse(proxyId, msg);
+    }
     const pending = this.pendingStreams.get(msg.streamId);
     if (!pending) return true;
     if (pending.token.proxyId !== proxyId) {
@@ -3764,6 +3855,50 @@ var RemoteFileBridge = class {
     this.handleStreamComplete(pending, msg);
     return true;
   }
+  issueUrlToken(input) {
+    const token = nanoid3(32);
+    const expiresAt = Date.now() + REMOTE_FILE_TOKEN_TTL_MS;
+    this.tokens.set(token, {
+      token,
+      clientId: input.clientId,
+      proxyId: input.proxyId,
+      sessionId: input.sessionId,
+      path: input.path,
+      disposition: input.disposition,
+      expiresAt
+    });
+    return { url: `/api/remote-files/${token}`, expiresAt };
+  }
+  handleUrlMetadataResponse(proxyId, msg) {
+    const pending = this.pendingUrlMetadata.get(msg.requestId);
+    if (!pending) return true;
+    if (pending.proxyId !== proxyId) {
+      this.deps.logger.warn(
+        { requestId: msg.requestId, expectedProxyId: pending.proxyId, proxyId },
+        "Remote file metadata ignored: proxy mismatch"
+      );
+      return true;
+    }
+    this.pendingUrlMetadata.delete(msg.requestId);
+    clearTimeout(pending.timer);
+    if (!msg.success) {
+      pending.resolve({
+        success: false,
+        path: pending.path,
+        error: msg.error ?? "\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25",
+        ...msg.errorCode ? { errorCode: msg.errorCode } : {}
+      });
+      return true;
+    }
+    const { url, expiresAt } = this.issueUrlToken(pending);
+    pending.resolve({
+      success: true,
+      path: pending.path,
+      url,
+      expiresAt
+    });
+    return true;
+  }
   handleProxyBinary(proxyId, data) {
     const decoded = decodeFileStreamFrame(data);
     if (!decoded) return false;
@@ -4091,10 +4226,27 @@ function createRelayServer(options) {
   voiceTtsWss.on("connection", (ws) => {
     handleVoiceTtsConnection(ws, voiceConfigStore, logger, voiceProviders);
   });
-  const proxyHeartbeat = setupHeartbeat(proxyWss, heartbeatInterval);
-  const clientHeartbeat = setupHeartbeat(clientWss, heartbeatInterval);
-  const voiceAsrHeartbeat = setupHeartbeat(voiceAsrWss, heartbeatInterval);
-  const voiceTtsHeartbeat = setupHeartbeat(voiceTtsWss, heartbeatInterval);
+  const proxyHeartbeat = setupHeartbeat(proxyWss, heartbeatInterval, {
+    logger,
+    peerType: "proxy",
+    describePeer: (ws) => ({ proxyId: ws.proxyId })
+  });
+  const clientHeartbeat = setupHeartbeat(clientWss, heartbeatInterval, {
+    logger,
+    peerType: "client",
+    describePeer: (ws) => ({
+      clientId: ws.clientId,
+      boundProxyId: ws.boundProxyId
+    })
+  });
+  const voiceAsrHeartbeat = setupHeartbeat(voiceAsrWss, heartbeatInterval, {
+    logger,
+    peerType: "voice-asr"
+  });
+  const voiceTtsHeartbeat = setupHeartbeat(voiceTtsWss, heartbeatInterval, {
+    logger,
+    peerType: "voice-tts"
+  });
   async function close() {
     clearInterval(proxyHeartbeat);
     clearInterval(clientHeartbeat);
@@ -4153,4 +4305,4 @@ export {
   parseRelayChaosFromEnv,
   createRelayServer
 };
-//# sourceMappingURL=chunk-L2KEGMDB.js.map
+//# sourceMappingURL=chunk-5B2OTBDL.js.map