@highstate/backend-api 0.9.16 → 0.9.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highstate/backend-api",
-  "version": "0.9.16",
+  "version": "0.9.19",
   "type": "module",
   "files": [
     "dist",
@@ -17,8 +17,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "highstate build",
-    "generate-sdk": "./scripts/generate-sdk.sh"
+    "build": "highstate build"
   },
   "peerDependencies": {
     "@pulumi/pulumi": "^3.163.0",
@@ -32,18 +31,15 @@
       "optional": true
     }
   },
-  "devDependencies": {
-    "ts-proto": "^2.7.5"
-  },
   "dependencies": {
     "@bufbuild/protobuf": "^2.6.1",
-    "@highstate/api": "^0.9.16",
-    "@highstate/backend": "^0.9.16",
-    "@highstate/cli": "^0.9.16",
+    "@highstate/api": "^0.9.19",
+    "@highstate/backend": "^0.9.19",
+    "@highstate/cli": "^0.9.19",
     "abort-controller-x": "^0.4.3",
     "nice-grpc": "^2.1.12",
     "nice-grpc-common": "^2.0.2",
     "zod": "^4.0.5"
   },
-  "gitHead": "458d6f1f9f6d4aec0ba75a2b2c4c01408cb9c8df"
+  "gitHead": "e77d292335556c6e5b6275acda1a3d1609d786a1"
 }

package/src/handlers/instance.ts

@@ -1,32 +1,44 @@
-import type { Services } from "@highstate/backend"
 import type { InstanceServiceImplementation } from "@highstate/api/instance.v1"
-import { instanceCustomStatusSchema } from "@highstate/backend/shared"
+import type { Services } from "@highstate/backend"
+import { instanceCustomStatusInputSchema } from "@highstate/backend/shared"
+import { z } from "@highstate/contract"
 import { authenticate, parseArgument } from "../shared"
 
 export function createInstanceService(services: Services): InstanceServiceImplementation {
   return {
     async updateCustomStatus(request, context) {
-      const [projectId] = await authenticate(services, context)
+      const [projectId, apiKey] = await authenticate(services, context)
 
       // TODO: validate instance access
 
-      const customStatus = parseArgument(request, "status", instanceCustomStatusSchema)
+      const stateId = parseArgument(request, "stateId", z.cuid2())
+      const customStatus = parseArgument(request, "status", instanceCustomStatusInputSchema)
 
       await services.instanceStateService.updateCustomStatus(
         projectId,
-        request.instanceId,
+        stateId,
+        apiKey.serviceAccountId,
         customStatus,
       )
 
       return {}
     },
 
-    async removeCustomStatus(request, _context) {
+    async removeCustomStatus(request, context) {
+      const [projectId, apiKey] = await authenticate(services, context)
+
+      // TODO: validate instance access
+
+      const stateId = parseArgument(request, "stateId", z.cuid2())
+
       await services.instanceStateService.removeCustomStatus(
-        "",
-        request.instanceId,
+        projectId,
+        stateId,
+        apiKey.serviceAccountId,
         request.statusName,
       )
+
+      return {}
     },
   }
 }

package/src/handlers/worker.ts

@@ -1,6 +1,6 @@
-import type { Services } from "@highstate/backend"
 import type { WorkerServiceImplementation } from "@highstate/api/worker.v1"
-import { workerSchema } from "@highstate/backend/shared"
+import type { Services } from "@highstate/backend"
+import { commonObjectMetaSchema, z } from "@highstate/contract"
 import { authenticate, parseArgument } from "../shared"
 
 export function createWorkerService(services: Services): WorkerServiceImplementation {
@@ -8,48 +8,72 @@ export function createWorkerService(services: Services): WorkerServiceImplementa
     async *connect(request, context) {
       const [projectId] = await authenticate(services, context)
 
-      // TODO: check worker access
-      const workerId = parseArgument(request, "workerId", workerSchema.shape.id)
+      const workerVersionId = parseArgument(request, "workerVersionId", z.cuid2())
 
-      const registrationStream = services.pubsubManager.subscribe([
-        "worker-unit-registration",
-        projectId,
-        workerId,
-      ])
+      // set worker as running
+      services.workerManager.setWorkerRunning(projectId, workerVersionId)
 
-      // update worker status
-      await services.workerManager.setWorkerRunning(projectId, workerId)
-      await services.workerManager.writeSystemMessage(projectId, workerId, "worker connected")
+      // get existing registrations for this worker version
+      const database = await services.database.forProject(projectId)
+      const existingRegistrations = await database.workerUnitRegistration.findMany({
+        where: { workerVersionId },
+        select: { stateId: true, params: true },
+      })
 
       // emit existing registrations
-      const registrations = await services.stateManager
-        .getWorkerRegistrationIndexRepository(projectId, workerId)
-        .getAllItems()
-
-      for (const registration of registrations) {
+      for (const registration of existingRegistrations) {
         yield {
           event: {
             $case: "unitRegistration",
             value: {
-              instanceId: registration.id,
+              stateId: registration.stateId,
               params: registration.params,
             },
           },
         }
       }
 
-      // emit new registrations
+      // subscribe to new registration events for this worker version
+      const registrationStream = await services.pubsubManager.subscribe([
+        "worker-unit-registration",
+        projectId,
+        workerVersionId,
+      ])
+
+      // emit new registration/deregistration events
       for await (const event of registrationStream) {
-        yield {
-          event: {
-            $case: "unitRegistration",
-            value: {
-              instanceId: event.instanceId,
-              params: event.params,
+        if (event.type === "registered") {
+          yield {
+            event: {
+              $case: "unitRegistration",
+              value: {
+                instanceId: event.instanceId,
+                params: event.params,
+              },
             },
-          },
+          }
+        } else if (event.type === "deregistered") {
+          yield {
+            event: {
+              $case: "unitDeregistration",
+              value: {
+                instanceId: event.instanceId,
+              },
+            },
+          }
         }
       }
     },
+
+    async updateWorkerVersionMeta(request, context) {
+      const [projectId] = await authenticate(services, context)
+
+      const workerVersionId = parseArgument(request, "workerVersionId", z.string())
+      const meta = parseArgument(request, "meta", commonObjectMetaSchema)
+
+      await services.workerService.updateWorkerVersionMeta(projectId, workerVersionId, meta)
+
+      return {}
+    },
   }
 }

package/src/index.ts

@@ -1,5 +1,6 @@
+import { rm } from "node:fs/promises"
 import { createServer } from "nice-grpc"
-import { type Services } from "@highstate/backend"
+import type { Services } from "@highstate/backend"
 import { InstanceServiceDefinition } from "@highstate/api/instance.v1"
 import { SecretServiceDefinition } from "@highstate/api/secret.v1"
 import { WorkerServiceDefinition } from "@highstate/api/worker.v1"
@@ -16,9 +17,17 @@ export async function startBackedApi(services: Services) {
   server.add(SecretServiceDefinition, createSecretService(services))
   server.add(WorkerServiceDefinition, createWorkerService(services))
 
-  const uid = process.geteuid!()
+  const uid = process.geteuid?.()
   const sockPath = `/run/user/${uid}/highstate.sock`
 
+  try {
+    await rm(sockPath, { force: true })
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
+      services.logger.error({ error }, "failed to remove existing socket file")
+    }
+  }
+
   await server.listen(`unix:${sockPath}`)
 
   services.workerManager.config.HIGHSTATE_WORKER_API_PATH = sockPath

package/src/shared/authentication.ts

@@ -1,11 +1,10 @@
-import type { Services } from "@highstate/backend"
-import type { ProjectApiKey } from "@highstate/backend/shared"
-import { ServerError, Status, type CallContext } from "nice-grpc-common"
+import type { ApiKey, Services } from "@highstate/backend"
+import { type CallContext, ServerError, Status } from "nice-grpc-common"
 
 export async function authenticate(
   services: Services,
   context: CallContext,
-): Promise<[projectId: string, apiKey: ProjectApiKey]> {
+): Promise<[projectId: string, apiKey: ApiKey]> {
   const token = context.metadata.get("api-key")
   if (!token) {
     throw new ServerError(Status.UNAUTHENTICATED, "No API key provided")

package/src/shared/error-handling.ts

@@ -1,7 +1,7 @@
 import type { Services } from "@highstate/backend"
-import { ServerError, Status, type CallContext, type ServerMiddlewareCall } from "nice-grpc-common"
-import { isAbortError } from "abort-controller-x"
 import { AccessError } from "@highstate/backend/shared"
+import { isAbortError } from "abort-controller-x"
+import { type CallContext, ServerError, type ServerMiddlewareCall, Status } from "nice-grpc-common"
 
 export function createErrorHandlingMiddleware(services: Services) {
   return async function* errorHandlingMiddleware<TRequest, TResponse>(