@milaboratories/pl-drivers 1.11.19 → 1.11.21

package/src/clients/logs.ts

@@ -1,22 +1,35 @@
-import { StreamingClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.client';
 import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
 import type { MiLogger } from '@milaboratories/ts-helpers';
 import { notEmpty } from '@milaboratories/ts-helpers';
 import type { Dispatcher } from 'undici';
-import type { GrpcClientProvider, GrpcClientProviderFactory } from '@milaboratories/pl-client';
-import { addRTypeToMetadata } from '@milaboratories/pl-client';
-import type { StreamingAPI_Response } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol';
+import type { WireClientProvider, WireClientProviderFactory } from '@milaboratories/pl-client';
+import { addRTypeToMetadata, createRTypeRoutingHeader, RestAPI } from '@milaboratories/pl-client';
+import type { StreamingAPI_Response } from '../proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol';
+import { StreamingClient } from '../proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol.client';
+import type { StreamingApiPaths, StreamingRestClientType } from '../proto-rest';
 import type { ResourceInfo } from '@milaboratories/pl-tree';
 
 export class ClientLogs {
-  public readonly grpcClient: GrpcClientProvider<StreamingClient>;
+  public readonly wire: WireClientProvider<StreamingRestClientType | StreamingClient>;
 
   constructor(
-    grpcClientProviderFactory: GrpcClientProviderFactory,
+    wireClientProviderFactory: WireClientProviderFactory,
     public readonly httpClient: Dispatcher,
     public readonly logger: MiLogger,
   ) {
-    this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new StreamingClient(transport));
+    this.wire = wireClientProviderFactory.createWireClientProvider(
+      (wire) => {
+        if (wire.type === 'grpc') {
+          return new StreamingClient(wire.Transport);
+        }
+
+        return RestAPI.createClient<StreamingApiPaths>({
+          hostAndPort: wire.Config.hostAndPort,
+          ssl: wire.Config.ssl,
+          dispatcher: wire.Dispatcher,
+          middlewares: wire.Middlewares,
+        });
+      });
   }
 
   close() {}
@@ -31,17 +44,32 @@ export class ClientLogs {
     searchStr?: string,
     options?: RpcOptions,
   ): Promise<StreamingAPI_Response> {
-    return (
-      await this.grpcClient.get().lastLines(
-        {
-          resourceId: rId,
-          lineCount: lineCount,
-          offset: offsetBytes,
-          search: searchStr,
-        },
-        addRTypeToMetadata(rType, options),
-      )
-    ).response;
+    const client = this.wire.get();
+    if (client instanceof StreamingClient) {
+      return (
+        await client.lastLines(
+          { resourceId: rId, lineCount: lineCount, offset: offsetBytes, search: searchStr },
+          addRTypeToMetadata(rType, options),
+        )
+      ).response;
+    }
+
+    const resp = (await client.POST('/v1/last-lines', {
+      body: {
+        resourceId: rId.toString(),
+        lineCount: lineCount,
+        offset: offsetBytes.toString(),
+        search: searchStr ?? '',
+        searchRe: '',
+      },
+      headers: { ...createRTypeRoutingHeader(rType) },
+    })).data!;
+
+    return {
+      data: new Uint8Array(Buffer.from(resp.data)),
+      size: BigInt(resp.size),
+      newOffset: BigInt(resp.newOffset),
+    };
   }
 
   /** Reads the file forward and returns the text,
@@ -54,8 +82,10 @@ export class ClientLogs {
     searchStr?: string,
     options?: RpcOptions,
   ): Promise<StreamingAPI_Response> {
-    return (
-      await this.grpcClient.get().readText(
+    const client = this.wire.get();
+
+    if (client instanceof StreamingClient) {
+      return (await client.readText(
         {
           resourceId: notEmpty(rId),
           readLimit: BigInt(lineCount),
@@ -64,6 +94,24 @@ export class ClientLogs {
         },
         addRTypeToMetadata(rType, options),
       )
-    ).response;
+      ).response;
+    }
+
+    const resp = (await client.POST('/v1/read/text', {
+      body: {
+        resourceId: rId.toString(),
+        readLimit: lineCount.toString(),
+        offset: offsetBytes.toString(),
+        search: searchStr ?? '',
+        searchRe: '',
+      },
+      headers: { ...createRTypeRoutingHeader(rType) },
+    })).data!;
+
+    return {
+      data: new Uint8Array(Buffer.from(resp.data)),
+      size: BigInt(resp.size),
+      newOffset: BigInt(resp.newOffset),
+    };
   }
 }

package/src/clients/ls_api.ts

@@ -1,19 +1,35 @@
 import type { MiLogger } from '@milaboratories/ts-helpers';
-import type { LsAPI_List_Response } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/lsapi/protocol';
-import { LSClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/lsapi/protocol.client';
 import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
-import type { GrpcClientProvider, GrpcClientProviderFactory } from '@milaboratories/pl-client';
-import { addRTypeToMetadata } from '@milaboratories/pl-client';
+import type { WireClientProvider, WireClientProviderFactory } from '@milaboratories/pl-client';
+import { RestAPI } from '@milaboratories/pl-client';
+import { addRTypeToMetadata, createRTypeRoutingHeader } from '@milaboratories/pl-client';
+import type { LsAPI_List_Response, LsAPI_ListItem } from '../proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/lsapi/protocol';
+import { LSClient } from '../proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/lsapi/protocol.client';
+import type { LsApiPaths, LsRestClientType } from '../proto-rest';
+
 import type { ResourceInfo } from '@milaboratories/pl-tree';
 
 export class ClientLs {
-  private readonly grpcClient: GrpcClientProvider<LSClient>;
+  private readonly wire: WireClientProvider<LsRestClientType | LSClient>;
 
   constructor(
-    grpcClientProviderFactory: GrpcClientProviderFactory,
+    wireClientProviderFactory: WireClientProviderFactory,
     private readonly logger: MiLogger,
   ) {
-    this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new LSClient(transport));
+    this.wire = wireClientProviderFactory.createWireClientProvider(
+      (wire) => {
+        if (wire.type === 'grpc') {
+          return new LSClient(wire.Transport);
+        }
+
+        return RestAPI.createClient<LsApiPaths>({
+          hostAndPort: wire.Config.hostAndPort,
+          ssl: wire.Config.ssl,
+          dispatcher: wire.Dispatcher,
+          middlewares: wire.Middlewares,
+        });
+      },
+    );
   }
 
   close() {}
@@ -23,12 +39,40 @@ export class ClientLs {
     path: string,
     options?: RpcOptions,
   ): Promise<LsAPI_List_Response> {
-    return await this.grpcClient.get().list(
-      {
-        resourceId: rInfo.id,
-        location: path,
-      },
-      addRTypeToMetadata(rInfo.type, options),
-    ).response;
+    const client = this.wire.get();
+
+    if (client instanceof LSClient) {
+      return await client.list(
+        {
+          resourceId: rInfo.id,
+          location: path,
+        },
+        addRTypeToMetadata(rInfo.type, options),
+      ).response;
+    } else {
+      const resp = (await client.POST('/v1/list', {
+        body: {
+          resourceId: rInfo.id.toString(),
+          location: path,
+        },
+        headers: { ...createRTypeRoutingHeader(rInfo.type) },
+      })).data!;
+
+      const items: LsAPI_ListItem[] = resp.items.map((item) => ({
+        name: item.name,
+        size: BigInt(item.size),
+        isDir: item.isDir,
+        fullName: item.fullName,
+        directory: item.directory,
+        // TODO: check we get value in a correct way here
+        lastModified: { seconds: BigInt(item.lastModified), nanos: 0 },
+        version: item.version,
+      }));
+
+      return {
+        items,
+        delimiter: resp.delimiter,
+      };
+    }
   }
 }

package/src/clients/progress.ts

@@ -1,11 +1,12 @@
-import { ProgressClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/progressapi/protocol.client';
 import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
-import { Duration } from '../proto/google/protobuf/duration';
-import type { GrpcClientProvider, GrpcClientProviderFactory, PlClient } from '@milaboratories/pl-client';
-import { addRTypeToMetadata } from '@milaboratories/pl-client';
+import type { WireClientProvider, WireClientProviderFactory, PlClient } from '@milaboratories/pl-client';
+import { addRTypeToMetadata, createRTypeRoutingHeader, RestAPI } from '@milaboratories/pl-client';
 import type { MiLogger } from '@milaboratories/ts-helpers';
 import { notEmpty } from '@milaboratories/ts-helpers';
 import type { Dispatcher } from 'undici';
+import { ProgressClient } from '../proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/progressapi/protocol.client';
+import type { ProgressAPI_Report } from '../proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/progressapi/protocol';
+import type { ProgressApiPaths, ProgressRestClientType } from '../proto-rest';
 import type { ResourceInfo } from '@milaboratories/pl-tree';
 
 export type ProgressStatus = {
@@ -20,27 +21,55 @@ export type ProgressStatus = {
 // When blobs are transfered, one can got a status of transfering
 // using this API.
 export class ClientProgress {
-  public readonly grpcClient: GrpcClientProvider<ProgressClient>;
+  public readonly wire: WireClientProvider<ProgressRestClientType | ProgressClient>;
 
   constructor(
-    grpcClientProviderFactory: GrpcClientProviderFactory,
+    wireClientProviderFactory: WireClientProviderFactory,
     _: Dispatcher,
     public readonly client: PlClient,
     public readonly logger: MiLogger,
   ) {
-    this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new ProgressClient(transport));
+    this.wire = wireClientProviderFactory.createWireClientProvider(
+      (wire) => {
+        if (wire.type === 'grpc') {
+          return new ProgressClient(wire.Transport);
+        }
+
+        return RestAPI.createClient<ProgressApiPaths>({
+          hostAndPort: wire.Config.hostAndPort,
+          ssl: wire.Config.ssl,
+          dispatcher: wire.Dispatcher,
+          middlewares: wire.Middlewares,
+        });
+      },
+    );
   }
 
   close() {}
 
   /** getStatus gets a progress status by given rId and rType. */
   async getStatus({ id, type }: ResourceInfo, options?: RpcOptions): Promise<ProgressStatus> {
-    const status = await this.grpcClient.get().getStatus(
-      { resourceId: id },
-      addRTypeToMetadata(type, options),
-    );
+    const client = this.wire.get();
 
-    const report = notEmpty(status.response.report);
+    let report: ProgressAPI_Report;
+    if (client instanceof ProgressClient) {
+      report = notEmpty((await client.getStatus(
+        { resourceId: id },
+        addRTypeToMetadata(type, options),
+      ).response).report);
+    } else {
+      const resp = (await client.POST('/v1/get-progress', {
+        body: { resourceId: id.toString() },
+        headers: { ...createRTypeRoutingHeader(type) },
+      })).data!.report;
+      report = {
+        done: resp.done,
+        progress: resp.progress,
+        bytesProcessed: BigInt(resp.bytesProcessed),
+        bytesTotal: BigInt(resp.bytesTotal),
+        name: resp.name,
+      };
+    }
 
     return {
       done: report.done,
@@ -49,36 +78,4 @@ export class ClientProgress {
       bytesTotal: String(report.bytesTotal),
     };
   }
-
-  // realtimeStatus returns a async generator that takes statuses from
-  // GRPC stream every updateIntervalMs milliseconds.
-  async *realtimeStatus(
-    { id, type }: ResourceInfo,
-    updateIntervalMs: number = 100,
-    options?: RpcOptions,
-  ) {
-    options = addRTypeToMetadata(type, options);
-
-    const secs = Math.floor(updateIntervalMs / 1000);
-    const nanos = (updateIntervalMs - secs * 1000) * 1000000;
-    const updateInterval = Duration.create({
-      seconds: BigInt(secs),
-      nanos: nanos,
-    });
-
-    try {
-      const { responses } = this.grpcClient.get().realtimeStatus(
-        {
-          resourceId: id,
-          updateInterval: updateInterval,
-        },
-        options,
-      );
-
-      yield * responses;
-    } catch (e) {
-      this.logger.warn('Failed to get realtime status' + String(e));
-      throw e;
-    }
-  }
 }

package/src/clients/upload.ts

@@ -1,13 +1,14 @@
-import type { GrpcClientProvider, GrpcClientProviderFactory, PlClient, ResourceId, ResourceType } from '@milaboratories/pl-client';
-import { addRTypeToMetadata } from '@milaboratories/pl-client';
+import type { WireClientProvider, WireClientProviderFactory, PlClient } from '@milaboratories/pl-client';
+import { addRTypeToMetadata, createRTypeRoutingHeader, RestAPI } from '@milaboratories/pl-client';
 import type { ResourceInfo } from '@milaboratories/pl-tree';
 import type { MiLogger } from '@milaboratories/ts-helpers';
 import type { RpcOptions } from '@protobuf-ts/runtime-rpc';
 import * as fs from 'node:fs/promises';
 import type { Dispatcher } from 'undici';
 import { request } from 'undici';
-import { uploadapi_ChecksumAlgorithm, type uploadapi_GetPartURL_Response } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol';
-import { UploadClient } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol.client';
+import { UploadAPI_ChecksumAlgorithm, type UploadAPI_GetPartURL_Response } from '../proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol';
+import { UploadClient } from '../proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/uploadapi/protocol.client';
+import type { UploadApiPaths, UploadRestClientType } from '../proto-rest';
 import { crc32c } from './crc32c';
 
 import type { IncomingHttpHeaders } from 'undici/types/header';
@@ -37,15 +38,28 @@ export class BadRequestError extends Error {
  * The user should pass here a concrete BlobUpload/<storageId> resource,
  * it can be got from handle field of BlobUpload. */
 export class ClientUpload {
-  private readonly grpcClient: GrpcClientProvider<UploadClient>;
+  private readonly wire: WireClientProvider<UploadRestClientType | UploadClient>;
 
   constructor(
-    grpcClientProviderFactory: GrpcClientProviderFactory,
+    wireClientProviderFactory: WireClientProviderFactory,
     public readonly httpClient: Dispatcher,
     _: PlClient,
     public readonly logger: MiLogger,
   ) {
-    this.grpcClient = grpcClientProviderFactory.createGrpcClientProvider((transport) => new UploadClient(transport));
+    this.wire = wireClientProviderFactory.createWireClientProvider(
+      (wire) => {
+        if (wire.type === 'grpc') {
+          return new UploadClient(wire.Transport);
+        }
+
+        return RestAPI.createClient<UploadApiPaths>({
+          hostAndPort: wire.Config.hostAndPort,
+          ssl: wire.Config.ssl,
+          dispatcher: wire.Dispatcher,
+          middlewares: wire.Middlewares,
+        });
+      },
+    );
   }
 
   close() {}
@@ -56,13 +70,33 @@ export class ClientUpload {
   ): Promise<{
       overall: bigint;
       toUpload: bigint[];
-      checksumAlgorithm: uploadapi_ChecksumAlgorithm;
+      checksumAlgorithm: UploadAPI_ChecksumAlgorithm;
       checksumHeader: string;
     }> {
-    const init = await this.grpcInit(id, type, options);
+    const client = this.wire.get();
+
+    if (client instanceof UploadClient) {
+      const init = (await client.init({ resourceId: id }, addRTypeToMetadata(type, options)))
+        .response;
+
+      return {
+        overall: init.partsCount,
+        toUpload: this.partsToUpload(init.partsCount, init.uploadedParts),
+        checksumAlgorithm: init.checksumAlgorithm,
+        checksumHeader: init.checksumHeader,
+      };
+    }
+
+    const init = (await client.POST('/v1/upload/init', {
+      body: {
+        resourceId: id.toString(),
+      },
+      headers: { ...createRTypeRoutingHeader(type) },
+    })).data!;
+
     return {
-      overall: init.partsCount,
-      toUpload: this.partsToUpload(init.partsCount, init.uploadedParts),
+      overall: BigInt(init.partsCount),
+      toUpload: this.partsToUpload(BigInt(init.partsCount), init.uploadedParts.map(BigInt)),
       checksumAlgorithm: init.checksumAlgorithm,
       checksumHeader: init.checksumHeader,
     };
@@ -73,22 +107,50 @@ export class ClientUpload {
     path: string,
     expectedMTimeUnix: bigint,
     partNumber: bigint,
-    checksumAlgorithm: uploadapi_ChecksumAlgorithm,
+    checksumAlgorithm: UploadAPI_ChecksumAlgorithm,
     checksumHeader: string,
     options?: RpcOptions,
   ) {
-    const info = await this.grpcGetPartUrl(
-      { id, type },
-      partNumber,
-      0n, // we update progress as a separate call later.
-      options,
-    );
+    const client = this.wire.get();
+
+    let info: UploadAPI_GetPartURL_Response;
+    if (client instanceof UploadClient) {
+      // partChecksum isn't used for now but protoc requires it to be set
+      info = (await client.getPartURL(
+        {
+          resourceId: id,
+          partNumber,
+          uploadedPartSize: 0n,
+          isInternalUse: false,
+          partChecksum: '',
+        },
+        addRTypeToMetadata(type, options),
+      )).response;
+    } else {
+      const resp = (await client.POST('/v1/upload/get-part-url', {
+        body: {
+          resourceId: id.toString(),
+          partNumber: partNumber.toString(),
+          uploadedPartSize: '0',
+          isInternalUse: false,
+          partChecksum: '',
+        },
+        headers: { ...createRTypeRoutingHeader(type) },
+      })).data!;
+      info = {
+        uploadUrl: resp.uploadUrl,
+        method: resp.method,
+        headers: resp.headers,
+        chunkStart: BigInt(resp.chunkStart),
+        chunkEnd: BigInt(resp.chunkEnd),
+      };
+    }
 
     const chunk = await readFileChunk(path, info.chunkStart, info.chunkEnd);
     await checkExpectedMTime(path, expectedMTimeUnix);
 
     const crc32cChecksum = calculateCrc32cChecksum(chunk);
-    if (checksumAlgorithm === uploadapi_ChecksumAlgorithm.CRC32C) {
+    if (checksumAlgorithm === UploadAPI_ChecksumAlgorithm.CRC32C) {
       info.headers.push({ name: checksumHeader, value: crc32cChecksum });
     }
 
@@ -136,11 +198,22 @@ export class ClientUpload {
       throw new Error(`partUpload: error ${JSON.stringify(e)} happened while trying to do part upload to the url ${info.uploadUrl}, headers: ${JSON.stringify(info.headers)}`);
     }
 
-    await this.grpcUpdateProgress({ id, type }, BigInt(info.chunkEnd - info.chunkStart), options);
+    await this.updateProgress({ id, type }, BigInt(info.chunkEnd - info.chunkStart), options);
   }
 
   public async finalize(info: ResourceInfo, options?: RpcOptions) {
-    return await this.grpcFinalize(info, options);
+    const client = this.wire.get();
+
+    if (client instanceof UploadClient) {
+      await client.finalize({ resourceId: info.id }, addRTypeToMetadata(info.type, options));
+    } else {
+      await client.POST('/v1/upload/finalize', {
+        body: {
+          resourceId: info.id.toString(),
+        },
+        headers: { ...createRTypeRoutingHeader(info.type) },
+      });
+    }
   }
 
   /** Calculates parts that need to be uploaded from the parts that were
@@ -156,41 +229,32 @@ export class ClientUpload {
     return toUpload;
   }
 
-  private async grpcInit(id: ResourceId, type: ResourceType, options?: RpcOptions) {
-    return await this.grpcClient.get().init({ resourceId: id }, addRTypeToMetadata(type, options))
-      .response;
-  }
-
-  private async grpcGetPartUrl(
-    { id, type }: ResourceInfo,
-    partNumber: bigint,
-    uploadedPartSize: bigint,
-    options?: RpcOptions,
-  ) {
-    // partChecksum isn't used for now but protoc requires it to be set
-    return await this.grpcClient.get().getPartURL(
-      { resourceId: id, partNumber, uploadedPartSize, isInternalUse: false, partChecksum: '' },
-      addRTypeToMetadata(type, options),
-    ).response;
-  }
-
-  private async grpcUpdateProgress(
+  private async updateProgress(
     { id, type }: ResourceInfo,
     bytesProcessed: bigint,
     options?: RpcOptions,
-  ) {
-    await this.grpcClient.get().updateProgress(
-      {
-        resourceId: id,
-        bytesProcessed,
-      },
-      addRTypeToMetadata(type, options),
-    ).response;
-  }
+  ): Promise<void> {
+    const client = this.wire.get();
+
+    if (client instanceof UploadClient) {
+      await client.updateProgress(
+        {
+          resourceId: id,
+          bytesProcessed,
+        },
+        addRTypeToMetadata(type, options),
+      ).response;
+      return;
+    }
 
-  private async grpcFinalize({ id, type }: ResourceInfo, options?: RpcOptions) {
-    return await this.grpcClient.get().finalize({ resourceId: id }, addRTypeToMetadata(type, options))
-      .response;
+    await client.POST('/v1/upload/update-progress', {
+      body: {
+        resourceId: id.toString(),
+        bytesProcessed: bytesProcessed.toString(),
+      },
+      headers: { ...createRTypeRoutingHeader(type) },
+    });
+    return;
   }
 }
 
@@ -243,7 +307,7 @@ function checkStatusCodeOk(
   statusCode: number,
   body: string,
   headers: IncomingHttpHeaders,
-  info: uploadapi_GetPartURL_Response,
+  info: UploadAPI_GetPartURL_Response,
 ) {
   if (statusCode == 400) {
     throw new BadRequestError(`response is not ok, status code: ${statusCode},`

package/src/drivers/download_blob/download_blob.ts

@@ -63,7 +63,7 @@ import { blobKey, pathToKey } from './blob_key';
 import { DownloadBlobTask, nonRecoverableError } from './download_blob_task';
 import { FilesCache } from '../helpers/files_cache';
 import { SparseCache, SparseCacheFsFile, SparseCacheFsRanges } from './sparse_cache/cache';
-import { isOffByOneError } from '../../helpers/download';
+import { isOffByOneError } from '../../helpers/download_errors';
 
 export type DownloadDriverOps = {
   /**

package/src/drivers/download_blob/download_blob_task.ts

@@ -18,7 +18,7 @@ import * as path from 'node:path';
 import { Writable } from 'node:stream';
 import type { ClientDownload } from '../../clients/download';
 import { UnknownStorageError, WrongLocalFileUrl } from '../../clients/download';
-import { NetworkError400 } from '../../helpers/download';
+import { isDownloadNetworkError400 } from '../../helpers/download_errors';
 import { resourceIdToString, stringifyWithResourceId } from '@milaboratories/pl-client';
 
 /** Downloads a blob and holds callers and watchers for the blob. */
@@ -155,7 +155,7 @@ export class DownloadBlobTask {
 export function nonRecoverableError(e: any) {
   return (
     e instanceof DownloadAborted
-    || e instanceof NetworkError400
+    || isDownloadNetworkError400(e)
     || e instanceof UnknownStorageError
     || e instanceof WrongLocalFileUrl
     // file that we downloads from was moved or deleted.

package/src/drivers/download_blob_url/task.ts

@@ -4,7 +4,7 @@ import * as tar from 'tar-fs';
 import path from 'path';
 import fs from 'fs';
 import * as fsp from 'fs/promises';
-import { NetworkError400 } from '../../helpers/download';
+import { isDownloadNetworkError400 } from '../../helpers/download_errors';
 import type { Watcher } from '@milaboratories/computable';
 import { ChangeSource } from '@milaboratories/computable';
 import type { MiLogger, Signer } from '@milaboratories/ts-helpers';
@@ -224,7 +224,7 @@ class URLAborted extends Error {
 export function nonRecoverableError(e: any) {
   return (
     e instanceof URLAborted
-    || e instanceof NetworkError400
+    || isDownloadNetworkError400(e)
     || e instanceof UnknownStorageError
     || e instanceof WrongLocalFileUrl
     // file that we downloads from was moved or deleted.

package/src/drivers/download_url/task.ts

@@ -17,7 +17,7 @@ import { Transform, Writable } from 'node:stream';
 import * as zlib from 'node:zlib';
 import * as tar from 'tar-fs';
 import type { RemoteFileDownloader } from '../../helpers/download';
-import { NetworkError400 } from '../../helpers/download';
+import { isDownloadNetworkError400 } from '../../helpers/download_errors';
 import type { UrlResult } from './driver';
 import { newBlockUIURL } from '../urls/url';
 
@@ -59,7 +59,7 @@ export class DownloadByUrlTask {
       this.setDone(size);
       this.change.markChanged(`download of ${this.url} finished`);
     } catch (e: unknown) {
-      if (e instanceof URLAborted || e instanceof NetworkError400) {
+      if (e instanceof URLAborted || isDownloadNetworkError400(e)) {
         this.setError(e);
         this.change.markChanged(`download of ${this.url} failed`);
         // Just in case we were half-way extracting an archive.

package/src/drivers/logs_stream.ts

@@ -21,7 +21,7 @@ import { randomUUID } from 'node:crypto';
 import type { PlTreeEntry, ResourceInfo } from '@milaboratories/pl-tree';
 import { treeEntryToResourceInfo } from '@milaboratories/pl-tree';
 import { scheduler } from 'node:timers/promises';
-import type { StreamingAPI_Response } from '../proto/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol';
+import type { StreamingAPI_Response } from '../proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/streamingapi/protocol';
 import type * as sdk from '@milaboratories/pl-model-common';
 import type { PollingOps } from './helpers/polling_ops';
 import type { RpcError } from '@protobuf-ts/runtime-rpc';