@science-corporation/synapse 2.2.5 → 2.2.7

package/src/api/proto.json

@@ -453,6 +453,10 @@
               "responseType": "AppDeployResponse",
               "responseStream": true
             },
+            "ListApps": {
+              "requestType": "ListAppsRequest",
+              "responseType": "ListAppsResponse"
+            },
             "ListFiles": {
               "requestType": "google.protobuf.Empty",
               "responseType": "ListFilesResponse"
@@ -1416,6 +1420,30 @@
             }
           }
         },
+        "AppInfo": {
+          "fields": {
+            "name": {
+              "type": "string",
+              "id": 1
+            },
+            "version": {
+              "type": "string",
+              "id": 2
+            }
+          }
+        },
+        "ListAppsRequest": {
+          "fields": {}
+        },
+        "ListAppsResponse": {
+          "fields": {
+            "apps": {
+              "rule": "repeated",
+              "type": "AppInfo",
+              "id": 1
+            }
+          }
+        },
         "FunctionProfile": {
           "fields": {
             "name": {

package/src/device.ts

@@ -1,4 +1,8 @@
 import { Channel, credentials, ServiceError } from "@grpc/grpc-js";
+import * as fs from "fs";
+import * as crypto from "crypto";
+import * as path from "path";
+import Long from "long";
 
 import protos from "./api/proto.json";
 import { synapse } from "./api/api";
@@ -6,6 +10,24 @@ import Config from "./config";
 import { CallOptions, create } from "./utils/client";
 import { fromDeviceStatus, Status } from "./utils/status";
 
+const FILE_CHUNK_SIZE = 1024 * 1024; // 1MB chunks
+
+function calculateSha256(filePath: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+    stream.on("data", (data) => hash.update(data));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+
+function extractVersion(packageName: string): string {
+  // Format: package-name_version_architecture.deb
+  const parts = packageName.split("_");
+  return parts.length >= 2 ? parts[1] : "";
+}
+
 const kSynapseService = "synapse.SynapseDevice";
 
 class Device {
@@ -183,6 +205,124 @@ class Device {
     return call;
   }
 
+  // Apps
+
+  async listApps(options: CallOptions = {}): Promise<{ status: Status; response?: synapse.ListAppsResponse }> {
+    return new Promise((resolve, reject) => {
+      this.rpc.listApps({}, options, (err: ServiceError, res: synapse.ListAppsResponse) => {
+        if (err) {
+          reject(err);
+        } else if (!res) {
+          reject(new Error("No response from listApps"));
+        } else {
+          resolve({ status: new Status(), response: res });
+        }
+      });
+    });
+  }
+
+  deployApp(
+    options: CallOptions = {},
+    callbacks: {
+      onData: (data: synapse.AppDeployResponse) => void;
+      onEnd?: () => void;
+      onError?: (err: Error) => void;
+      onStatus?: (status: Status) => void;
+    }
+  ) {
+    const { onData, onEnd, onError, onStatus } = callbacks;
+    const call = this.rpc.deployApp({}, options);
+
+    call.on("data", (data: synapse.AppDeployResponse) => {
+      onData(data);
+    });
+    if (onEnd) {
+      call.on("end", onEnd);
+    }
+    if (onError) {
+      call.on("error", (err: ServiceError) => {
+        onError(err);
+      });
+    }
+    if (onStatus) {
+      call.on("status", (grpcStatus) => {
+        onStatus?.(new Status(grpcStatus.code, grpcStatus.details));
+      });
+    }
+
+    return {
+      call,
+      sendMetadata: (metadata: synapse.IPackageMetadata) => {
+        call.write({ metadata });
+      },
+      sendChunk: (fileChunk: Uint8Array) => {
+        call.write({ fileChunk });
+      },
+      end: () => {
+        call.end();
+      },
+    };
+  }
+
+  async deploy(
+    debPackagePath: string,
+    callbacks?: {
+      onProgress?: (bytesTransferred: number, totalBytes: number) => void;
+      onStatus?: (message: string) => void;
+    }
+  ): Promise<Status> {
+    const fileName = path.basename(debPackagePath);
+    const fileSize = fs.statSync(debPackagePath).size;
+    const sha256Sum = await calculateSha256(debPackagePath);
+    const version = extractVersion(fileName);
+
+    const metadata: synapse.IPackageMetadata = {
+      name: fileName,
+      version,
+      size: Long.fromNumber(fileSize),
+      sha256Sum,
+    };
+
+    return new Promise((resolve, reject) => {
+      let bytesTransferred = 0;
+
+      const { sendMetadata, sendChunk, end } = this.deployApp({}, {
+        onData: (response) => {
+          callbacks?.onStatus?.(response.message || "");
+          if (response.status !== synapse.StatusCode.kOk) {
+            reject(new Error(response.message || "Deployment failed"));
+          }
+        },
+        onEnd: () => {
+          resolve(new Status());
+        },
+        onError: (err) => {
+          reject(err);
+        },
+      });
+
+      sendMetadata(metadata);
+
+      const stream = fs.createReadStream(debPackagePath, {
+        highWaterMark: FILE_CHUNK_SIZE,
+      });
+
+      stream.on("data", (chunk: Buffer) => {
+        sendChunk(chunk);
+        bytesTransferred += chunk.length;
+        callbacks?.onProgress?.(bytesTransferred, fileSize);
+      });
+
+      stream.on("end", () => {
+        end();
+      });
+
+      stream.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+
   _handleStatusResponse(status: synapse.IStatus): Status {
     const { code, message } = status;
     if (code !== synapse.StatusCode.kOk) {

package/synapse-api/api/app.proto

@@ -53,3 +53,19 @@ message AppPerformanceSummary {
   uint64 timestamp_ns = 1;
   repeated FunctionProfile function_profiles = 2;
 }
+
+// Information about an installed application
+message AppInfo {
+  // Application name (e.g., "synapse-example-app")
+  string name = 1;
+
+  // Installed version
+  string version = 2;
+}
+
+message ListAppsRequest {
+}
+
+message ListAppsResponse {
+  repeated AppInfo apps = 1;
+}

package/synapse-api/api/synapse.proto

@@ -20,6 +20,7 @@ service SynapseDevice {
   rpc StreamQuery(StreamQueryRequest) returns (stream StreamQueryResponse) {}
 
   rpc DeployApp(stream AppPackageChunk) returns (stream AppDeployResponse) {}
+  rpc ListApps(ListAppsRequest) returns (ListAppsResponse) {}
 
   rpc ListFiles(google.protobuf.Empty) returns (ListFilesResponse) {}
   rpc WriteFile(WriteFileRequest) returns (WriteFileResponse) {}