@dev-anywhere/relay 0.4.79 → 0.4.81

package/dist/{chunk-L2KEGMDB.js → chunk-XJZ3HOPH.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") {
@@ -3578,8 +3617,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 +3635,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 +3821,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 +3840,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;
@@ -4153,4 +4273,4 @@ export {
   parseRelayChaosFromEnv,
   createRelayServer
 };
-//# sourceMappingURL=chunk-L2KEGMDB.js.map
+//# sourceMappingURL=chunk-XJZ3HOPH.js.map