neoagent 2.3.1-beta.2 → 2.3.1-beta.21

package/flutter_app/third_party/desktop_audio_capture/windows/system_audio_capture_plugin.h

@@ -0,0 +1,87 @@
+#ifndef FLUTTER_PLUGIN_SYSTEM_AUDIO_CAPTURE_PLUGIN_H_
+#define FLUTTER_PLUGIN_SYSTEM_AUDIO_CAPTURE_PLUGIN_H_
+
+#include <flutter/event_channel.h>
+#include <flutter/method_channel.h>
+#include <flutter/plugin_registrar_windows.h>
+#include <flutter/standard_method_codec.h>
+
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <atomic>
+#include <vector>
+
+// Include Windows headers for WAVEFORMATEX
+#include <mmsystem.h>
+
+// Forward declarations for WASAPI interfaces
+struct IAudioClient;
+struct IAudioCaptureClient;
+struct IMMDevice;
+
+namespace audio_capture {
+
+class SystemAudioCapturePlugin : public flutter::Plugin {
+ public:
+  static void RegisterWithRegistrar(flutter::PluginRegistrarWindows *registrar);
+
+  SystemAudioCapturePlugin(flutter::PluginRegistrarWindows *registrar);
+  ~SystemAudioCapturePlugin();
+
+  // Disallow copy and assign.
+  SystemAudioCapturePlugin(const SystemAudioCapturePlugin&) = delete;
+  SystemAudioCapturePlugin& operator=(const SystemAudioCapturePlugin&) = delete;
+
+  void HandleMethodCall(
+      const flutter::MethodCall<flutter::EncodableValue> &method_call,
+      std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result);
+
+ private:
+  bool StartCapture(const flutter::EncodableMap* args);
+  bool StopCapture();
+  void CaptureThread();
+  void SetThreadPriority();
+  double CalculateDecibel(const int16_t* samples, size_t sample_count);
+  void ApplyGainBoostAndConvertToMono(const int16_t* input, int16_t* output,
+                                      size_t frame_count, int input_channels,
+                                      float gain_boost);
+  void SendStatusUpdate(bool is_active);
+  void SendDecibelUpdate(double decibel);
+
+  flutter::PluginRegistrarWindows* registrar_;
+  std::unique_ptr<flutter::MethodChannel<flutter::EncodableValue>> method_channel_;
+  std::unique_ptr<flutter::EventChannel<flutter::EncodableValue>> event_channel_;
+  std::unique_ptr<flutter::EventChannel<flutter::EncodableValue>> status_event_channel_;
+  std::unique_ptr<flutter::EventChannel<flutter::EncodableValue>> decibel_event_channel_;
+  
+  std::unique_ptr<flutter::EventSink<flutter::EncodableValue>> event_sink_;
+  std::unique_ptr<flutter::EventSink<flutter::EncodableValue>> status_event_sink_;
+  std::unique_ptr<flutter::EventSink<flutter::EncodableValue>> decibel_event_sink_;
+
+  std::mutex mutex_;
+  std::atomic<bool> is_capturing_;
+  std::atomic<bool> should_stop_;
+  std::thread capture_thread_;
+  
+  // Audio configuration
+  int sample_rate_;
+  int channels_;
+  int bits_per_sample_;
+  int chunk_duration_ms_;
+  float gain_boost_;
+  float input_volume_;
+  
+  // WASAPI interfaces
+  IAudioClient* audio_client_;
+  IAudioCaptureClient* capture_client_;
+  IMMDevice* device_;
+  WAVEFORMATEX* mix_format_;
+  UINT32 buffer_frame_count_;
+  bool com_initialized_;  // Track if we initialized COM
+};
+
+}  // namespace audio_capture
+
+#endif  // FLUTTER_PLUGIN_SYSTEM_AUDIO_CAPTURE_PLUGIN_H_
+

package/flutter_app/third_party/flutter_secure_storage_linux/linux/CMakeLists.txt

@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.10)
+set(PROJECT_NAME "flutter_secure_storage_linux")
+project(${PROJECT_NAME} LANGUAGES CXX)
+
+set(PLUGIN_NAME "flutter_secure_storage_linux_plugin")
+
+add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}")
+
+add_library(${PLUGIN_NAME} SHARED
+  "flutter_secure_storage_linux_plugin.cc"
+)
+
+apply_standard_settings(${PLUGIN_NAME})
+
+set_target_properties(${PLUGIN_NAME} PROPERTIES
+  CXX_VISIBILITY_PRESET hidden
+)
+
+target_compile_definitions(${PLUGIN_NAME} PRIVATE FLUTTER_PLUGIN_IMPL)
+target_include_directories(${PLUGIN_NAME} INTERFACE
+  "${CMAKE_CURRENT_SOURCE_DIR}/include"
+)
+
+target_link_libraries(${PLUGIN_NAME} PRIVATE flutter)
+target_link_libraries(${PLUGIN_NAME} PRIVATE PkgConfig::GTK)
+
+set(flutter_secure_storage_bundled_libraries
+  ""
+  PARENT_SCOPE
+)

package/flutter_app/third_party/flutter_secure_storage_linux/linux/flutter_secure_storage_linux_plugin.cc

@@ -0,0 +1,215 @@
+#include "include/flutter_secure_storage_linux/flutter_secure_storage_linux_plugin.h"
+
+#include <flutter_linux/flutter_linux.h>
+#include <glib.h>
+#include <gtk/gtk.h>
+
+#include <cstdio>
+#include <string>
+
+#define flutter_secure_storage_linux_plugin(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+                              flutter_secure_storage_linux_plugin_get_type(), \
+                              FlutterSecureStorageLinuxPlugin))
+
+namespace {
+
+constexpr const char *kChannelName =
+    "plugins.it_nomads.com/flutter_secure_storage";
+constexpr const char *kGroupName = "secure_storage";
+
+std::string GetStoragePath() {
+  const gchar *config_dir = g_get_user_config_dir();
+  gchar *directory = g_build_filename(config_dir, APPLICATION_ID, nullptr);
+  g_mkdir_with_parents(directory, 0700);
+  gchar *path = g_build_filename(directory, "flutter_secure_storage.ini", nullptr);
+  std::string result(path);
+  g_free(path);
+  g_free(directory);
+  return result;
+}
+
+GKeyFile *LoadKeyFile() {
+  GKeyFile *key_file = g_key_file_new();
+  const std::string path = GetStoragePath();
+  GError *error = nullptr;
+  g_key_file_load_from_file(
+      key_file,
+      path.c_str(),
+      static_cast<GKeyFileFlags>(G_KEY_FILE_KEEP_COMMENTS |
+                                 G_KEY_FILE_KEEP_TRANSLATIONS),
+      &error);
+  if (error != nullptr) {
+    g_error_free(error);
+  }
+  return key_file;
+}
+
+bool SaveKeyFile(GKeyFile *key_file, gchar **error_message) {
+  gsize length = 0;
+  GError *error = nullptr;
+  gchar *data = g_key_file_to_data(key_file, &length, &error);
+  if (error != nullptr) {
+    *error_message = g_strdup(error->message);
+    g_error_free(error);
+    return false;
+  }
+
+  const std::string path = GetStoragePath();
+  if (!g_file_set_contents(path.c_str(), data, static_cast<gssize>(length), &error)) {
+    *error_message = g_strdup(error->message);
+    g_error_free(error);
+    g_free(data);
+    return false;
+  }
+
+  g_free(data);
+  return true;
+}
+
+FlMethodResponse *BuildErrorResponse(const gchar *code, const gchar *message) {
+  return FL_METHOD_RESPONSE(
+      fl_method_error_response_new(code, message, nullptr));
+}
+
+}  // namespace
+
+struct _FlutterSecureStorageLinuxPlugin {
+  GObject parent_instance;
+};
+
+G_DEFINE_TYPE(FlutterSecureStorageLinuxPlugin,
+              flutter_secure_storage_linux_plugin,
+              g_object_get_type())
+
+static void flutter_secure_storage_linux_plugin_handle_method_call(
+    FlutterSecureStorageLinuxPlugin *self,
+    FlMethodCall *method_call) {
+  g_autoptr(FlMethodResponse) response = nullptr;
+
+  const gchar *method = fl_method_call_get_name(method_call);
+  FlValue *args = fl_method_call_get_args(method_call);
+
+  if (fl_value_get_type(args) != FL_VALUE_TYPE_MAP) {
+    response = BuildErrorResponse("Bad arguments",
+                                  "args given to function is not a map");
+    fl_method_call_respond(method_call, response, nullptr);
+    return;
+  }
+
+  FlValue *key = fl_value_lookup_string(args, "key");
+  FlValue *value = fl_value_lookup_string(args, "value");
+  const gchar *key_string = key == nullptr ? nullptr : fl_value_get_string(key);
+  const gchar *value_string =
+      value == nullptr ? nullptr : fl_value_get_string(value);
+
+  g_autoptr(GKeyFile) key_file = LoadKeyFile();
+
+  if (strcmp(method, "write") == 0) {
+    if (key_string == nullptr || value_string == nullptr) {
+      response = BuildErrorResponse("Bad arguments", "Key or Value was null");
+    } else {
+      g_key_file_set_string(key_file, kGroupName, key_string, value_string);
+      gchar *error_message = nullptr;
+      if (!SaveKeyFile(key_file, &error_message)) {
+        response = BuildErrorResponse("Storage error", error_message);
+        g_free(error_message);
+      } else {
+        response = FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
+      }
+    }
+  } else if (strcmp(method, "read") == 0) {
+    if (key_string == nullptr) {
+      response = BuildErrorResponse("Bad arguments", "Key is null");
+    } else if (!g_key_file_has_key(key_file, kGroupName, key_string, nullptr)) {
+      response = FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
+    } else {
+      gchar *stored_value = g_key_file_get_string(key_file, kGroupName, key_string, nullptr);
+      g_autoptr(FlValue) result = fl_value_new_string(stored_value);
+      g_free(stored_value);
+      response = FL_METHOD_RESPONSE(fl_method_success_response_new(result));
+    }
+  } else if (strcmp(method, "readAll") == 0) {
+    gsize key_count = 0;
+    g_auto(GStrv) keys = g_key_file_get_keys(key_file, kGroupName, &key_count, nullptr);
+    g_autoptr(FlValue) result = fl_value_new_map();
+    for (gsize i = 0; i < key_count; ++i) {
+      gchar *stored_value = g_key_file_get_string(key_file, kGroupName, keys[i], nullptr);
+      fl_value_set_string_take(result, keys[i], fl_value_new_string(stored_value));
+      g_free(stored_value);
+    }
+    response = FL_METHOD_RESPONSE(fl_method_success_response_new(result));
+  } else if (strcmp(method, "delete") == 0) {
+    if (key_string == nullptr) {
+      response = BuildErrorResponse("Bad arguments", "Key is null");
+    } else {
+      g_key_file_remove_key(key_file, kGroupName, key_string, nullptr);
+      gchar *error_message = nullptr;
+      if (!SaveKeyFile(key_file, &error_message)) {
+        response = BuildErrorResponse("Storage error", error_message);
+        g_free(error_message);
+      } else {
+        response = FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
+      }
+    }
+  } else if (strcmp(method, "deleteAll") == 0) {
+    g_key_file_remove_group(key_file, kGroupName, nullptr);
+    gchar *error_message = nullptr;
+    if (!SaveKeyFile(key_file, &error_message)) {
+      response = BuildErrorResponse("Storage error", error_message);
+      g_free(error_message);
+    } else {
+      response = FL_METHOD_RESPONSE(fl_method_success_response_new(nullptr));
+    }
+  } else if (strcmp(method, "containsKey") == 0) {
+    if (key_string == nullptr) {
+      response = BuildErrorResponse("Bad arguments", "Key is null");
+    } else {
+      g_autoptr(FlValue) result =
+          fl_value_new_bool(g_key_file_has_key(key_file, kGroupName, key_string, nullptr));
+      response = FL_METHOD_RESPONSE(fl_method_success_response_new(result));
+    }
+  } else {
+    response = FL_METHOD_RESPONSE(fl_method_not_implemented_response_new());
+  }
+
+  fl_method_call_respond(method_call, response, nullptr);
+}
+
+static void flutter_secure_storage_linux_plugin_dispose(GObject *object) {
+  G_OBJECT_CLASS(flutter_secure_storage_linux_plugin_parent_class)
+      ->dispose(object);
+}
+
+static void flutter_secure_storage_linux_plugin_class_init(
+    FlutterSecureStorageLinuxPluginClass *klass) {
+  G_OBJECT_CLASS(klass)->dispose =
+      flutter_secure_storage_linux_plugin_dispose;
+}
+
+static void flutter_secure_storage_linux_plugin_init(
+    FlutterSecureStorageLinuxPlugin *self) {}
+
+static void method_call_cb(FlMethodChannel *channel,
+                           FlMethodCall *method_call,
+                           gpointer user_data) {
+  FlutterSecureStorageLinuxPlugin *plugin =
+      flutter_secure_storage_linux_plugin(user_data);
+  flutter_secure_storage_linux_plugin_handle_method_call(plugin, method_call);
+}
+
+void flutter_secure_storage_linux_plugin_register_with_registrar(
+    FlPluginRegistrar *registrar) {
+  FlutterSecureStorageLinuxPlugin *plugin =
+      flutter_secure_storage_linux_plugin(
+          g_object_new(flutter_secure_storage_linux_plugin_get_type(), nullptr));
+
+  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
+  g_autoptr(FlMethodChannel) channel = fl_method_channel_new(
+      fl_plugin_registrar_get_messenger(registrar),
+      kChannelName,
+      FL_METHOD_CODEC(codec));
+  fl_method_channel_set_method_call_handler(
+      channel, method_call_cb, g_object_ref(plugin), g_object_unref);
+  g_object_unref(plugin);
+}

package/flutter_app/third_party/flutter_secure_storage_linux/linux/include/flutter_secure_storage_linux/flutter_secure_storage_linux_plugin.h

@@ -0,0 +1,27 @@
+#ifndef FLUTTER_PLUGIN_FLUTTER_SECURE_STORAGE_LINUX_PLUGIN_H_
+#define FLUTTER_PLUGIN_FLUTTER_SECURE_STORAGE_LINUX_PLUGIN_H_
+
+#include <flutter_linux/flutter_linux.h>
+
+G_BEGIN_DECLS
+
+#ifdef FLUTTER_PLUGIN_IMPL
+#define FLUTTER_PLUGIN_EXPORT __attribute__((visibility("default")))
+#else
+#define FLUTTER_PLUGIN_EXPORT
+#endif
+
+typedef struct _FlutterSecureStorageLinuxPlugin FlutterSecureStorageLinuxPlugin;
+typedef struct {
+  GObjectClass parent_class;
+} FlutterSecureStorageLinuxPluginClass;
+
+FLUTTER_PLUGIN_EXPORT GType flutter_secure_storage_linux_plugin_get_type();
+
+FLUTTER_PLUGIN_EXPORT void
+flutter_secure_storage_linux_plugin_register_with_registrar(
+    FlPluginRegistrar *registrar);
+
+G_END_DECLS
+
+#endif

package/flutter_app/third_party/flutter_secure_storage_linux/pubspec.yaml

@@ -0,0 +1,20 @@
+name: flutter_secure_storage_linux
+description: Local Linux implementation of flutter_secure_storage without libsecret.
+version: 1.2.3
+publish_to: none
+
+environment:
+  sdk: ">=3.0.0 <4.0.0"
+  flutter: ">=3.0.0"
+
+dependencies:
+  flutter:
+    sdk: flutter
+  flutter_secure_storage_platform_interface: ^1.1.2
+
+flutter:
+  plugin:
+    implements: flutter_secure_storage
+    platforms:
+      linux:
+        pluginClass: FlutterSecureStorageLinuxPlugin

package/flutter_app/tool/generate_desktop_branding.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import math
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFilter
+
+
+ROOT = Path(__file__).resolve().parents[1]
+BRANDING_DIR = ROOT / "assets" / "branding"
+WEB_DIR = ROOT / "web"
+WEB_ICONS_DIR = WEB_DIR / "icons"
+MAC_ICON_DIR = ROOT / "macos" / "Runner" / "Assets.xcassets" / "AppIcon.appiconset"
+WINDOWS_ICON_PATH = ROOT / "windows" / "runner" / "resources" / "app_icon.ico"
+LINUX_ICON_DIR = ROOT / "linux" / "runner" / "resources"
+ANDROID_RES_DIR = ROOT / "android" / "app" / "src" / "main" / "res"
+SERVER_PUBLIC_DIR = ROOT.parent / "server" / "public"
+SERVER_PUBLIC_ICONS_DIR = SERVER_PUBLIC_DIR / "icons"
+
+ACCENT = (143, 109, 62)
+ACCENT_ALT = (47, 125, 110)
+WHITE = (255, 255, 255, 255)
+TRANSPARENT = (0, 0, 0, 0)
+
+
+def lerp(a: float, b: float, t: float) -> float:
+    return a + (b - a) * t
+
+
+def gradient_background(size: int) -> Image.Image:
+    img = Image.new("RGBA", (size, size), TRANSPARENT)
+    px = img.load()
+    for y in range(size):
+      for x in range(size):
+        tx = x / max(size - 1, 1)
+        ty = y / max(size - 1, 1)
+        t = (tx + ty) / 2
+        px[x, y] = (
+            int(lerp(ACCENT[0], ACCENT_ALT[0], t)),
+            int(lerp(ACCENT[1], ACCENT_ALT[1], t)),
+            int(lerp(ACCENT[2], ACCENT_ALT[2], t)),
+            255,
+        )
+    return img
+
+
+def logo_paths(size: int, padding_ratio: float = 0.18):
+    pad = size * padding_ratio
+    inner = size - pad * 2
+    def point(x: float, y: float) -> tuple[float, float]:
+        return (pad + inner * x, pad + inner * y)
+
+    top = [point(0.5, 0.08), point(0.1, 0.3), point(0.5, 0.52), point(0.9, 0.3)]
+    middle = [point(0.1, 0.52), point(0.5, 0.74), point(0.9, 0.52)]
+    bottom = [point(0.1, 0.72), point(0.5, 0.94), point(0.9, 0.72)]
+    return top, middle, bottom, inner
+
+
+def draw_logo(draw: ImageDraw.ImageDraw, size: int, color: tuple[int, int, int, int]) -> None:
+    top, middle, bottom, inner = logo_paths(size)
+    stroke = max(2, round(inner * 0.08))
+    draw.polygon(top, fill=color)
+    draw.line(middle, fill=color, width=stroke, joint="curve")
+    draw.line(bottom, fill=color, width=stroke, joint="curve")
+
+
+def make_app_icon(size: int) -> Image.Image:
+    canvas = Image.new("RGBA", (size, size), TRANSPARENT)
+
+    shadow = Image.new("RGBA", (size, size), TRANSPARENT)
+    shadow_draw = ImageDraw.Draw(shadow)
+    offset_y = size * 0.02
+    corner = round(size * 0.34)
+    shadow_draw.rounded_rectangle(
+        (size * 0.07, size * 0.07 + offset_y, size * 0.93, size * 0.93 + offset_y),
+        radius=corner,
+        fill=(0, 0, 0, 72),
+    )
+    shadow = shadow.filter(ImageFilter.GaussianBlur(radius=max(2, size * 0.04)))
+    canvas.alpha_composite(shadow)
+
+    base_mask = Image.new("L", (size, size), 0)
+    mask_draw = ImageDraw.Draw(base_mask)
+    base_rect = (size * 0.08, size * 0.08, size * 0.92, size * 0.92)
+    mask_draw.rounded_rectangle(base_rect, radius=corner, fill=255)
+
+    base = gradient_background(size)
+    clipped = Image.new("RGBA", (size, size), TRANSPARENT)
+    clipped.paste(base, mask=base_mask)
+    canvas.alpha_composite(clipped)
+
+    ring = Image.new("RGBA", (size, size), TRANSPARENT)
+    ring_draw = ImageDraw.Draw(ring)
+    ring_draw.rounded_rectangle(
+        base_rect,
+        radius=corner,
+        outline=(255, 255, 255, 36),
+        width=max(1, round(size * 0.012)),
+    )
+    canvas.alpha_composite(ring)
+
+    glyph = Image.new("RGBA", (size, size), TRANSPARENT)
+    draw = ImageDraw.Draw(glyph)
+    draw_logo(draw, size, WHITE)
+    canvas.alpha_composite(glyph)
+    return canvas
+
+
+def make_tray_template(size: int = 64) -> Image.Image:
+    img = Image.new("RGBA", (size, size), TRANSPARENT)
+    draw = ImageDraw.Draw(img)
+    draw_logo(draw, size, (0, 0, 0, 255))
+    return img
+
+
+def ensure_dirs() -> None:
+    BRANDING_DIR.mkdir(parents=True, exist_ok=True)
+    WEB_ICONS_DIR.mkdir(parents=True, exist_ok=True)
+    MAC_ICON_DIR.mkdir(parents=True, exist_ok=True)
+    LINUX_ICON_DIR.mkdir(parents=True, exist_ok=True)
+    SERVER_PUBLIC_ICONS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def write_text(path: Path, content: str) -> None:
+    path.write_text(content, encoding="utf-8")
+
+
+def copy_png(image: Image.Image, path: Path, size: int) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    save_png(image, path, size)
+
+
+def write_favicon_svg(path: Path) -> None:
+    svg = f"""<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <defs>
+    <linearGradient id="bg" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#{ACCENT[0]:02x}{ACCENT[1]:02x}{ACCENT[2]:02x}"/>
+      <stop offset="100%" stop-color="#{ACCENT_ALT[0]:02x}{ACCENT_ALT[1]:02x}{ACCENT_ALT[2]:02x}"/>
+    </linearGradient>
+  </defs>
+  <rect x="2.5" y="2.5" width="27" height="27" rx="9" ry="9" fill="url(#bg)" stroke="#ffffff" stroke-opacity="0.16" stroke-width="1"/>
+  <polygon points="16,5.7 5.2,11.6 16,17.6 26.8,11.6" fill="white"/>
+  <polyline points="5.2,17.6 16,23.5 26.8,17.6" fill="none" stroke="white" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"/>
+  <polyline points="5.2,22.7 16,28.1 26.8,22.7" fill="none" stroke="white" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
+"""
+    write_text(path, svg)
+
+
+def save_png(image: Image.Image, path: Path, size: int) -> None:
+    image.resize((size, size), Image.Resampling.LANCZOS).save(path, format="PNG")
+
+
+def main() -> None:
+    ensure_dirs()
+    master = make_app_icon(1024)
+
+    save_png(master, BRANDING_DIR / "app_icon_1024.png", 1024)
+    save_png(master, BRANDING_DIR / "app_icon_512.png", 512)
+    save_png(master, BRANDING_DIR / "app_icon_256.png", 256)
+    save_png(master, BRANDING_DIR / "app_icon_192.png", 192)
+    save_png(master, BRANDING_DIR / "app_icon_128.png", 128)
+    save_png(master, BRANDING_DIR / "app_icon_64.png", 64)
+    save_png(master, BRANDING_DIR / "app_icon_32.png", 32)
+
+    tray = make_tray_template(64)
+    save_png(tray, BRANDING_DIR / "tray_icon_template.png", 64)
+
+    icon_sizes = {
+        16: "app_icon_16.png",
+        32: "app_icon_32.png",
+        64: "app_icon_64.png",
+        128: "app_icon_128.png",
+        256: "app_icon_256.png",
+        512: "app_icon_512.png",
+        1024: "app_icon_1024.png",
+    }
+    for size, filename in icon_sizes.items():
+        save_png(master, MAC_ICON_DIR / filename, size)
+
+    save_png(master, LINUX_ICON_DIR / "app_icon.png", 256)
+
+    master_for_ico = master.resize((256, 256), Image.Resampling.LANCZOS)
+    master_for_ico.save(
+        WINDOWS_ICON_PATH,
+        format="ICO",
+        sizes=[(16, 16), (24, 24), (32, 32), (48, 48), (64, 64), (128, 128), (256, 256)],
+    )
+
+    web_icon_sizes = {
+        192: "Icon-192.png",
+        512: "Icon-512.png",
+    }
+    for size, filename in web_icon_sizes.items():
+        copy_png(master, WEB_ICONS_DIR / filename, size)
+        copy_png(master, WEB_ICONS_DIR / filename.replace("Icon-", "Icon-maskable-"), size)
+        copy_png(master, SERVER_PUBLIC_ICONS_DIR / filename, size)
+        copy_png(master, SERVER_PUBLIC_ICONS_DIR / filename.replace("Icon-", "Icon-maskable-"), size)
+
+    copy_png(master, WEB_DIR / "favicon.png", 32)
+    copy_png(master, SERVER_PUBLIC_DIR / "favicon.png", 32)
+    write_favicon_svg(WEB_DIR / "favicon.svg")
+    write_favicon_svg(SERVER_PUBLIC_DIR / "favicon.svg")
+
+    android_icon_sizes = {
+        "mipmap-mdpi": 48,
+        "mipmap-hdpi": 72,
+        "mipmap-xhdpi": 96,
+        "mipmap-xxhdpi": 144,
+        "mipmap-xxxhdpi": 192,
+    }
+    for folder, size in android_icon_sizes.items():
+        copy_png(master, ANDROID_RES_DIR / folder / "ic_launcher.png", size)
+
+
+if __name__ == "__main__":
+    main()

package/flutter_app/web/favicon.svg

@@ -0,0 +1,12 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <defs>
+    <linearGradient id="bg" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#8f6d3e"/>
+      <stop offset="100%" stop-color="#2f7d6e"/>
+    </linearGradient>
+  </defs>
+  <rect x="2.5" y="2.5" width="27" height="27" rx="9" ry="9" fill="url(#bg)" stroke="#ffffff" stroke-opacity="0.16" stroke-width="1"/>
+  <polygon points="16,5.7 5.2,11.6 16,17.6 26.8,11.6" fill="white"/>
+  <polyline points="5.2,17.6 16,23.5 26.8,17.6" fill="none" stroke="white" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"/>
+  <polyline points="5.2,22.7 16,28.1 26.8,22.7" fill="none" stroke="white" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

package/flutter_app/web/index.html

@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <!--
+    If you are serving your web app in a path other than the root, change the
+    href value below to reflect the base path you are serving from.
+
+    The path provided below has to start and end with a slash "/" in order for
+    it to work correctly.
+
+    For more details:
+    * https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base
+
+    This is a placeholder for base href that will be replaced by the value of
+    the `--base-href` argument provided to `flutter build`.
+  -->
+  <base href="$FLUTTER_BASE_HREF">
+
+  <meta charset="UTF-8">
+  <meta content="IE=Edge" http-equiv="X-UA-Compatible">
+  <meta name="description" content="NeoAgent Flutter client for web and Android.">
+
+  <!-- iOS meta tags & icons -->
+  <meta name="mobile-web-app-capable" content="yes">
+  <meta name="apple-mobile-web-app-status-bar-style" content="black">
+  <meta name="apple-mobile-web-app-title" content="NeoAgent">
+  <link rel="apple-touch-icon" href="icons/Icon-192.png">
+
+  <!-- Favicon -->
+  <link rel="icon" type="image/svg+xml" href="favicon.svg"/>
+  <link rel="icon" type="image/png" href="favicon.png"/>
+
+  <title>NeoAgent</title>
+  <link rel="manifest" href="manifest.json">
+</head>
+<body>
+  <script src="flutter_bootstrap.js" async></script>
+</body>
+</html>