fix(mobile): rotate android raw natively instead of createBitmap

the exif rotate now happens in a small native pass (lock pixels + a
tiled copy straight into the output buffer) so there's no second full
bitmap. about 6x faster on big raws. also fixes orientation 5/7 which
were swapped, and forces argb_8888 so high-bit-depth dng don't
under-allocate. keeps the skia path as a fallback for odd formats.

.github/workflows/test.yml

@@ -716,7 +716,7 @@ jobs:
           github_token: ${{ steps.token.outputs.token }}
 
       - name: Install server dependencies
-        run: pnpm --filter immich install --frozen-lockfile
+        run: SHARP_IGNORE_GLOBAL_LIBVIPS=true pnpm --filter immich install --frozen-lockfile
       - name: Run API generation
         run: mise //:open-api
         working-directory: open-api
@@ -774,7 +774,7 @@ jobs:
           github_token: ${{ steps.token.outputs.token }}
 
       - name: Install server dependencies
-        run: pnpm install --frozen-lockfile
+        run: SHARP_IGNORE_GLOBAL_LIBVIPS=true pnpm install --frozen-lockfile
 
       - name: Build plugins
         run: mise //:plugins

docs/docs/administration/email-notification.mdx

@@ -14,8 +14,6 @@ Under Email, enter the required details to connect with an SMTP server.
 
 You can use [this guide](/guides/smtp-gmail) to use Gmail's SMTP server.
 
-You can use [this guide](/guides/smtp-microsoft365) to use Microsoft's SMTP server.
-
 ## User's notifications settings
 
 Users can manage their email notification settings from their account settings page on the web. They can choose to turn email notifications on or off for the following events:

docs/docs/guides/smtp-microsoft365.md

@@ -1,19 +0,0 @@
-# SMTP settings using Microsoft 365
-
-This guide walks you through how to get the information you need to set up your Immich instance to send emails using Microsoft's SMTP server.
-
-## Create an app password
-
-You will need to generate an app password to use your Microsoft email in Immich. Depending on if you have a personal or business account, you can use https://go.microsoft.com/fwlink/?linkid=2274139 or https://myaccount.microsoft.com/securtiy-info respectively.
-
-## Entering the SMTP credential in Immich
-
-Entering your credential in Immich's email notification settings at `Administration -> Settings -> Notification Settings`
-
-Host: smtp-mail.outlook.com
-Port: 587
-username: your mail address
-Password: app password you created earlier
-SMTPS: set it to disabled
-
-<img src={require('./img/email-ms-settings.webp').default} width="80%" title="SMTP settings" />

e2e/package.json

@@ -48,7 +48,7 @@
     "pngjs": "^7.0.0",
     "prettier": "^3.7.4",
     "prettier-plugin-organize-imports": "^4.0.0",
-    "sharp": "^0.35.2",
+    "sharp": "^0.34.5",
     "socket.io-client": "^4.7.4",
     "supertest": "^7.0.0",
     "typescript": "^6.0.0",

mise.toml

@@ -57,6 +57,7 @@ dir = "open-api"
 run = "bash ./bin/generate-dart-sdk.sh"
 
 [tasks.open-api]
+env = { SHARP_IGNORE_GLOBAL_LIBVIPS = true }
 run = [
   { task = "//:plugins" },
   { task = "//server:install" },

mobile/android/app/CMakeLists.txt

@@ -7,6 +7,7 @@ project(native_buffer LANGUAGES C)
 
 add_library(native_buffer SHARED
     src/main/cpp/native_buffer.c
+    src/main/cpp/native_image.c
 )
 
 target_link_libraries(native_buffer jnigraphics)

mobile/android/app/src/main/cpp/native_image.c

@@ -0,0 +1,109 @@
+#include <jni.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <android/bitmap.h>
+
+// Cache-friendly block size for the tiled rotation (in pixels). 32x32 uint32 = 4KB, fits L1.
+#define TILE 32
+
+// EXIF orientation values (androidx.exifinterface.media.ExifInterface.ORIENTATION_*).
+enum {
+  ORIENTATION_FLIP_HORIZONTAL = 2,
+  ORIENTATION_ROTATE_180 = 3,
+  ORIENTATION_FLIP_VERTICAL = 4,
+  ORIENTATION_TRANSPOSE = 5,
+  ORIENTATION_ROTATE_90 = 6,
+  ORIENTATION_TRANSVERSE = 7,
+  ORIENTATION_ROTATE_270 = 8,
+};
+
+// The orientations that swap width and height. Must stay in sync with affine_for's dim usage.
+static int swaps_dims(int o) {
+  return o == ORIENTATION_ROTATE_90 || o == ORIENTATION_ROTATE_270 ||
+         o == ORIENTATION_TRANSPOSE || o == ORIENTATION_TRANSVERSE;
+}
+
+// A source pixel (sx, sy) maps to destination index base + sx*stepX + sy*stepY, where dw is the
+// destination width. This affine form covers all 8 EXIF orientations and matches the pixel layout
+// of Bitmap.createBitmap(src, matrixForExifOrientation(o)). int64_t so it stays correct on
+// armeabi-v7a (32-bit long) regardless of how large MAX_RAW_DECODE_PIXELS grows.
+static void affine_for(int o, int sw, int sh, int dw, int64_t *base, int64_t *stepX, int64_t *stepY) {
+  switch (o) {
+    case ORIENTATION_ROTATE_90:       *base = sh - 1;                             *stepX = dw;  *stepY = -1;  break;
+    case ORIENTATION_ROTATE_270:      *base = (int64_t) (sw - 1) * dw;            *stepX = -dw; *stepY = 1;   break;
+    case ORIENTATION_ROTATE_180:      *base = (int64_t) (sh - 1) * dw + (sw - 1); *stepX = -1;  *stepY = -dw; break;
+    case ORIENTATION_FLIP_HORIZONTAL: *base = sw - 1;                             *stepX = -1;  *stepY = dw;  break;
+    case ORIENTATION_FLIP_VERTICAL:   *base = (int64_t) (sh - 1) * dw;            *stepX = 1;   *stepY = -dw; break;
+    case ORIENTATION_TRANSPOSE:       *base = 0;                                  *stepX = dw;  *stepY = 1;   break;
+    case ORIENTATION_TRANSVERSE:      *base = (int64_t) (sw - 1) * dw + (sh - 1); *stepX = -dw; *stepY = -1;  break;
+    default:                          *base = 0;                                  *stepX = 1;   *stepY = dw;  break;
+  }
+}
+
+// Copy each source pixel (whole uint32, so channel order/premult is irrelevant) to its rotated
+// destination, walking TILE x TILE blocks so the scattered writes of a 90/270 transpose stay
+// cache-resident. dst is densely packed (rowBytes == dw*4, no padding), which the affine math relies on.
+static void rotate_tiled(const uint8_t *src, int srcStride, uint32_t *dst,
+                         int sw, int sh, int64_t base, int64_t stepX, int64_t stepY) {
+  for (int ty = 0; ty < sh; ty += TILE) {
+    int yEnd = ty + TILE < sh ? ty + TILE : sh;
+    for (int tx = 0; tx < sw; tx += TILE) {
+      int xEnd = tx + TILE < sw ? tx + TILE : sw;
+      for (int sy = ty; sy < yEnd; sy++) {
+        const uint32_t *srcRow = (const uint32_t *) (src + (size_t) sy * srcStride);
+        int64_t idx = base + (int64_t) sy * stepY + (int64_t) tx * stepX;
+        for (int sx = tx; sx < xEnd; sx++) {
+          dst[idx] = srcRow[sx];
+          idx += stepX;
+        }
+      }
+    }
+  }
+}
+
+// Rotates an RGBA_8888 bitmap to the given EXIF orientation into a freshly malloc'd buffer (free it
+// via NativeBuffer.free). Fills outInfo with {width, height, rowBytes} and returns the buffer
+// address, or 0 if the bitmap can't be handled (e.g. a non-8888 format) so the caller can fall back.
+JNIEXPORT jlong JNICALL
+Java_app_alextran_immich_NativeImage_rotate(
+    JNIEnv *env, jclass clazz, jobject bitmap, jint orientation, jintArray outInfo) {
+  AndroidBitmapInfo info;
+  if (AndroidBitmap_getInfo(env, bitmap, &info) != ANDROID_BITMAP_RESULT_SUCCESS) {
+    return 0;
+  }
+  if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
+    return 0;
+  }
+
+  int sw = (int) info.width;
+  int sh = (int) info.height;
+  int dw = swaps_dims(orientation) ? sh : sw;
+  int dh = swaps_dims(orientation) ? sw : sh;
+
+  uint32_t *dst = (uint32_t *) malloc((size_t) dw * dh * 4);
+  if (dst == NULL) {
+    return 0;
+  }
+
+  void *srcPixels = NULL;
+  if (AndroidBitmap_lockPixels(env, bitmap, &srcPixels) != ANDROID_BITMAP_RESULT_SUCCESS) {
+    free(dst);
+    return 0;
+  }
+
+  int64_t base, stepX, stepY;
+  affine_for(orientation, sw, sh, dw, &base, &stepX, &stepY);
+  rotate_tiled((const uint8_t *) srcPixels, (int) info.stride, dst, sw, sh, base, stepX, stepY);
+
+  AndroidBitmap_unlockPixels(env, bitmap);
+
+  jint dims[3] = {dw, dh, dw * 4};
+  (*env)->SetIntArrayRegion(env, outInfo, 0, 3, dims);
+  // Keep ownership in C until the buffer is safely handed back: if outInfo was somehow too small,
+  // SetIntArrayRegion left a pending exception and Kotlin will never receive (or free) dst.
+  if ((*env)->ExceptionCheck(env)) {
+    free(dst);
+    return 0;
+  }
+  return (jlong) dst;
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/NativeImage.kt

@@ -0,0 +1,19 @@
+package app.alextran.immich
+
+import android.graphics.Bitmap
+
+object NativeImage {
+  init {
+    // rotate() is compiled into the native_buffer shared lib (which already links jnigraphics).
+    System.loadLibrary("native_buffer")
+  }
+
+  /**
+   * Rotates an RGBA_8888 [bitmap] to the given EXIF [orientation], writing the result into a freshly
+   * malloc'd native buffer. Returns the buffer address (free it with [NativeBuffer.free]) and fills
+   * [outInfo] with {width, height, rowBytes}. Returns 0 when the bitmap can't be handled (e.g. a
+   * non-8888 config) so the caller can fall back.
+   */
+  @JvmStatic
+  external fun rotate(bitmap: Bitmap, orientation: Int, outInfo: IntArray): Long
+}

mobile/android/app/src/main/kotlin/app/alextran/immich/images/LocalImagesImpl.kt

@@ -12,7 +12,9 @@ import android.provider.MediaStore.Images
 import android.provider.MediaStore.Video
 import android.util.Size
 import androidx.annotation.RequiresApi
+import androidx.exifinterface.media.ExifInterface
 import app.alextran.immich.NativeBuffer
+import app.alextran.immich.NativeImage
 import kotlin.math.*
 import java.io.IOException
 import java.util.concurrent.Executors
@@ -74,6 +76,11 @@ class LocalImagesImpl(context: Context) : LocalImageApi {
   companion object {
     val CANCELLED = Result.success<Map<String, Long>?>(null)
     val OPTIONS = BitmapFactory.Options().apply { inPreferredConfig = Bitmap.Config.ARGB_8888 }
+
+    // "Load original" decodes a raw at full res, and the orientation pass then walks every pixel, so
+    // cap the decode resolution to keep that bounded on huge DNGs. This only trims pixels on very
+    // large raws - they still come out upright, just downsampled.
+    const val MAX_RAW_DECODE_PIXELS = 24_000_000L
   }
 
   override fun getThumbhash(thumbhash: String, callback: (Result<Map<String, Long>>) -> Unit) {
@@ -181,35 +188,133 @@ class LocalImagesImpl(context: Context) : LocalImageApi {
     val id = assetId.toLong()
 
     signal.throwIfCanceled()
-    val bitmap = if (isVideo) {
-      decodeVideoThumbnail(id, size, signal)
-    } else {
-      decodeImage(id, size, signal)
-    }
-
     try {
-      signal.throwIfCanceled()
-      val res = bitmap.toNativeBuffer()
-      signal.throwIfCanceled()
+      val res = if (isVideo) {
+        decodeVideoThumbnail(id, size, signal).toNativeBuffer()
+      } else {
+        val (bitmap, orientation) = decodeImage(id, size, signal)
+        signal.throwIfCanceled()
+        if (orientation == ExifInterface.ORIENTATION_NORMAL || orientation == ExifInterface.ORIENTATION_UNDEFINED) {
+          bitmap.toNativeBuffer()
+        } else {
+          rotateToNativeBuffer(bitmap, orientation, signal)
+        }
+      }
+      // Don't re-check cancellation here: res owns a malloc'd buffer, and bailing to CANCELLED would
+      // orphan it. Deliver it; Dart frees the buffer itself if the request was cancelled meanwhile.
       callback(Result.success(res))
     } catch (e: Exception) {
       callback(if (e is OperationCanceledException) CANCELLED else Result.failure(e))
     }
   }
 
-  private fun decodeImage(id: Long, size: Size, signal: CancellationSignal): Bitmap {
+  // Returns the decoded bitmap plus the EXIF orientation that still needs applying. Only Q+ raw
+  // decodes come back unrotated (ImageDecoder / loadThumbnail skip EXIF for raw like DNG); every
+  // other path already orients itself, so it reports ORIENTATION_NORMAL.
+  private fun decodeImage(id: Long, size: Size, signal: CancellationSignal): Pair<Bitmap, Int> {
     signal.throwIfCanceled()
     val uri = ContentUris.withAppendedId(Images.Media.EXTERNAL_CONTENT_URI, id)
+    val handleRaw = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && isRawMime(uri)
+    val orientation = if (handleRaw) rawOrientation(uri) else ExifInterface.ORIENTATION_NORMAL
+
     if (size.width <= 0 || size.height <= 0 || size.width > 768 || size.height > 768) {
-      return decodeSource(uri, size, signal)
+      // A "load original" request is unsized -> a full-res decode. For raw, cap it so the later
+      // orientation pass stays within a safe pixel budget.
+      val bitmap = if (handleRaw && (size.width <= 0 || size.height <= 0)) {
+        decodeRawCapped(uri, signal)
+      } else {
+        decodeSource(uri, size, signal)
+      }
+      return bitmap to orientation
     }
 
-    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+    val bitmap = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
       resolver.loadThumbnail(uri, size, signal)
     } else {
       signal.setOnCancelListener { Images.Thumbnails.cancelThumbnailRequest(resolver, id) }
       Images.Thumbnails.getThumbnail(resolver, id, Images.Thumbnails.MINI_KIND, OPTIONS)
     }
+    return bitmap to orientation
+  }
+
+  private fun isRawMime(uri: Uri): Boolean {
+    val mime = resolver.getType(uri) ?: return false
+    return mime.startsWith("image/x-") || mime == "image/dng"
+  }
+
+  private fun rawOrientation(uri: Uri): Int {
+    return resolver.openInputStream(uri)?.use {
+      ExifInterface(it).getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
+    } ?: ExifInterface.ORIENTATION_NORMAL
+  }
+
+  // Full-res raw decode for "load original", sampled down to MAX_RAW_DECODE_PIXELS (power of two).
+  // Caps resolution only; the caller still rotates the result, so even huge raws end up upright.
+  @RequiresApi(Build.VERSION_CODES.Q)
+  private fun decodeRawCapped(uri: Uri, signal: CancellationSignal): Bitmap {
+    signal.throwIfCanceled()
+    return ImageDecoder.decodeBitmap(ImageDecoder.createSource(resolver, uri)) { decoder, info, _ ->
+      val pixels = info.size.width.toLong() * info.size.height.toLong()
+      var sample = 1
+      while (pixels / (sample.toLong() * sample) > MAX_RAW_DECODE_PIXELS) {
+        sample *= 2
+      }
+      if (sample > 1) {
+        decoder.setTargetSampleSize(sample)
+      }
+      decoder.allocator = ImageDecoder.ALLOCATOR_SOFTWARE
+      decoder.setTargetColorSpace(ColorSpace.get(ColorSpace.Named.SRGB))
+    }
+  }
+
+  // ImageDecoder / loadThumbnail skip EXIF orientation for raw (e.g. DNG) on Q+, so the decoded
+  // bitmap comes back unrotated. Rotate it into the output buffer in native code (one pass, no
+  // intermediate rotated bitmap), falling back to Skia for any config the native path can't take.
+  private fun rotateToNativeBuffer(bitmap: Bitmap, orientation: Int, signal: CancellationSignal): Map<String, Long> {
+    signal.throwIfCanceled()
+    // Force ARGB_8888 so both the native pass and the Skia fallback are 4 bytes/pixel: the native
+    // rotate needs a lockable 8888 buffer, and toNativeBuffer() below allocates width*height*4 (an
+    // F16/HDR decode would otherwise under-allocate). No-op for the common already-8888 case.
+    val src = if (bitmap.config != Bitmap.Config.ARGB_8888) {
+      val converted = bitmap.copy(Bitmap.Config.ARGB_8888, false)
+      bitmap.recycle()
+      converted ?: throw IOException("could not convert bitmap to ARGB_8888")
+    } else {
+      bitmap
+    }
+    try {
+      val info = IntArray(3)
+      val pointer = NativeImage.rotate(src, orientation, info)
+      if (pointer != 0L) {
+        return mapOf(
+          "pointer" to pointer,
+          "width" to info[0].toLong(),
+          "height" to info[1].toLong(),
+          "rowBytes" to info[2].toLong()
+        )
+      }
+      // Native path declined (unsupported config) -> rotate via Skia, then copy out.
+      val matrix = matrixForExifOrientation(orientation) ?: return src.toNativeBuffer()
+      return Bitmap.createBitmap(src, 0, 0, src.width, src.height, matrix, true).toNativeBuffer()
+    } finally {
+      if (!src.isRecycled) src.recycle()
+    }
+  }
+
+  // EXIF orientation (1-8) -> transform matrix, or null when no rotation/flip is needed.
+  private fun matrixForExifOrientation(orientation: Int): Matrix? {
+    val matrix = Matrix()
+    when (orientation) {
+      ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f)
+      ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f)
+      ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f)
+      ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.postScale(-1f, 1f)
+      ExifInterface.ORIENTATION_FLIP_VERTICAL -> matrix.postScale(1f, -1f)
+      ExifInterface.ORIENTATION_TRANSPOSE -> matrix.apply { postRotate(270f); postScale(-1f, 1f) }
+      ExifInterface.ORIENTATION_TRANSVERSE -> matrix.apply { postRotate(90f); postScale(-1f, 1f) }
+      else -> return null
+    }
+    return matrix
   }
 
   private fun decodeVideoThumbnail(id: Long, target: Size, signal: CancellationSignal): Bitmap {

mobile/lib/presentation/widgets/backup/backup_toggle_button.widget.dart

@@ -106,57 +106,65 @@ class BackupToggleButtonState extends ConsumerState<BackupToggleButton> with Sin
               borderRadius: const BorderRadius.all(Radius.circular(18.5)),
               color: context.colorScheme.surfaceContainerLow,
             ),
-            child: Padding(
-              padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 16),
-              child: Row(
-                children: [
-                  Container(
-                    padding: const EdgeInsets.all(8),
-                    decoration: BoxDecoration(
-                      shape: BoxShape.circle,
-                      gradient: LinearGradient(
-                        colors: [
-                          context.primaryColor.withValues(alpha: 0.2),
-                          context.primaryColor.withValues(alpha: 0.1),
-                        ],
+            child: Material(
+              color: context.colorScheme.surfaceContainerLow,
+              borderRadius: const BorderRadius.all(Radius.circular(20.5)),
+              child: InkWell(
+                borderRadius: const BorderRadius.all(Radius.circular(20.5)),
+                onTap: () => _onToggle(!_isEnabled),
+                child: Padding(
+                  padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 16),
+                  child: Row(
+                    children: [
+                      Container(
+                        padding: const EdgeInsets.all(8),
+                        decoration: BoxDecoration(
+                          shape: BoxShape.circle,
+                          gradient: LinearGradient(
+                            colors: [
+                              context.primaryColor.withValues(alpha: 0.2),
+                              context.primaryColor.withValues(alpha: 0.1),
+                            ],
+                          ),
+                        ),
+                        child: isProcessing
+                            ? const SizedBox(width: 24, height: 24, child: CircularProgressIndicator(strokeWidth: 2))
+                            : Icon(Icons.cloud_upload_outlined, color: context.primaryColor, size: 24),
                       ),
-                    ),
-                    child: isProcessing
-                        ? const SizedBox(width: 24, height: 24, child: CircularProgressIndicator(strokeWidth: 2))
-                        : Icon(Icons.cloud_upload_outlined, color: context.primaryColor, size: 24),
-                  ),
-                  const SizedBox(width: 16),
-                  Expanded(
-                    child: Column(
-                      crossAxisAlignment: CrossAxisAlignment.start,
-                      children: [
-                        Row(
-                          crossAxisAlignment: CrossAxisAlignment.center,
+                      const SizedBox(width: 16),
+                      Expanded(
+                        child: Column(
+                          crossAxisAlignment: CrossAxisAlignment.start,
                           children: [
-                            Flexible(
-                              child: Text(
-                                "enable_backup".t(context: context),
-                                style: context.textTheme.titleMedium?.copyWith(
-                                  fontWeight: FontWeight.w600,
-                                  color: context.primaryColor,
+                            Row(
+                              crossAxisAlignment: CrossAxisAlignment.center,
+                              children: [
+                                Flexible(
+                                  child: Text(
+                                    "enable_backup".t(context: context),
+                                    style: context.textTheme.titleMedium?.copyWith(
+                                      fontWeight: FontWeight.w600,
+                                      color: context.primaryColor,
+                                    ),
+                                  ),
+                                ),
+                              ],
+                            ),
+                            if (errorCount > 0)
+                              Padding(
+                                padding: const EdgeInsets.only(top: 2),
+                                child: Text(
+                                  "upload_error_with_count".t(context: context, args: {'count': '$errorCount'}),
+                                  style: context.textTheme.labelMedium?.copyWith(color: context.colorScheme.error),
                                 ),
                               ),
-                            ),
                           ],
                         ),
-                        if (errorCount > 0)
-                          Padding(
-                            padding: const EdgeInsets.only(top: 2),
-                            child: Text(
-                              "upload_error_with_count".t(context: context, args: {'count': '$errorCount'}),
-                              style: context.textTheme.labelMedium?.copyWith(color: context.colorScheme.error),
-                            ),
-                          ),
-                      ],
-                    ),
+                      ),
+                      Switch.adaptive(value: _isEnabled, onChanged: (value) => _onToggle(value)),
+                    ],
                   ),
-                  Switch.adaptive(value: _isEnabled, onChanged: (value) => _onToggle(value)),
-                ],
+                ),
               ),
             ),
           ),

open-api/immich-openapi-specs.json

@@ -16252,7 +16252,7 @@
     },
     {
       "name": "Faces",
-      "description": "A face is a detected human face within an asset, which can be associated with a person. Faces are normally detected via machine learning, but can also be created manually."
+      "description": "A face is a detected human face within an asset, which can be associated with a person. Faces are normally detected via machine learning, but can also be created via manually."
     },
     {
       "name": "Integrity (admin)",

packages/plugin-core/manifest.json

@@ -233,6 +233,12 @@
         }
       }
     },
+    {
+      "name": "assetTimeline",
+      "title": "Move to timeline",
+      "description": "Change visibility to timeline",
+      "types": ["AssetV1"]
+    },
     {
       "name": "assetVisibility",
       "title": "Update visibility",
@@ -295,38 +301,100 @@
       }
     },
     {
-      "name": "webhook",
-      "title": "Trigger Webhook",
-      "description": "POST/PUT event data to any URL",
+      "name": "noop1",
+      "title": "DEV: Nested properties",
+      "description": "Example configuration with nested properties",
       "types": ["AssetV1"],
-      "hostFunctions": true,
-      "allowedHosts": ["*"],
       "schema": {
         "type": "object",
         "properties": {
-          "url": {
-            "type": "string",
-            "title": "URL",
-            "description": "Event data will be PUT/POSTed to this URL as a JSON object"
+          "number1": {
+            "type": "number",
+            "title": "Number 1",
+            "description": "Basic number"
           },
-          "headerName": {
-            "type": "string",
-            "title": "Header name",
-            "description": "The name of an additional header to include with the request (e.g. authentication)"
+          "number2": {
+            "type": "number",
+            "title": "Number 2",
+            "array": true,
+            "description": "List of numbers"
           },
-          "headerValue": {
+          "string1": {
             "type": "string",
-            "title": "Header value",
-            "description": "The value of the additional header"
+            "title": "String 1",
+            "description": "Basic string"
           },
-          "method": {
+          "string2": {
             "type": "string",
-            "title": "Method",
-            "description": "The HTTP method to use in the request",
-            "enum": ["POST", "PUT"]
+            "title": "String 2",
+            "array": true,
+            "description": "List of strings"
+          },
+          "string3": {
+            "type": "string",
+            "title": "String 3",
+            "enum": ["choice-1", "choice-2"],
+            "description": "Select from a list"
+          },
+          "nested": {
+            "type": "object",
+            "title": "Nested",
+            "description": "Nested properties for nesting",
+            "properties": {
+              "nested1": {
+                "type": "string",
+                "title": "Nested 1",
+                "description": "Nested string"
+              },
+              "nested2": {
+                "type": "number",
+                "title": "Nested 2",
+                "description": "Nested number"
+              },
+              "nested3": {
+                "type": "object",
+                "title": "Nested 3",
+                "description": "Nested again",
+                "properties": {
+                  "nested4": {
+                    "type": "boolean",
+                    "title": "Nested 4",
+                    "description": "Nested, nested boolean"
+                  }
+                }
+              }
+            }
           }
-        },
-        "required": ["url"]
+        }
+      }
+    },
+    {
+      "name": "noop2",
+      "title": "DEV: Album pickers",
+      "description": "Example configuration with album pickers",
+      "types": ["AssetV1"],
+      "schema": {
+        "properties": {
+          "albumId": {
+            "type": "string",
+            "title": "Album ID",
+            "description": "Target album ID",
+            "uiHint": {
+              "type": "AlbumId",
+              "order": 1
+            }
+          },
+          "albumIds": {
+            "type": "string",
+            "title": "Album IDs",
+            "description": "Target album IDs",
+            "array": true,
+            "uiHint": {
+              "type": "AlbumId",
+              "order": 2
+            }
+          }
+        }
       }
     }
   ]

packages/plugin-core/src/index.ts

@@ -1,201 +1,157 @@
-import { wrapper } from '@immich/plugin-sdk';
+import { getWrapper } from '@immich/plugin-sdk';
 import { AssetVisibility } from '@immich/sdk';
 import type { Manifest } from '../dist/index.d.ts';
 
-const methods = wrapper<Manifest>({
-  assetAddToAlbums: ({ config, data, functions }) => {
-    const assetId = data.asset.id;
+const wrapper = getWrapper<Manifest>();
 
-    if (config.albumIds.length === 0) {
-      if (!config.albumName) {
-        return {};
-      }
+export const assetFileFilter = wrapper<'assetFileFilter'>(({ data, config }) => {
+  const { pattern, matchType = 'contains', caseSensitive = false } = config;
 
-      const [existing] = functions.searchAlbums({ name: config.albumName });
-      if (!existing) {
-        const created = functions.createAlbum({ albumName: config.albumName, assetIds: [assetId] });
-        config.albumIds.push(created.id);
-        return {};
-      }
+  const { asset } = data;
 
-      config.albumIds.push(existing.id);
+  const fileName = asset.originalFileName || '';
+  const searchName = caseSensitive ? fileName : fileName.toLowerCase();
+  const searchPattern = caseSensitive ? pattern : pattern.toLowerCase();
+
+  switch (matchType) {
+    case 'contains': {
+      return { workflow: { continue: searchName.includes(searchPattern) } };
     }
 
-    if (config.albumIds.length === 1) {
-      functions.addAssetsToAlbum(config.albumIds[0], [assetId]);
+    case 'exact': {
+      return { workflow: { continue: searchName === searchPattern } };
+    }
+
+    case 'startsWith': {
+      return { workflow: { continue: searchName.startsWith(searchPattern) } };
+    }
+
+    case 'regex': {
+      const flags = caseSensitive ? '' : 'i';
+      const regex = new RegExp(searchPattern, flags);
+      return { workflow: { continue: regex.test(fileName) } };
+    }
+
+    default: {
+      return {};
+    }
+  }
+});
+
+export const assetMissingTimeZoneFilter = wrapper<'assetMissingTimeZoneFilter'>(({ config, data }) => {
+  const hasTimeZone = !!data.asset?.exifInfo?.timeZone;
+  const needsTimeZone = config.inverse ? true : false;
+  return { workflow: { continue: hasTimeZone === needsTimeZone } };
+});
+
+export const assetLocationFilter = wrapper<'assetLocationFilter'>(({ config, data }) => {
+  if (
+    (config.region?.country && config.region.country !== data.asset.exifInfo?.country) ||
+    (config.region?.state && config.region.state !== data.asset.exifInfo?.state) ||
+    (config.region?.city && config.region.city !== data.asset.exifInfo?.city)
+  ) {
+    return { workflow: { continue: false } };
+  }
+
+  const configLat = Number.parseFloat(config.coordinate?.latitude ?? '');
+  const configLon = Number.parseFloat(config.coordinate?.longitude ?? '');
+
+  if (Number.isNaN(configLat) || Number.isNaN(configLat)) {
+    return { workflow: { continue: true } };
+  }
+
+  const assetLat = data.asset.exifInfo?.latitude;
+  const assetLon = data.asset.exifInfo?.longitude;
+
+  if (assetLat === undefined || assetLat === null || assetLon === undefined || assetLon === null) {
+    return { workflow: { continue: false } };
+  }
+
+  const earthDiameter = 12742;
+  const deg = Math.PI / 180;
+  const delta = Math.asin(
+    Math.sqrt(
+      Math.pow(Math.sin((assetLat * deg - configLat * deg) / 2), 2) +
+        Math.cos(assetLat * deg) *
+          Math.cos(configLat * deg) *
+          Math.pow(Math.sin((assetLon * deg - configLon * deg) / 2), 2),
+    ),
+  );
+
+  return { workflow: { continue: earthDiameter * delta <= (config.coordinate?.radius ?? 0) } };
+});
+
+export const assetTypeFilter = wrapper<'assetTypeFilter'>(({ config, data }) => {
+  return { workflow: { continue: config.allowedTypes.includes(data.asset.type) } };
+});
+
+export const assetFavorite = wrapper<'assetFavorite'>(({ config, data }) => {
+  const target = config.inverse ? false : true;
+  if (target !== data.asset.isFavorite) {
+    return {
+      changes: {
+        asset: { isFavorite: target },
+      },
+    };
+  }
+});
+
+export const assetVisibility = wrapper<'assetVisibility'>(({ config }) => ({
+  changes: { asset: { visibility: config.visibility as AssetVisibility } },
+}));
+
+export const assetArchive = wrapper<'assetArchive'>(({ config, data }) => {
+  if (!config.inverse && data.asset.visibility !== AssetVisibility.Archive) {
+    return { changes: { asset: { visibility: AssetVisibility.Archive } } };
+  }
+
+  if (config.inverse && data.asset.visibility === AssetVisibility.Archive) {
+    return { changes: { asset: { visibility: AssetVisibility.Timeline } } };
+  }
+
+  return {};
+});
+
+export const assetLock = wrapper<'assetLock'>(({ config, data }) => {
+  if (!config.inverse && data.asset.visibility !== AssetVisibility.Locked) {
+    return { changes: { asset: { visibility: AssetVisibility.Locked } } };
+  }
+
+  if (config.inverse && data.asset.visibility === AssetVisibility.Locked) {
+    return { changes: { asset: { visibility: AssetVisibility.Timeline } } };
+  }
+
+  return {};
+});
+
+// export const assetTrash = () => {
+//   // TODO use trash/untrash host functions
+//   return wrapper<WorkflowType.AssetV1, { inverse?: boolean }>(() => ({}));
+// };
+
+export const assetAddToAlbums = wrapper<'assetAddToAlbums'>(({ config, data, functions }) => {
+  const assetId = data.asset.id;
+
+  if (config.albumIds.length === 0) {
+    if (!config.albumName) {
       return {};
     }
 
-    functions.addAssetsToAlbums({ albumIds: config.albumIds, assetIds: [assetId] });
+    const [existing] = functions.searchAlbums({ name: config.albumName });
+    if (!existing) {
+      const created = functions.createAlbum({ albumName: config.albumName, assetIds: [assetId] });
+      config.albumIds.push(created.id);
+      return {};
+    }
+
+    config.albumIds.push(existing.id);
+  }
+
+  if (config.albumIds.length === 1) {
+    functions.addAssetsToAlbum(config.albumIds[0], [assetId]);
     return {};
-  },
+  }
 
-  assetArchive: ({ config, data }) => {
-    if (!config.inverse && data.asset.visibility !== AssetVisibility.Archive) {
-      return { changes: { asset: { visibility: AssetVisibility.Archive } } };
-    }
-
-    if (config.inverse && data.asset.visibility === AssetVisibility.Archive) {
-      return { changes: { asset: { visibility: AssetVisibility.Timeline } } };
-    }
-
-    return {};
-  },
-
-  assetFavorite: ({ config, data }) => {
-    const target = config.inverse ? false : true;
-    if (target !== data.asset.isFavorite) {
-      return {
-        changes: {
-          asset: { isFavorite: target },
-        },
-      };
-    }
-  },
-
-  assetFileFilter: ({ data, config }) => {
-    const { pattern, matchType = 'contains', caseSensitive = false } = config;
-
-    const { asset } = data;
-
-    const fileName = asset.originalFileName || '';
-    const searchName = caseSensitive ? fileName : fileName.toLowerCase();
-    const searchPattern = caseSensitive ? pattern : pattern.toLowerCase();
-
-    switch (matchType) {
-      case 'contains': {
-        return { workflow: { continue: searchName.includes(searchPattern) } };
-      }
-
-      case 'exact': {
-        return { workflow: { continue: searchName === searchPattern } };
-      }
-
-      case 'startsWith': {
-        return { workflow: { continue: searchName.startsWith(searchPattern) } };
-      }
-
-      case 'regex': {
-        const flags = caseSensitive ? '' : 'i';
-        const regex = new RegExp(searchPattern, flags);
-        return { workflow: { continue: regex.test(fileName) } };
-      }
-
-      default: {
-        return {};
-      }
-    }
-  },
-
-  assetLocationFilter: ({ config, data }) => {
-    if (
-      (config.region?.country && config.region.country !== data.asset.exifInfo?.country) ||
-      (config.region?.state && config.region.state !== data.asset.exifInfo?.state) ||
-      (config.region?.city && config.region.city !== data.asset.exifInfo?.city)
-    ) {
-      return { workflow: { continue: false } };
-    }
-
-    const configLat = Number.parseFloat(config.coordinate?.latitude ?? '');
-    const configLon = Number.parseFloat(config.coordinate?.longitude ?? '');
-
-    if (Number.isNaN(configLat) || Number.isNaN(configLat)) {
-      return { workflow: { continue: true } };
-    }
-
-    const assetLat = data.asset.exifInfo?.latitude;
-    const assetLon = data.asset.exifInfo?.longitude;
-
-    if (assetLat === undefined || assetLat === null || assetLon === undefined || assetLon === null) {
-      return { workflow: { continue: false } };
-    }
-
-    const earthDiameter = 12742;
-    const deg = Math.PI / 180;
-    const delta = Math.asin(
-      Math.sqrt(
-        Math.pow(Math.sin((assetLat * deg - configLat * deg) / 2), 2) +
-          Math.cos(assetLat * deg) *
-            Math.cos(configLat * deg) *
-            Math.pow(Math.sin((assetLon * deg - configLon * deg) / 2), 2),
-      ),
-    );
-
-    return { workflow: { continue: earthDiameter * delta <= (config.coordinate?.radius ?? 0) } };
-  },
-
-  assetLock: ({ config, data }) => {
-    if (!config.inverse && data.asset.visibility !== AssetVisibility.Locked) {
-      return { changes: { asset: { visibility: AssetVisibility.Locked } } };
-    }
-
-    if (config.inverse && data.asset.visibility === AssetVisibility.Locked) {
-      return { changes: { asset: { visibility: AssetVisibility.Timeline } } };
-    }
-
-    return {};
-  },
-
-  assetMissingTimeZoneFilter: ({ config, data }) => {
-    const hasTimeZone = !!data.asset?.exifInfo?.timeZone;
-    const needsTimeZone = config.inverse ? true : false;
-    return { workflow: { continue: hasTimeZone === needsTimeZone } };
-  },
-
-  assetTypeFilter: ({ config, data }) => {
-    return { workflow: { continue: config.allowedTypes.includes(data.asset.type) } };
-  },
-
-  assetVisibility: ({ config }) => ({
-    changes: { asset: { visibility: config.visibility as AssetVisibility } },
-  }),
-
-  webhook: ({ config, data, functions }) => {
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-    };
-
-    if (config.headerName && config.headerValue) {
-      headers[config.headerName] = config.headerValue;
-    }
-
-    functions.httpRequest(config.url, {
-      method: config.method ?? 'POST',
-      body: JSON.stringify(data.asset),
-      headers,
-    });
-
-    return {};
-  },
+  functions.addAssetsToAlbums({ albumIds: config.albumIds, assetIds: [assetId] });
+  return {};
 });
-
-const {
-  assetAddToAlbums,
-  assetArchive,
-  assetFavorite,
-  assetFileFilter,
-  assetLocationFilter,
-  assetLock,
-  assetMissingTimeZoneFilter,
-  assetTypeFilter,
-  assetVisibility,
-  webhook,
-
-  // should be empty. ensures that every field is destructured
-  ...rest
-} = methods;
-
-export {
-  assetAddToAlbums,
-  assetArchive,
-  assetFavorite,
-  assetFileFilter,
-  assetLocationFilter,
-  assetLock,
-  assetMissingTimeZoneFilter,
-  assetTypeFilter,
-  assetVisibility,
-  webhook,
-};
-
-'All methods must be destructured and exported' satisfies string & typeof rest;

packages/plugin-core/tsconfig.json

@@ -4,7 +4,7 @@
     "declaration": true,
     "emitDeclarationOnly": true,
     "esModuleInterop": true, // Enables compatibility with Babel-style module imports
-    "lib": ["es2020", "DOM"], // Specify a list of library files to be included in the compilation
+    "lib": ["es2020"], // Specify a list of library files to be included in the compilation
     "module": "nodenext", // Specify module code generation
     "moduleResolution": "nodenext",
     "noEmit": true, // Do not emit outputs (no .js or .d.ts files)

packages/plugin-sdk/src/host-functions.ts

@@ -30,23 +30,12 @@ type HostFunctionResult<T> =
 
 type QueryParams<T extends (...args: any) => any> = Parameters<T>[0];
 type AlbumSearchDto = QueryParams<typeof getAllAlbums>;
-type HttpRequestOptions = {
-  method?: string;
-  headers?: Record<string, string>;
-  body?: string;
-};
-type HttpResponse = {
-  ok: string;
-  status: number;
-  body: string;
-};
 
 export const availableFunctions = [
   'searchAlbums',
   'createAlbum',
   'addAssetsToAlbum',
   'addAssetsToAlbums',
-  'httpRequest',
 ] as const;
 
 export const hostFunctions = (authToken: string) => {
@@ -90,11 +79,5 @@ export const hostFunctions = (authToken: string) => {
       ),
     addAssetsToAlbums: ({ assetIds, albumIds }: AlbumsToAssets) =>
       call('addAssetsToAlbums', authToken, [{ albumIds, assetIds }]),
-    httpRequest: (url: string, options?: HttpRequestOptions) =>
-      call<[string, HttpRequestOptions | undefined], HttpResponse>(
-        'httpRequest',
-        authToken,
-        [url, options],
-      ),
   } satisfies Record<(typeof availableFunctions)[number], unknown>;
 };

packages/plugin-sdk/src/sdk.ts

@@ -1,3 +1,4 @@
+import type { WorkflowType } from '@immich/sdk';
 import { hostFunctions } from 'src/host-functions.js';
 import type {
   WorkflowEventPayload,
@@ -52,56 +53,53 @@ type ConfigValue<
       'required' extends keyof T ? T['required'] : undefined
     >['properties'];
 
-export const wrapper = <T extends Record<string, any>>(methods: {
-  [K in T['methods'][number] as K['name']]: (
-    payload: WorkflowEventPayload<
-      K['types'][number],
-      ConfigValue<K['schema']>
-    > & {
-      functions: ReturnType<typeof hostFunctions>;
-    },
-  ) => WorkflowResponse<K['types'][number]> | undefined;
-}) => {
-  const result: { [K in keyof typeof methods]: () => void } = {} as never;
-  for (const name of Object.keys(methods) as (keyof typeof methods)[]) {
-    result[name] = () => {
-      const input = Host.inputString();
+export const getWrapper =
+  <T extends Record<string, any>>() =>
+  <
+    K extends T['methods'][number]['name'],
+    L extends WorkflowType = (T['methods'][number] & {
+      name: K;
+    })['types'][number],
+    TConfig = ConfigValue<(T['methods'][number] & { name: K })['schema']>,
+  >(
+    fn: (
+      payload: WorkflowEventPayload<L, TConfig> & {
+        functions: ReturnType<typeof hostFunctions>;
+      },
+    ) => WorkflowResponse<L> | undefined,
+  ) =>
+  () => {
+    const input = Host.inputString();
 
-      try {
-        const payload = JSON.parse(input) as WorkflowEventPayload<
-          typeof name,
-          (T['methods'][number]['name'] & { name: typeof name })['schema']
-        >;
-        const event = {
-          ...payload,
-          functions: hostFunctions(payload.workflow.authToken),
-        };
+    try {
+      const payload = JSON.parse(input) as WorkflowEventPayload<K, TConfig>;
+      const event = {
+        ...payload,
+        functions: hostFunctions(payload.workflow.authToken),
+      };
 
-        const eventConfigBefore = JSON.stringify(event.config);
+      const eventConfigBefore = JSON.stringify(event.config);
 
-        console.debug(
-          `Inputs: trigger=${event.trigger}, event=${String(event.type)}, config=${eventConfigBefore}`,
-        );
+      console.debug(
+        `Inputs: trigger=${event.trigger}, event=${event.type}, config=${eventConfigBefore}`,
+      );
 
-        const response = methods[name](event) ?? {};
+      const response = fn(event) ?? {};
 
-        // if config changed, notify host
-        const eventConfigAfter = JSON.stringify(event.config);
-        if (!response.config && eventConfigBefore !== eventConfigAfter) {
-          response.config = event.config as WorkflowStepConfig;
-        }
-
-        console.debug(
-          `Outputs: workflow=${JSON.stringify(response.workflow)}, changes=${JSON.stringify(response.changes)}, data=${JSON.stringify(response.data)}, config=${JSON.stringify(response.config)}`,
-        );
-
-        const output = JSON.stringify(response);
-        Host.outputString(output);
-      } catch (error: Error | any) {
-        console.error(`Unhandled plugin exception: ${error.message || error}`);
-        throw error;
+      // if config changed, notify host
+      const eventConfigAfter = JSON.stringify(event.config);
+      if (!response.config && eventConfigBefore !== eventConfigAfter) {
+        response.config = event.config as WorkflowStepConfig;
       }
-    };
-  }
-  return result;
-};
+
+      console.debug(
+        `Outputs: workflow=${JSON.stringify(response.workflow)}, changes=${JSON.stringify(response.changes)}, data=${JSON.stringify(response.data)}, config=${JSON.stringify(response.config)}`,
+      );
+
+      const output = JSON.stringify(response);
+      Host.outputString(output);
+    } catch (error: Error | any) {
+      console.error(`Unhandled plugin exception: ${error.message || error}`);
+      throw error;
+    }
+  };

pnpm-workspace.yaml

@@ -29,7 +29,7 @@ allowBuilds:
   postman-code-generators: false
 overrides:
   canvas: 3.2.3
-  sharp: ^0.35.2
+  sharp: ^0.34.5
 packageExtensions:
   nestjs-kysely:
     dependencies:

server/Dockerfile

@@ -1,4 +1,4 @@
-FROM ghcr.io/immich-app/base-server-dev:202606180900@sha256:3871e19b02c37d0e3d2ee200e4977e0f2afc77730fd8dcc5e4532b6e2b26bdce AS builder
+FROM ghcr.io/immich-app/base-server-dev:202606161235@sha256:9f88b07acc8b7bf37a1dd3d5a19193f664443eaaab4e08e9f9341414c5e4b23f AS builder
 ENV COREPACK_ENABLE_DOWNLOAD_PROMPT=0 \
   CI=1 \
   COREPACK_HOME=/tmp \
@@ -20,9 +20,8 @@ RUN --mount=type=cache,id=pnpm-server,target=/buildcache/pnpm-store \
   --mount=type=bind,source=.pnpmfile.cjs,target=.pnpmfile.cjs \
   --mount=type=bind,source=pnpm-lock.yaml,target=pnpm-lock.yaml \
   --mount=type=bind,source=pnpm-workspace.yaml,target=pnpm-workspace.yaml \
-  pnpm --filter @immich/sdk --filter @immich/plugin-sdk --filter immich build && \
-  pnpm --filter immich --prod deploy /output/server-pruned && \
-  SHARP_FORCE_GLOBAL_LIBVIPS=true pnpm --dir /output/server-pruned/node_modules/sharp exec npm run build
+  SHARP_IGNORE_GLOBAL_LIBVIPS=true pnpm --filter @immich/sdk --filter @immich/plugin-sdk --filter immich build && \
+  SHARP_FORCE_GLOBAL_LIBVIPS=true  pnpm --filter immich --prod --no-optional deploy /output/server-pruned
 
 FROM builder AS web
 
@@ -38,7 +37,7 @@ RUN --mount=type=cache,id=pnpm-web,target=/buildcache/pnpm-store \
   --mount=type=bind,source=.pnpmfile.cjs,target=.pnpmfile.cjs \
   --mount=type=bind,source=pnpm-lock.yaml,target=pnpm-lock.yaml \
   --mount=type=bind,source=pnpm-workspace.yaml,target=pnpm-workspace.yaml \
-  pnpm --filter @immich/sdk --filter immich-web install --frozen-lockfile --force && \
+  SHARP_IGNORE_GLOBAL_LIBVIPS=true pnpm --filter @immich/sdk --filter immich-web install --frozen-lockfile --force && \
   pnpm --filter @immich/sdk --filter immich-web build
 
 FROM builder AS cli
@@ -81,7 +80,7 @@ RUN --mount=type=cache,id=pnpm-packages,target=/buildcache/pnpm-store \
   --mount=type=cache,id=mise-tools-${TARGETPLATFORM},target=/buildcache/mise \
   mise //:plugins
 
-FROM ghcr.io/immich-app/base-server-prod:202606180900@sha256:442159fae88a04b01a4caafbd9813f08aeefb2e1ae3b8a47cc82409208dfbd80
+FROM ghcr.io/immich-app/base-server-prod:202606161235@sha256:c6d59e3923f548d29a212b4dc51b6281a722cfa1da7972a009c0f3830f5762d6
 
 WORKDIR /usr/src/app
 ENV NODE_ENV=production \

server/Dockerfile.dev

@@ -1,5 +1,5 @@
 # dev build
-FROM ghcr.io/immich-app/base-server-dev:202606180900@sha256:3871e19b02c37d0e3d2ee200e4977e0f2afc77730fd8dcc5e4532b6e2b26bdce AS dev
+FROM ghcr.io/immich-app/base-server-dev:202606161235@sha256:9f88b07acc8b7bf37a1dd3d5a19193f664443eaaab4e08e9f9341414c5e4b23f AS dev
 
 
 COPY --from=ghcr.io/jdx/mise:2026.6.10@sha256:f57ac375a262f52f8ac3f9101348dbff2187d5e4b59612154f2f2808dbe46ef6 /usr/local/bin/mise /usr/local/bin/mise

server/package.json

@@ -107,7 +107,7 @@
     "rxjs": "^7.8.1",
     "sanitize-filename": "^1.6.3",
     "semver": "^7.8.1",
-    "sharp": "^0.35.2",
+    "sharp": "^0.34.5",
     "sirv": "^3.0.0",
     "socket.io": "^4.8.1",
     "tailwindcss-preset-email": "^1.4.0",
@@ -168,6 +168,6 @@
     "vitest": "^3.0.0"
   },
   "overrides": {
-    "sharp": "^0.35.2"
+    "sharp": "^0.34.5"
   }
 }

server/src/constants.ts

@@ -155,7 +155,7 @@ export const endpointTags: Record<ApiTag, string> = {
   [ApiTag.Download]: 'Endpoints for downloading assets or collections of assets.',
   [ApiTag.Duplicates]: 'Endpoints for managing and identifying duplicate assets.',
   [ApiTag.Faces]:
-    'A face is a detected human face within an asset, which can be associated with a person. Faces are normally detected via machine learning, but can also be created manually.',
+    'A face is a detected human face within an asset, which can be associated with a person. Faces are normally detected via machine learning, but can also be created via manually.',
   [ApiTag.Integrity]: 'Endpoints for viewing and managing integrity reports.',
   [ApiTag.Jobs]:
     'Queues and background jobs are used for processing tasks asynchronously. Queues can be paused and resumed as needed.',

server/src/database.ts

@@ -368,7 +368,6 @@ export const columns = {
     'plugin_method.types',
     'plugin_method.schema',
     'plugin_method.hostFunctions',
-    'plugin_method.allowedHosts',
     'plugin_method.uiHints',
   ],
   syncAsset: [

server/src/dtos/plugin-manifest.dto.ts

@@ -18,11 +18,6 @@ const PluginManifestMethodSchema = z
     description: z.string().min(1).describe('Method description'),
     types: z.array(WorkflowTypeSchema).min(1).describe('Workflow type'),
     hostFunctions: z.boolean().optional().default(false).describe('Method uses host functions'),
-    allowedHosts: z
-      .array(z.string())
-      .optional()
-      .default([])
-      .describe('Hostnames the method can access (use * for wildcards)'),
     schema: PluginManifestMethodSchemaSchema.describe('Schema'),
     uiHints: z.array(z.string()).optional().describe('Ui hints, for example "filter"'),
   })

server/src/queries/plugin.repository.sql

@@ -48,7 +48,6 @@ select
           "plugin_method"."types",
           "plugin_method"."schema",
           "plugin_method"."hostFunctions",
-          "plugin_method"."allowedHosts",
           "plugin_method"."uiHints",
           "plugin"."name" as "pluginName"
         from
@@ -85,7 +84,6 @@ select
           "plugin_method"."types",
           "plugin_method"."schema",
           "plugin_method"."hostFunctions",
-          "plugin_method"."allowedHosts",
           "plugin_method"."uiHints",
           "plugin"."name" as "pluginName"
         from
@@ -122,7 +120,6 @@ select
           "plugin_method"."types",
           "plugin_method"."schema",
           "plugin_method"."hostFunctions",
-          "plugin_method"."allowedHosts",
           "plugin_method"."uiHints",
           "plugin"."name" as "pluginName"
         from
@@ -159,7 +156,6 @@ select
           "plugin_method"."types",
           "plugin_method"."schema",
           "plugin_method"."hostFunctions",
-          "plugin_method"."allowedHosts",
           "plugin_method"."uiHints",
           "plugin"."name" as "pluginName"
         from
@@ -194,7 +190,6 @@ select
   "plugin_method"."types",
   "plugin_method"."schema",
   "plugin_method"."hostFunctions",
-  "plugin_method"."allowedHosts",
   "plugin_method"."uiHints"
 from
   "plugin_method"

server/src/queries/workflow.repository.sql

@@ -80,8 +80,7 @@ select
           "plugin_method"."pluginId" as "pluginId",
           "plugin_method"."name" as "methodName",
           "plugin_method"."types" as "types",
-          "plugin_method"."hostFunctions",
-          "plugin_method"."allowedHosts"
+          "plugin_method"."hostFunctions"
         from
           "workflow_step"
           inner join "plugin_method" on "plugin_method"."id" = "workflow_step"."pluginMethodId"

server/src/repositories/plugin.repository.ts

@@ -190,7 +190,6 @@ export class PluginRepository {
                   description: ref('excluded.description'),
                   types: ref('excluded.types'),
                   hostFunctions: ref('excluded.hostFunctions'),
-                  allowedHosts: ref('excluded.allowedHosts'),
                   uiHints: ref('excluded.uiHints'),
                   schema: ref('excluded.schema'),
                 })),
@@ -241,7 +240,7 @@ export class PluginRepository {
     }
   }
 
-  async callMethod<T>({ pluginKey, methodName }: PluginMethod, input: unknown, context?: unknown) {
+  async callMethod<T>({ pluginKey, methodName }: PluginMethod, input: unknown) {
     const item = this.pluginMap.get(pluginKey);
     if (!item) {
       throw new Error(`No loaded plugin found for ${pluginKey}`);
@@ -252,7 +251,7 @@ export class PluginRepository {
     try {
       const plugin = await pool.acquire();
       try {
-        const result = await plugin.call(methodName, JSON.stringify(input), context);
+        const result = await plugin.call(methodName, JSON.stringify(input));
         return (result ? result.json() : result) as T;
       } finally {
         await pool.release(plugin);

server/src/repositories/workflow.repository.ts

@@ -79,7 +79,6 @@ export class WorkflowRepository {
               'plugin_method.name as methodName',
               'plugin_method.types as types',
               'plugin_method.hostFunctions',
-              'plugin_method.allowedHosts',
             ]),
         ).as('steps'),
       ])

server/src/schema/migrations/1782414436633-AddPluginMethodAllowedHosts.ts

@@ -1,9 +0,0 @@
-import { Kysely, sql } from 'kysely';
-
-export async function up(db: Kysely<any>): Promise<void> {
-  await sql`ALTER TABLE "plugin_method" ADD "allowedHosts" character varying[] NOT NULL DEFAULT '{}';`.execute(db);
-}
-
-export async function down(db: Kysely<any>): Promise<void> {
-  await sql`ALTER TABLE "plugin_method" DROP COLUMN "allowedHosts";`.execute(db);
-}

server/src/schema/tables/plugin-method.table.ts

@@ -27,9 +27,6 @@ export class PluginMethodTable {
   @Column({ type: 'boolean', default: false })
   hostFunctions!: Generated<boolean>;
 
-  @Column({ type: 'character varying', default: [], array: true })
-  allowedHosts!: Generated<string[]>;
-
   @Column({ type: 'jsonb', nullable: true })
   schema!: JsonSchemaDto | null;
 

server/src/services/workflow-execution.service.ts

@@ -42,10 +42,6 @@ type ExecuteOptions<T extends WorkflowType> = {
 
 type AssetTrigger = { userId: string; assetId: string; trigger: WorkflowTrigger };
 
-type HostContext = {
-  allowedHosts: string[];
-};
-
 export class WorkflowExecutionService extends BaseService {
   private jwtSecret!: string;
 
@@ -70,48 +66,20 @@ export class WorkflowExecutionService extends BaseService {
 
     const albumService = BaseService.create(AlbumService, this);
 
-    const searchAlbums = this.wrap<[dto: GetAlbumsDto]>((authDto, ctx, args) => albumService.getAll(authDto, ...args));
-    const createAlbum = this.wrap<[dto: CreateAlbumDto]>((authDto, ctx, args) => albumService.create(authDto, ...args));
-    const addAssetsToAlbum = this.wrap<[id: string, dto: BulkIdsDto]>((authDto, ctx, args) =>
+    const searchAlbums = this.wrap<[dto: GetAlbumsDto]>((authDto, args) => albumService.getAll(authDto, ...args));
+    const createAlbum = this.wrap<[dto: CreateAlbumDto]>((authDto, args) => albumService.create(authDto, ...args));
+    const addAssetsToAlbum = this.wrap<[id: string, dto: BulkIdsDto]>((authDto, args) =>
       albumService.addAssets(authDto, ...args),
     );
-    const addAssetsToAlbums = this.wrap<[dto: AlbumsAddAssetsDto]>((authDto, ctx, args) =>
+    const addAssetsToAlbums = this.wrap<[dto: AlbumsAddAssetsDto]>((authDto, args) =>
       albumService.addAssetsToAlbums(authDto, ...args),
     );
-    const httpRequest = this.wrap<
-      [
-        url: string,
-        options?: {
-          method?: string;
-          headers?: Record<string, string>;
-          body?: string;
-        },
-      ]
-    >(async (authDto, context, args) => {
-      const hostname = new URL(args[0]).hostname;
-
-      for (const pattern of context.allowedHosts) {
-        const regex = new RegExp(pattern.replaceAll('.', String.raw`\.`).replaceAll('*', '.*'));
-        if (regex.test(hostname)) {
-          const res = await fetch(...args);
-
-          return {
-            ok: res.ok,
-            status: res.status,
-            body: await res.text(),
-          };
-        }
-      }
-
-      throw new Error('Hostname did not match any listed in methods[].allowedHosts in the plugin manifest');
-    });
 
     const functions = {
       searchAlbums,
       createAlbum,
       addAssetsToAlbum,
       addAssetsToAlbums,
-      httpRequest,
     };
 
     const stubs: typeof functions = {
@@ -119,7 +87,6 @@ export class WorkflowExecutionService extends BaseService {
       createAlbum: dummy,
       addAssetsToAlbum: dummy,
       addAssetsToAlbums: dummy,
-      httpRequest: dummy,
     };
 
     const plugins = await this.pluginRepository.getForLoad();
@@ -154,7 +121,7 @@ export class WorkflowExecutionService extends BaseService {
     return id + (hostFunctions ? '/worker' : '');
   }
 
-  private wrap<T>(fn: (authDto: AuthDto, context: HostContext, args: T) => Promise<unknown>) {
+  private wrap<T>(fn: (authDto: AuthDto, args: T) => Promise<unknown>) {
     return async (plugin: CurrentPlugin, offset: bigint) => {
       try {
         const handle = plugin.read(offset);
@@ -169,9 +136,8 @@ export class WorkflowExecutionService extends BaseService {
           throw new Error('authToken is required');
         }
 
-        const context = plugin.hostContext<HostContext>();
         const authDto = this.validate(authToken);
-        const response = await fn(authDto, context, args);
+        const response = await fn(authDto, args);
 
         return plugin.store(JSON.stringify({ success: true, response }));
       } catch (error: Error | any) {
@@ -415,10 +381,6 @@ export class WorkflowExecutionService extends BaseService {
           data,
         };
 
-        const context: HostContext = {
-          allowedHosts: step.allowedHosts,
-        };
-
         if (step.methodName.startsWith('noop')) {
           continue;
         }
@@ -429,7 +391,6 @@ export class WorkflowExecutionService extends BaseService {
             methodName: step.methodName,
           },
           payload,
-          context,
         );
         if (result?.changes) {
           await write(

server/test/medium/specs/workflow/workflow-core-plugin.spec.ts

@@ -427,32 +427,4 @@ describe('core plugin', () => {
       await expect(ctx.get(AssetRepository).getById(asset.id)).resolves.toMatchObject({ isFavorite: true });
     });
   });
-
-  describe('webhook', () => {
-    it('should trigger a webhook on asset upload', async () => {
-      const { user } = await ctx.newUser();
-      const { asset } = await ctx.newAsset({ ownerId: user.id });
-
-      const fetchMock = vi.fn(() => Promise.resolve({ ok: true, status: 200, text: () => Promise.resolve('') }));
-      vi.stubGlobal('fetch', fetchMock);
-
-      const workflow = await createWorkflow({
-        ownerId: user.id,
-        trigger: WorkflowTrigger.AssetCreate,
-        steps: [
-          {
-            method: 'immich-plugin-core#webhook',
-            config: { url: 'http://localhost', method: 'POST' },
-          },
-        ],
-      });
-
-      await expect(ctx.sut.handleAssetTrigger({ workflowId: workflow.id, assetId: asset.id })).resolves.toBeUndefined();
-      expect(fetchMock).toHaveBeenCalled();
-    });
-
-    afterEach(() => {
-      vi.unstubAllGlobals();
-    });
-  });
 });