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

package/vendor/node_modules/@legendapp/spark-clipboard/src/desktop.ts

@@ -1,39 +1,63 @@
 import { Platform } from "react-native";
+import { callBinary, nativeBytes } from "@legendapp/spark-desktop-app/src/contracts/native-buffer";
+import { SparkError, parseNativeResult, invokeNative, type Availability } from "@legendapp/spark-desktop-app/src/contracts";
+import { nativePath } from "@legendapp/spark-desktop-app/src/contracts/path";
 import Native from "./NativeDesktopClipboard";
-async function call<T = void>(method: string, args: object = {}): Promise<T> { return JSON.parse(await Native.call(method, JSON.stringify(args))) as T; }
-export const readClipboardText = () => call<string>("readText");
-export const writeClipboardText = (text: string) => call("writeText", { text });
-export const hasClipboardText = () => call<boolean>("hasText");
-
-export type ClipboardContent = { text?: string; html?: string; rtf?: string; imagePNG?: string; files?: string[] };
-/** imagePNG contains base64-encoded PNG bytes. */
-export async function readClipboard(): Promise<ClipboardContent> { return JSON.parse(await Native.call("read", "{}")); }
-export async function getClipboardFormats(): Promise<string[]> { return JSON.parse(await Native.call("formats", "{}")); }
-export async function clearClipboard() { await Native.call("clear", "{}"); }
-export async function writeClipboard(content: ClipboardContent) {
-  for (const key of Object.keys(content)) if (!["text", "html", "rtf", "imagePNG", "files"].includes(key)) throw new Error(`Unknown clipboard format: ${key}`);
-  if (content.files && (Object.keys(content).length !== 1 || content.files.some(file => Platform.OS === "windows" ? !/^(?:[a-z]:[\\/]|\\\\[^\\/]+[\\/][^\\/]+)/i.test(file) : !file.startsWith("/")))) throw new Error("Files must be absolute paths and written separately from other formats");
-  for (const key of ["text", "html", "rtf", "imagePNG"] as const) if (content[key] !== undefined && typeof content[key] !== "string") throw new Error(`Invalid clipboard ${key}`);
-  await Native.call("write", JSON.stringify(content));
-}
-
-import { StringFormat } from "./formats";
+import { stringOptions } from "./options";
+import type { ClipboardContent, ClipboardWriteContent, GetStringOptions, SetStringOptions } from "./types";
 export { StringFormat } from "./formats";
-export type GetStringOptions = { preferredFormat?: StringFormat };
-export type SetStringOptions = { inputFormat?: StringFormat };
-function stringOptions(options: object, key: string) {
-  if (!options || Object.keys(options).some(name => name !== key)) throw new Error("Unsupported clipboard option");
-  const format = (options as Record<string, unknown>)[key] ?? StringFormat.PLAIN_TEXT;
-  if (format !== StringFormat.PLAIN_TEXT && format !== StringFormat.HTML) throw new Error("Invalid clipboard string format");
-  return format;
+export type { ClipboardContent, ClipboardWriteContent, ClipboardImage, GetStringOptions, SetStringOptions } from "./types";
+export function getRichClipboardAvailability(): Availability {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") return { available: false, reason: "unsupported-platform" };
+  return Native ? { available: true } : { available: false, reason: "missing-module" };
+}
+function native() {
+  const availability = getRichClipboardAvailability();
+  if (!availability.available) throw new SparkError(availability.reason === "unsupported-platform" ? "E_UNSUPPORTED_PLATFORM" : "E_MODULE_UNAVAILABLE", "Desktop clipboard module is unavailable");
+  return Native!;
+}
+async function call<T>(method: string, args: object, validate: (value: unknown) => value is T): Promise<T> {
+  return parseNativeResult(await invokeNative(() => native().call(method, JSON.stringify(args))), validate);
 }
-/** Expo-compatible text/HTML subset. Rich desktop formats remain available above. */
+const isVoid = (value: unknown): value is null => value === null;
+const isBoolean = (value: unknown): value is boolean => typeof value === "boolean";
+/** Expo-compatible text/HTML subset. */
 export async function getStringAsync(options: GetStringOptions = {}): Promise<string> {
-  return call("getString", { format: stringOptions(options, "preferredFormat") });
+  return call("getString", { format: stringOptions(options, "preferredFormat") }, (value): value is string => typeof value === "string");
 }
 export async function setStringAsync(text: string, options: SetStringOptions = {}): Promise<boolean> {
-  if (typeof text !== "string") throw new TypeError("Clipboard text must be a string");
-  await call("setString", { text, format: stringOptions(options, "inputFormat") });
-  return true;
+  if (typeof text !== "string") throw new SparkError("E_INVALID_ARGUMENT", "Clipboard text must be a string");
+  return call("setString", { text, format: stringOptions(options, "inputFormat") }, isBoolean);
+}
+export async function hasStringAsync(): Promise<boolean> { return call("hasString", {}, (value): value is boolean => typeof value === "boolean"); }
+export async function readClipboard(): Promise<ClipboardContent> {
+  const raw = await invokeNative(() => callBinary(native(), "__sparkClipboardBinary", "read", {})) as Record<string, unknown>;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new SparkError("E_INVALID_DATA", "Invalid clipboard content");
+  const result: ClipboardContent = {};
+  for (const key of ["text", "html", "rtf"] as const) {
+    if (raw[key] !== undefined && typeof raw[key] !== "string") throw new SparkError("E_INVALID_DATA", `Invalid clipboard ${key}`);
+    if (typeof raw[key] === "string") result[key] = raw[key];
+  }
+  if (raw.files !== undefined) {
+    if (!Array.isArray(raw.files) || raw.files.some(value => typeof value !== "string")) throw new SparkError("E_INVALID_DATA", "Invalid clipboard files");
+    try { result.files = raw.files.map(value => nativePath(value, Platform.OS)); }
+    catch (cause) { throw new SparkError("E_INVALID_DATA", "Invalid clipboard file paths", { cause }); }
+  }
+  if (raw.imagePNG !== undefined) {
+    result.image = { format: "png", bytes: nativeBytes(raw.imagePNG) };
+  }
+  return result;
+}
+export async function getClipboardFormats(): Promise<string[]> { return call("formats", {}, (value): value is string[] => Array.isArray(value) && value.every(format => typeof format === "string")); }
+export async function clearClipboard(): Promise<void> { await call("clear", {}, isVoid); }
+export async function writeClipboard(content: ClipboardWriteContent): Promise<void> {
+  if (!content || typeof content !== "object" || Array.isArray(content)) throw new SparkError("E_INVALID_ARGUMENT", "Expected clipboard content");
+  for (const key of Object.keys(content)) if (!["text", "html", "rtf", "image", "files"].includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown clipboard format: ${key}`);
+  for (const key of ["text", "html", "rtf"] as const) if (content[key] !== undefined && typeof content[key] !== "string") throw new SparkError("E_INVALID_ARGUMENT", `Invalid clipboard ${key}`);
+  if (content.files !== undefined && (!Array.isArray(content.files) || Object.entries(content).some(([key, value]) => key !== "files" && value !== undefined))) throw new SparkError("E_INVALID_ARGUMENT", "Files must be written separately from other formats");
+  const files = content.files?.map(path => nativePath(path, Platform.OS));
+  const { image, ...rest } = content;
+  if (image !== undefined && (!image || image.format !== "png" || !(image.bytes instanceof Uint8Array))) throw new SparkError("E_INVALID_ARGUMENT", "Expected PNG image bytes");
+  const response = await invokeNative(() => callBinary(native(), "__sparkClipboardBinary", "write", { ...rest, files }, image?.bytes));
+  if (response !== null) throw new SparkError("E_INVALID_DATA", "Invalid native clipboard response");
 }
-export const hasStringAsync = (): Promise<boolean> => call("hasString");

package/vendor/node_modules/@legendapp/spark-clipboard/src/expo.ts

@@ -1,12 +1,22 @@
 import * as Clipboard from "expo-clipboard";
-export { getStringAsync, setStringAsync, hasStringAsync, StringFormat } from "expo-clipboard";
-export type { GetStringOptions, SetStringOptions } from "expo-clipboard";
-export type { ClipboardContent } from "./index";
-export const readClipboardText = Clipboard.getStringAsync;
-export async function writeClipboardText(text: string): Promise<void> { await Clipboard.setStringAsync(text); }
-export const hasClipboardText = Clipboard.hasStringAsync;
-const unavailable = async (..._args: unknown[]): Promise<never> => { throw Object.assign(new Error("Rich desktop clipboard operations are unavailable on this platform"), { code: "E_UNAVAILABLE" }); };
-export const readClipboard = unavailable;
-export const getClipboardFormats = unavailable;
-export const clearClipboard = unavailable;
-export const writeClipboard = unavailable;
+import { SparkError, type Availability } from "@legendapp/spark-desktop-app/src/contracts";
+import { StringFormat } from "./formats";
+import { stringOptions } from "./options";
+import type { ClipboardContent, ClipboardWriteContent, GetStringOptions, SetStringOptions } from "./types";
+export { StringFormat } from "./formats";
+export type { ClipboardContent, ClipboardWriteContent, ClipboardImage, GetStringOptions, SetStringOptions } from "./types";
+export async function getStringAsync(options: GetStringOptions = {}): Promise<string> {
+  const format = stringOptions(options, "preferredFormat");
+  return Clipboard.getStringAsync({ preferredFormat: format === StringFormat.HTML ? Clipboard.StringFormat.HTML : Clipboard.StringFormat.PLAIN_TEXT });
+}
+export async function setStringAsync(text: string, options: SetStringOptions = {}): Promise<boolean> {
+  const format = stringOptions(options, "inputFormat");
+  return Clipboard.setStringAsync(text, { inputFormat: format === StringFormat.HTML ? Clipboard.StringFormat.HTML : Clipboard.StringFormat.PLAIN_TEXT });
+}
+export const hasStringAsync = Clipboard.hasStringAsync;
+export function getRichClipboardAvailability(): Availability { return { available: false, reason: "unsupported-platform" }; }
+function unavailable(): never { throw new SparkError("E_UNSUPPORTED_PLATFORM", "Rich clipboard operations require a desktop host"); }
+export async function readClipboard(): Promise<ClipboardContent> { return unavailable(); }
+export async function getClipboardFormats(): Promise<string[]> { return unavailable(); }
+export async function clearClipboard(): Promise<void> { return unavailable(); }
+export async function writeClipboard(_content: ClipboardWriteContent): Promise<void> { return unavailable(); }

package/vendor/node_modules/@legendapp/spark-clipboard/src/options.ts

@@ -0,0 +1,8 @@
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import { StringFormat } from "./formats";
+export function stringOptions(options: object, key: string): StringFormat {
+  if (!options || typeof options !== "object" || Object.keys(options).some(name => name !== key)) throw new SparkError("E_UNSUPPORTED_OPTION", "Unsupported clipboard option");
+  const format = (options as Record<string, unknown>)[key] ?? StringFormat.PLAIN_TEXT;
+  if (format !== StringFormat.PLAIN_TEXT && format !== StringFormat.HTML) throw new SparkError("E_INVALID_ARGUMENT", "Invalid clipboard string format");
+  return format;
+}

package/vendor/node_modules/@legendapp/spark-clipboard/src/types.ts

@@ -0,0 +1,10 @@
+import type { StringFormat } from "./formats";
+export type GetStringOptions = { preferredFormat?: StringFormat };
+export type SetStringOptions = { inputFormat?: StringFormat };
+export interface ClipboardImage { format: "png"; bytes: Uint8Array }
+/** Reading preserves all OS representations, which can coexist. */
+export interface ClipboardContent { text?: string; html?: string; rtf?: string; image?: ClipboardImage; files?: readonly string[] }
+/** File lists must be written separately from text/image representations. */
+export type ClipboardWriteContent =
+  | { files: readonly string[]; text?: never; html?: never; rtf?: never; image?: never }
+  | { files?: never; text?: string; html?: string; rtf?: string; image?: ClipboardImage };

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