@legendapp/spark 0.0.1-next.2 → 0.0.1-next.4

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard/SparkClipboard.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "NativeModules.h"
+#include <SparkBinaryWindows.hpp>
 #include <winrt/Windows.ApplicationModel.DataTransfer.h>
 #include <winrt/Windows.Data.Json.h>
 #include <winrt/Windows.Data.Html.h>
@@ -35,14 +36,21 @@ inline hstring HTML(hstring const &text) {
   for (auto c : text) { switch(c) { case L'&': value += L"&amp;"; break; case L'<': value += L"&lt;"; break; case L'>': value += L"&gt;"; break; case L'\n': value += L"<br>"; break; default: value += c; } }
   return hstring(value + L"</div>");
 }
+class ClipboardBytes final : public spark::binary::jsi::MutableBuffer {
+  com_array<uint8_t> bytes;
+public:
+  explicit ClipboardBytes(com_array<uint8_t> value) : bytes(std::move(value)) {}
+  size_t size() const override { return bytes.size(); }
+  uint8_t *data() override { return bytes.data(); }
+};
 REACT_MODULE(SparkClipboard, L"NativeDesktopClipboard")
 struct SparkClipboard {
   React::ReactContext context;
   REACT_INIT(Initialize) void Initialize(React::ReactContext const &value) noexcept { context = value; }
-  static fire_and_forget Invoke(std::string method, std::string encoded, React::ReactPromise<std::string> promise) {
+  static fire_and_forget Invoke(std::string method, std::string encoded, spark::binary::NativePromise promise, std::optional<std::vector<uint8_t>> input = {}, bool binary = false) {
     try {
       auto args = Json::JsonObject::Parse(to_hstring(encoded));
-      if (method == "write" || method == "setString" || method == "writeText") {
+      if (method == "write" || method == "setString") {
         if (method != "write") {
           Json::JsonObject content; content.SetNamedValue(args.GetNamedString(L"format", L"plainText") == L"html" ? L"html" : L"text", args.GetNamedValue(L"text")); args = content;
         }
@@ -62,34 +70,38 @@ struct SparkClipboard {
           }
           data.SetStorageItems(items); data.RequestedOperation(Transfer::DataPackageOperation::Copy);
         }
-        if (args.HasKey(L"imagePNG")) {
-          auto bytes = CryptographicBuffer::DecodeFromBase64String(args.GetNamedString(L"imagePNG"));
+        if (input) {
+          auto bytes = CryptographicBuffer::CreateFromByteArray(*input);
           Streams::InMemoryRandomAccessStream stream; co_await stream.WriteAsync(bytes); stream.Seek(0);
           auto decoder = co_await Imaging::BitmapDecoder::CreateAsync(stream);
           if (decoder.DecoderInformation().CodecId() != Imaging::BitmapDecoder::PngDecoderId()) throw hresult_invalid_argument(L"Clipboard image must be PNG");
           data.SetBitmap(Streams::RandomAccessStreamReference::CreateFromStream(stream));
         }
-        if (args.Size() == 0) Transfer::Clipboard::Clear();
-        else { Transfer::Clipboard::SetContent(data); Transfer::Clipboard::Flush(); }
-        promise.Resolve("null");
+        bool written = true;
+        // The image is carried separately from the JSON metadata. An image-only
+        // write therefore has an empty object but is still non-empty content.
+        if (args.Size() == 0 && !input) Transfer::Clipboard::Clear();
+        else { Transfer::Clipboard::SetContent(data); written = Transfer::Clipboard::Flush(); }
+        // setString mirrors Expo's boolean result; write keeps reporting failure by exception only.
+        promise.Resolve(method == "setString" ? (written ? "true" : "false") : "null");
       } else if (method == "clear") { Transfer::Clipboard::Clear(); promise.Resolve("null"); }
       else {
         auto data = Transfer::Clipboard::GetContent();
         const bool text = data.Contains(Transfer::StandardDataFormats::Text()), html = data.Contains(Transfer::StandardDataFormats::Html()), rtf = data.Contains(Transfer::StandardDataFormats::Rtf());
-        if (method == "hasString" || method == "hasText") promise.Resolve((text || (method == "hasString" && (html || rtf))) ? "true" : "false");
+        if (method == "hasString") promise.Resolve((text || html || rtf) ? "true" : "false");
         else if (method == "formats") { Json::JsonArray formats; for (auto const &format : data.AvailableFormats()) formats.Append(Json::JsonValue::CreateStringValue(format)); promise.Resolve(to_string(formats.Stringify())); }
-        else if (method == "getString" || method == "readText") {
+        else if (method == "getString") {
           hstring value; const bool preferHTML = args.GetNamedString(L"format", L"plainText") == L"html";
-          if (method == "getString" && preferHTML && html) value = Transfer::HtmlFormatHelper::GetStaticFragment(co_await data.GetHtmlFormatAsync());
+          if (preferHTML && html) value = Transfer::HtmlFormatHelper::GetStaticFragment(co_await data.GetHtmlFormatAsync());
           else {
             if (text) value = co_await data.GetTextAsync();
-            else if (method == "getString" && html) value = Windows::Data::Html::HtmlUtilities::ConvertToText(Transfer::HtmlFormatHelper::GetStaticFragment(co_await data.GetHtmlFormatAsync()));
-            else if (method == "getString" && rtf) value = PlainRTF(co_await data.GetRtfAsync());
+            else if (html) value = Windows::Data::Html::HtmlUtilities::ConvertToText(Transfer::HtmlFormatHelper::GetStaticFragment(co_await data.GetHtmlFormatAsync()));
+            else if (rtf) value = PlainRTF(co_await data.GetRtfAsync());
             if (preferHTML && !value.empty()) value = HTML(value);
           }
           promise.Resolve(to_string(Json::JsonValue::CreateStringValue(value).Stringify()));
         } else if (method == "read") {
-          Json::JsonObject result;
+          Json::JsonObject result; std::shared_ptr<ClipboardBytes> image;
           if (text) result.SetNamedValue(L"text", Json::JsonValue::CreateStringValue(co_await data.GetTextAsync()));
           if (html) result.SetNamedValue(L"html", Json::JsonValue::CreateStringValue(Transfer::HtmlFormatHelper::GetStaticFragment(co_await data.GetHtmlFormatAsync())));
           if (rtf) result.SetNamedValue(L"rtf", Json::JsonValue::CreateStringValue(co_await data.GetRtfAsync()));
@@ -105,13 +117,24 @@ struct SparkClipboard {
             encoder.SetSoftwareBitmap(bitmap); co_await encoder.FlushAsync(); output.Seek(0);
             if (output.Size() > UINT32_MAX) throw hresult_invalid_argument(L"Clipboard image is too large");
             Streams::Buffer bytes(static_cast<uint32_t>(output.Size())); auto read = co_await output.ReadAsync(bytes, bytes.Capacity(), Streams::InputStreamOptions::None);
-            result.SetNamedValue(L"imagePNG", Json::JsonValue::CreateStringValue(CryptographicBuffer::EncodeToBase64String(read)));
+            com_array<uint8_t> owned; CryptographicBuffer::CopyToByteArray(read, owned); image = std::make_shared<ClipboardBytes>(std::move(owned));
           }
-          promise.Resolve(to_string(result.Stringify()));
+          spark::binary::Response response{to_string(result.Stringify()), {}, {}}; if (image) response.fields["imagePNG"] = image; promise.Resolve(std::move(response));
         } else throw hresult_invalid_argument(L"Unsupported Windows clipboard operation");
       }
     } catch (hresult_error const &error) { promise.Reject(React::ReactError{"E_CLIPBOARD", to_string(error.message())}); }
   }
+  REACT_SYNC_METHOD(installBinary) std::optional<std::string> installBinary() noexcept {
+    try {
+    spark::binary::Install(context, "__sparkClipboardBinary", [context = context](std::string method, std::string encoded, std::optional<std::vector<uint8_t>> bytes, spark::binary::Completion finish) {
+      context.UIDispatcher().Post([method = std::move(method), encoded = std::move(encoded), bytes = std::move(bytes), promise = spark::binary::NativePromise(finish)]() mutable { Invoke(std::move(method), std::move(encoded), promise, std::move(bytes), true); });
+    });
+      return std::nullopt;
+    } catch (std::exception const &error) { return error.what(); }
+    catch (hresult_error const &error) { return to_string(error.message()); }
+    catch (...) { return "Could not install native binary transport"; }
+  }
+
   REACT_METHOD(call) void call(std::string method, std::string args, React::ReactPromise<std::string> promise) noexcept {
     context.UIDispatcher().Post([method = std::move(method), args = std::move(args), promise]() { Invoke(method, args, promise); });
   }

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard/SparkClipboard.vcxproj

@@ -80,6 +80,8 @@
       <PreprocessorDefinitions>_WINRT_DLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
       <AdditionalIncludeDirectories>
+        $(MSBuildThisFileDirectory)..\..\..\spark-desktop-app\cpp;
+        $(MSBuildThisFileDirectory)..\..\..\desktop-app\cpp;
         $(MSBuildThisFileDirectory);
         %(AdditionalIncludeDirectories)
       </AdditionalIncludeDirectories>

package/vendor/node_modules/@legendapp/spark-codex/RNCodex.podspec

@@ -0,0 +1,22 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name = "RNCodex"
+  s.version = package["version"]
+  s.summary = "Per-app Codex app-server client"
+  s.license = { :type => "MIT" }
+  s.author = "Legend"
+  s.homepage = "https://legendapp.com"
+  s.source = { :path => "." }
+  s.platforms = { :osx => "14.0" }
+  s.source_files = "cpp/**/*.{h,hpp,cpp,mm}"
+  s.pod_target_xcconfig = {
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+  }
+  s.frameworks = "Foundation"
+  s.dependency "React-Core"
+  load "nitrogen/generated/ios/RNCodex+autolinking.rb"
+  add_nitrogen_files(s)
+end

package/vendor/node_modules/@legendapp/spark-codex/cpp/HybridCodexAppServer.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "../nitrogen/generated/shared/c++/HybridCodexAppServerSpec.hpp"
+
+namespace margelo::nitro::legendapps::codex {
+
+class HybridCodexAppServer final : public HybridCodexAppServerSpec {
+public:
+  HybridCodexAppServer();
+
+  std::shared_ptr<Promise<CodexAvailability>> getAvailability() override;
+  std::shared_ptr<Promise<CodexRunResult>> runPrompt(
+      const std::string& prompt,
+      const std::string& cwd,
+      const std::string& reasoningEffort,
+      double timeoutMs,
+      const std::string& outputSchemaJson,
+      const std::string& developerInstructions) override;
+  double cancelActiveRuns() override;
+  double shutdown() override;
+};
+
+} // namespace margelo::nitro::legendapps::codex