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

package/vendor/node_modules/@legendapp/spark-processes/src/index.ts

@@ -1,39 +1,135 @@
 import { Platform } from "react-native";
+import { callBinary, nativeBytes } from "@legendapp/spark-desktop-app/src/contracts/native-buffer";
 import Native from "./NativeDesktopProcesses";
-import { onDesktopEvent } from "@legendapp/spark-desktop-app";
-export type ProcessOptions = { executable: string; args?: string[]; cwd?: string; env?: Record<string, string>; timeoutMs?: number; input?: string };
-export type ProcessOutput = { stream: "stdout" | "stderr"; base64: string };
-export type ProcessResult = { exitCode: number; signal: boolean; stdout: string; stderr: string; stdoutBase64: string; stderrBase64: string; timedOut: boolean; outputTruncated: boolean };
+import { onDesktopEvent } from "@legendapp/spark-desktop-app/src/events";
+import { SparkError, invokeNative, nativeError, type Availability } from "@legendapp/spark-desktop-app/src/contracts";
+import { nativePath } from "@legendapp/spark-desktop-app/src/contracts/path";
+import type { ProcessOptions, RunCommandOptions, ProcessInput, ProcessResult, ProcessHandle } from "./types";
+export type * from "./types";
+export function getProcessAvailability(): Availability {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") return { available: false, reason: "unsupported-platform" };
+  return Native ? { available: true } : { available: false, reason: "missing-module" };
+}
+async function call<T>(method: string, args: object, validate: (value: unknown) => value is T): Promise<T> {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") throw new SparkError("E_UNSUPPORTED_PLATFORM", "Processes require a desktop host");
+  if (!Native) throw new SparkError("E_MODULE_UNAVAILABLE", "Process module is unavailable");
+  const { bytes, ...metadata } = args as { bytes?: Uint8Array };
+  const value = await invokeNative(() => callBinary(Native!, "__sparkProcessesBinary", method, metadata, bytes));
+  if (!validate(value)) throw new SparkError("E_INVALID_DATA", "Invalid native process response");
+  return value;
+}
+const command = (method: string, args: object) => call(method, args, (value): value is null => value === null).then(() => {});
+function invalid(message: string): never { throw new SparkError("E_INVALID_ARGUMENT", message); }
+function object(value: unknown, allowed: string[]): asserts value is Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) invalid("Expected process options");
+  for (const key of Object.keys(value)) if (!allowed.includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown process option: ${key}`);
+}
+function commandName(value: unknown): asserts value is string {
+  if (typeof value !== "string" || !value || /[\\/\0:]/.test(value) || value === "." || value === ".." || value.trim() !== value) invalid("Expected a command name without path components");
+}
+export async function resolveCommand(name: string): Promise<string | null> {
+  commandName(name);
+  const value = await call("resolveCommand", { command: name }, (value): value is string | null => value === null || typeof value === "string");
+  if (value === null) return null;
+  try { return nativePath(value, Platform.OS); } catch (cause) { throw new SparkError("E_INVALID_DATA", "Resolved command path is invalid", { cause }); }
+}
+function inputBytes(input: ProcessInput): Uint8Array {
+  if (typeof input === "string") return new TextEncoder().encode(input);
+  if (!(input instanceof Uint8Array)) invalid("Process input must be UTF-8 text or Uint8Array");
+  return input;
+}
+function result(value: unknown, aborted: boolean, limit: number): ProcessResult {
+  if (!value || typeof value !== "object") throw new SparkError("E_INVALID_DATA", "Invalid process exit result");
+  const data = value as Record<string, unknown>;
+  if (!Number.isInteger(data.exitCode) || (data.exitCode as number) < 0 || (data.exitCode as number) > 0xffffffff || typeof data.terminated !== "boolean" || !(data.terminationSignal === null || (Number.isInteger(data.terminationSignal) && (data.terminationSignal as number) > 0)) || (!data.terminated && data.terminationSignal !== null) || typeof data.timedOut !== "boolean" || typeof data.outputTruncated !== "boolean") throw new SparkError("E_INVALID_DATA", "Invalid process exit status");
+  return { exit: data.terminated ? { type: "terminated", signal: data.terminationSignal as number | null } : { type: "exited", code: data.exitCode as number }, stdout: nativeBytes(data.stdout, limit), stderr: nativeBytes(data.stderr, limit), timedOut: data.timedOut, outputTruncated: data.outputTruncated, aborted };
+}
 let sequence = 0;
-function absolute(value: string) { return Platform.OS === "windows" ? /^(?:[a-z]:[\\/]|\\\\[^\\/]+[\\/][^\\/]+)/i.test(value) : value.startsWith("/"); }
-export async function spawn(options: ProcessOptions, onOutput?: (chunk: ProcessOutput) => void) {
-  if (typeof options.executable !== "string" || (options.executable.startsWith("helper:") && !/^helper:[A-Za-z0-9_-]+$/.test(options.executable))) throw new Error("Invalid helper name or executable");
-  if (options.input !== undefined && typeof options.input !== "string") throw new Error("input must be a string");
-  if (!absolute(options.executable) && !options.executable.startsWith("helper:")) throw new Error("executable must be an absolute path or helper:name");
-  if (options.executable.includes("\0") || options.args?.some(arg => typeof arg !== "string" || arg.includes("\0"))) throw new Error("Invalid process arguments");
-  if (options.cwd !== undefined && (!absolute(options.cwd) || options.cwd.includes("\0"))) throw new Error("cwd must be absolute");
-  if (options.env && Object.entries(options.env).some(([key, value]) => !key || /[=\0]/.test(key) || typeof value !== "string" || value.includes("\0"))) throw new Error("Invalid process environment");
-  if (options.timeoutMs !== undefined && (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 1)) throw new Error("timeoutMs must be positive");
+export async function spawn(options: ProcessOptions): Promise<ProcessHandle> {
+  object(options, ["target", "args", "cwd", "env", "input", "timeoutMs", "signal", "captureLimitBytes", "onOutput"]);
+  object(options.target, ["type", "path", "name"]);
+  const { target, signal, onOutput } = options;
+  let executable: string;
+  if (target.type === "executable") { object(target, ["type", "path"]); executable = nativePath(target.path, Platform.OS); }
+  else if (target.type === "helper") { object(target, ["type", "name"]); if (typeof target.name !== "string" || !/^[A-Za-z0-9_-]+$/.test(target.name)) invalid("Invalid helper name"); executable = `helper:${target.name}`; }
+  else if (target.type === "command") { object(target, ["type", "name"]); commandName(target.name); executable = target.name; }
+  else invalid("Unknown process target type");
+  if (options.args !== undefined && (!Array.isArray(options.args) || options.args.some(arg => typeof arg !== "string" || arg.includes("\0")))) invalid("Invalid process arguments");
+  const cwd = options.cwd === undefined ? undefined : nativePath(options.cwd, Platform.OS);
+  if (options.env !== undefined) {
+    if (!options.env || typeof options.env !== "object" || Array.isArray(options.env) || Object.entries(options.env).some(([key, value]) => !key || /[=\0]/.test(key) || typeof value !== "string" || value.includes("\0"))) invalid("Invalid process environment");
+  }
+  if (options.timeoutMs !== undefined && (!Number.isInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 0xfffffffe)) invalid("timeoutMs must be an integer from 1 to 4294967294");
+  const captureLimitBytes = options.captureLimitBytes ?? 8 * 1024 * 1024;
+  if (!Number.isInteger(captureLimitBytes) || captureLimitBytes < 0 || captureLimitBytes > 8 * 1024 * 1024) invalid("captureLimitBytes must be an integer from 0 to 8388608");
+  if (onOutput !== undefined && typeof onOutput !== "function") invalid("onOutput must be a function");
+  if (signal !== undefined && (!signal || typeof signal.aborted !== "boolean" || typeof signal.addEventListener !== "function" || typeof signal.removeEventListener !== "function")) invalid("Expected an AbortSignal");
+  const wire = { executable, command: target.type === "command", args: options.args ?? [], cwd, env: options.env ?? {}, bytes: options.input === undefined ? undefined : inputBytes(options.input), timeoutMs: options.timeoutMs, captureLimitBytes, streamOutput: !!onOutput };
+  if (signal?.aborted) throw new SparkError("E_ABORTED", "Process launch was aborted");
+  const availability = getProcessAvailability();
+  if (!availability.available) throw new SparkError(availability.reason === "missing-module" ? "E_MODULE_UNAVAILABLE" : "E_UNSUPPORTED_PLATFORM", "Process execution is unavailable");
   const id = `process-${Date.now()}-${++sequence}`;
-  let finish!: (value: ProcessResult) => void;
-  let ended = false;
-  const exited = new Promise<ProcessResult>(resolve => { finish = resolve; });
+  let finish!: (value: ProcessResult) => void, fail!: (error: unknown) => void;
+  let ended = false, aborted = false, started = false, inputClosing = false, outputStopped = false;
+  let closingInput: Promise<void> | undefined, terminating: Promise<void> | undefined;
+  let settleExit!: () => void;
+  const exitObserved = new Promise<void>(resolve => { settleExit = resolve; });
+  const exited = new Promise<ProcessResult>((resolve, reject) => { finish = resolve; fail = reject; });
+  // Exit can precede the spawn acknowledgement, before callers receive the handle.
+  void exited.catch(() => {});
+  function abort() { if (!ended) { aborted = true; if (started) void terminate().catch(fail); } }
+  function terminate(): Promise<void> {
+    if (ended) return Promise.resolve();
+    return terminating ??= command("terminate", { id }).then(() => exitObserved).catch(error => { terminating = undefined; throw error; });
+  }
   const subscription = onDesktopEvent(event => {
-    if (event.processId !== id) return;
-    if (event.type === "processOutput") onOutput?.({ stream: event.stream as "stdout" | "stderr", base64: event.base64 as string });
-    if (event.type === "processExit") { ended = true; subscription.remove(); finish(event.result as ProcessResult); }
-  });
-  const call = async (method: string, args: object = {}) => { await Native.call(method, JSON.stringify({ id, ...args })); };
-  try { await call("spawn", { ...options, streamOutput: !!onOutput }); } catch (error) { subscription.remove(); throw error; }
+    if (event.processId !== id || ended) return;
+    if (event.type === "processExit") {
+      ended = true; subscription.remove(); signal?.removeEventListener("abort", abort); settleExit();
+      try { finish(result(event.result, aborted, captureLimitBytes)); } catch (error) { fail(error); }
+    } else if (event.type === "processOutput" && !outputStopped) {
+      try {
+        if (event.stream !== "stdout" && event.stream !== "stderr") throw new SparkError("E_INVALID_DATA", "Invalid process output stream");
+        const bytes = nativeBytes(event.bytes, 16384);
+        onOutput?.({ stream: event.stream, bytes });
+      } catch (error) { outputStopped = true; fail(nativeError(error)); void terminate().catch(fail); }
+    }
+  }, { types: ["processOutput", "processExit"], target: { field: "processId", value: id } });
+  signal?.addEventListener("abort", abort, { once: true });
+  try {
+    await command("spawn", { id, ...wire }); started = true;
+    if (signal?.aborted) abort();
+    if (aborted) void terminate().catch(fail);
+  } catch (error) {
+    subscription.remove(); signal?.removeEventListener("abort", abort);
+    // A malformed acknowledgement can follow successful allocation.
+    if (error instanceof SparkError && error.code === "E_INVALID_DATA") {
+      try { await command("terminate", { id }); }
+      catch (cleanup) { throw new SparkError("E_NATIVE", "Process launch and termination failed", { cause: new AggregateError([error, cleanup]) }); }
+    }
+    throw error;
+  }
   return {
     id, exited,
-    async write(text: string) { if (typeof text !== "string") throw new Error("Process input must be a string"); if (ended) throw new Error("Process has exited"); await call("write", { text }); },
-    async closeInput() { if (!ended) await call("closeInput"); },
-    async terminate() { if (!ended) await call("terminate"); },
+    async write(input) {
+      const bytes = inputBytes(input);
+      if (ended || inputClosing) throw new SparkError("E_CLOSED", "Process input is closed");
+      return command("write", { id, bytes });
+    },
+    closeInput() {
+      inputClosing = true;
+      if (ended) return Promise.resolve();
+      return closingInput ??= command("closeInput", { id }).catch(error => { closingInput = undefined; throw error; });
+    },
+    terminate,
   };
 }
-export async function runCommand(options: ProcessOptions) {
+export async function runCommand(options: RunCommandOptions): Promise<ProcessResult> {
   const child = await spawn(options);
-  await child.closeInput();
-  return child.exited;
+  try { await child.closeInput(); return await child.exited; }
+  catch (error) {
+    try { await child.terminate(); }
+    catch (cleanup) { throw new SparkError("E_NATIVE", "Command and termination failed", { cause: new AggregateError([error, cleanup]) }); }
+    throw error;
+  }
 }

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

@@ -0,0 +1,34 @@
+export type ProcessTarget = { type: "executable"; path: string } | { type: "helper"; name: string } | { type: "command"; name: string };
+export type ProcessInput = string | Uint8Array;
+export type ProcessOutput = { stream: "stdout" | "stderr"; bytes: Uint8Array };
+export type ProcessOptions = {
+  target: ProcessTarget;
+  args?: readonly string[];
+  cwd?: string;
+  env?: Readonly<Record<string, string>>;
+  input?: ProcessInput;
+  timeoutMs?: number;
+  signal?: AbortSignal;
+  /** Maximum captured bytes per stream, 0–8 MiB; streaming remains complete. */
+  captureLimitBytes?: number;
+  onOutput?: (output: ProcessOutput) => void;
+};
+export type RunCommandOptions = ProcessOptions;
+export type ProcessExit = { type: "exited"; code: number } | { type: "terminated"; signal: number | null };
+export type ProcessResult = {
+  exit: ProcessExit;
+  stdout: Uint8Array;
+  stderr: Uint8Array;
+  timedOut: boolean;
+  aborted: boolean;
+  outputTruncated: boolean;
+};
+export interface ProcessHandle {
+  readonly id: string;
+  readonly exited: Promise<ProcessResult>;
+  /** Strings use UTF-8; byte arrays pass through unchanged. Calls preserve order. */
+  write(input: ProcessInput): Promise<void>;
+  closeInput(): Promise<void>;
+  /** Resolve after the process tree exits and its output drains. Retry on failure. */
+  terminate(): Promise<void>;
+}

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/SparkProcesses.h

@@ -1,11 +1,11 @@
 #pragma once
 #include "NativeModules.h"
+#include <SparkBinaryWindows.hpp>
 #include <algorithm>
 #include <atomic>
 #include <condition_variable>
 #include <deque>
 #include <filesystem>
-#include <future>
 #include <fstream>
 #include <map>
 #include <memory>
@@ -13,9 +13,7 @@
 #include <optional>
 #include <thread>
 #include <vector>
-#include <wincrypt.h>
 #include <winrt/Windows.Data.Json.h>
-#pragma comment(lib, "Crypt32.lib")
 namespace winrt::SparkProcesses {
 namespace React = Microsoft::ReactNative;
 namespace Json = Windows::Data::Json;
@@ -27,47 +25,75 @@ inline std::wstring Quote(std::wstring const &argument) {
   }
   result.append(slashes * 2, L'\\'); result += L'"'; return result;
 }
-inline std::string Base64(std::string const &bytes) {
-  if (bytes.empty()) return "";
-  DWORD length = 0; if (!CryptBinaryToStringA(reinterpret_cast<BYTE const *>(bytes.data()), static_cast<DWORD>(bytes.size()), CRYPT_STRING_BASE64 | CRYPT_STRING_NOCRLF, nullptr, &length)) throw_last_error();
-  std::string result(length, '\0'); if (!CryptBinaryToStringA(reinterpret_cast<BYTE const *>(bytes.data()), static_cast<DWORD>(bytes.size()), CRYPT_STRING_BASE64 | CRYPT_STRING_NOCRLF, result.data(), &length)) throw_last_error(); result.resize(length); return result;
+inline std::wstring ResolveCommand(std::wstring const &name) {
+  if (name.empty() || name.find_first_of(L"/\\:") != std::wstring::npos) throw hresult_invalid_argument(L"Expected a command name");
+  DWORD size = GetEnvironmentVariableW(L"PATH", nullptr, 0);
+  if (!size) return {};
+  std::wstring paths(size, L'\0'); GetEnvironmentVariableW(L"PATH", paths.data(), size);
+  std::wstring absolutePaths; size_t start = 0;
+  while (start < paths.size()) {
+    auto end = paths.find(L';', start); auto directory = paths.substr(start, end == std::wstring::npos ? std::wstring::npos : end - start);
+    directory.resize(wcslen(directory.c_str()));
+    if (directory.size() >= 2 && directory.front() == L'"' && directory.back() == L'"') directory = directory.substr(1, directory.size() - 2);
+    if (std::filesystem::path(directory).is_absolute()) { if (!absolutePaths.empty()) absolutePaths += L';'; absolutePaths += directory; }
+    if (end == std::wstring::npos) break; start = end + 1;
+  }
+  if (absolutePaths.empty()) return {};
+  wchar_t result[32768]{};
+  DWORD count = SearchPathW(absolutePaths.c_str(), name.c_str(), L".exe", 32768, result, nullptr);
+  if (!count) return {};
+  if (count >= 32768) throw hresult_invalid_argument(L"Resolved command path is too long");
+  auto attributes = GetFileAttributesW(result);
+  if (attributes == INVALID_FILE_ATTRIBUTES || (attributes & FILE_ATTRIBUTE_DIRECTORY)) return {};
+  auto extension = std::filesystem::path(result).extension().wstring();
+  if (_wcsicmp(extension.c_str(), L".exe") && _wcsicmp(extension.c_str(), L".com")) return {};
+  return result;
 }
-inline std::string UTF8(std::string const &bytes) { return bytes.empty() || MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, bytes.data(), static_cast<int>(bytes.size()), nullptr, 0) ? bytes : ""; }
+class CapturedBytes final : public spark::binary::jsi::MutableBuffer {
+  std::string bytes;
+public:
+  explicit CapturedBytes(std::string value) : bytes(std::move(value)) {}
+  size_t size() const override { return bytes.size(); }
+  uint8_t *data() override { return reinterpret_cast<uint8_t *>(bytes.data()); }
+};
 struct Process : std::enable_shared_from_this<Process> {
-  struct Input { std::string text; bool close; std::optional<React::ReactPromise<std::string>> promise; };
+  struct Input { std::vector<uint8_t> text; bool close; std::optional<spark::binary::NativePromise> promise; };
   handle process, job, input, output, error;
   std::mutex mutex; std::condition_variable condition; std::deque<Input> queue;
   std::atomic<bool> done{false}, terminated{false}, timedOut{false}, truncated{false};
   bool inputClosed = false;
+  size_t captureLimit = 8 * 1024 * 1024;
   std::string id, stdoutBytes, stderrBytes;
   React::ReactContext context;
+  void StopChecked() { if (job && !TerminateJobObject(job.get(), 1)) throw_last_error(); terminated = true; }
   void Stop() noexcept { terminated = true; if (job) TerminateJobObject(job.get(), 1); }
-  void Write(Input value) { std::lock_guard lock(mutex); if (done || inputClosed) { if (value.promise) { if (value.close) value.promise->Resolve("null"); else value.promise->Reject(React::ReactError{"E_PIPE", "Process input is closed"}); } return; } if (value.close) inputClosed = true; queue.push_back(std::move(value)); condition.notify_one(); }
+  void Write(Input value) { std::lock_guard lock(mutex); if (done || inputClosed) { if (value.promise) { if (value.close) value.promise->Resolve("null"); else value.promise->Reject(React::ReactError{"E_CLOSED", "Process input is closed"}); } return; } if (value.close) inputClosed = true; queue.push_back(std::move(value)); condition.notify_one(); }
   void InputLoop() noexcept {
     while (true) {
       Input value;
       { std::unique_lock lock(mutex); condition.wait(lock, [&]() { return done || !queue.empty(); }); if (queue.empty()) break; value = std::move(queue.front()); queue.pop_front(); }
-      if (done || !input) { if (value.promise) value.promise->Reject(React::ReactError{"E_PIPE", "Process input is closed"}); continue; }
+      if (done || !input) { if (value.promise) value.promise->Reject(React::ReactError{"E_CLOSED", "Process input is closed"}); continue; }
       bool success = true;
       if (value.close) input.close();
       else for (size_t offset = 0; offset < value.text.size();) { DWORD written = 0; if (!WriteFile(input.get(), value.text.data() + offset, static_cast<DWORD>(std::min<size_t>(16384, value.text.size() - offset)), &written, nullptr) || !written) { success = false; break; } offset += written; }
-      if (value.promise) { if (success) value.promise->Resolve("null"); else value.promise->Reject(React::ReactError{"E_PIPE", "Process input is closed"}); }
+      if (value.promise) { if (success) value.promise->Resolve("null"); else value.promise->Reject(React::ReactError{"E_CLOSED", "Process input is closed"}); }
     }
     input.close();
   }
   void Read(HANDLE pipe, std::string &buffer, std::string stream, bool streaming, std::shared_ptr<std::atomic<bool>> active) {
+    struct Credits { std::mutex mutex; std::condition_variable ready; size_t pending = 0; };
+    auto credits = std::make_shared<Credits>();
     char bytes[16384]; DWORD count;
     while (ReadFile(pipe, bytes, sizeof(bytes), &count, nullptr) && count) {
-      const auto keep = std::min<size_t>(count, 8 * 1024 * 1024 - buffer.size()); buffer.append(bytes, keep); if (keep < count) truncated = true;
+      const auto keep = std::min<size_t>(count, captureLimit - buffer.size()); buffer.append(bytes, keep); if (keep < count) truncated = true;
       if (streaming && *active) {
-        auto flushed = std::make_shared<std::promise<void>>(); auto wait = flushed->get_future();
-        auto data = Base64(std::string(bytes, count)); auto key = id;
-        context.UIDispatcher().Post([context = context, active, key, stream, data, flushed]() {
-          if (*active) context.EmitJSEvent(L"RCTDeviceEventEmitter", L"desktop", React::JSValueObject{{"type", "processOutput"}, {"processId", key}, {"stream", stream}, {"base64", data}});
-          flushed->set_value();
+        { std::unique_lock lock(credits->mutex); while (*active && credits->pending >= 64) credits->ready.wait_for(lock, std::chrono::milliseconds(100)); if (!*active) break; ++credits->pending; }
+        auto data = std::make_shared<spark::binary::Bytes>(std::vector<uint8_t>(bytes, bytes + count)); auto key = id;
+        auto delivered = [credits] { { std::lock_guard lock(credits->mutex); --credits->pending; } credits->ready.notify_one(); };
+        context.UIDispatcher().Post([context = context, active, key, stream, data, delivered]() {
+          if (*active) { Json::JsonObject event; event.SetNamedValue(L"type", Json::JsonValue::CreateStringValue(L"processOutput")); event.SetNamedValue(L"processId", Json::JsonValue::CreateStringValue(to_hstring(key))); event.SetNamedValue(L"stream", Json::JsonValue::CreateStringValue(to_hstring(stream))); spark::binary::Response response{to_string(event.Stringify()), {}, {{"bytes", data}}}; spark::binary::Emit(context.CallInvoker(), response.Build(), delivered); } else delivered();
         });
-        // Backpressure bounds the JS queue. Runtime shutdown releases this wait.
-        while (*active && wait.wait_for(std::chrono::milliseconds(100)) != std::future_status::ready) {}
+        // At most 1 MiB per stream awaits JS delivery; no per-chunk round trip.
       }
     }
   }
@@ -76,8 +102,12 @@ struct Process : std::enable_shared_from_this<Process> {
     if (!CreatePipe(read.put(), write.put(), &security, 0)) throw_last_error();
     if (!SetHandleInformation(parentReads ? read.get() : write.get(), HANDLE_FLAG_INHERIT, 0)) throw_last_error();
   }
-  void Start(Json::JsonObject const &args) {
+  void Start(Json::JsonObject const &args, std::optional<std::vector<uint8_t>> inputBytes) {
+    const auto limit = args.GetNamedNumber(L"captureLimitBytes", 8 * 1024 * 1024);
+    if (limit < 0 || limit > 8 * 1024 * 1024) throw hresult_invalid_argument(L"Invalid capture limit");
+    captureLimit = static_cast<size_t>(limit);
     auto executable = std::wstring(args.GetNamedString(L"executable"));
+    if (args.GetNamedBoolean(L"command", false)) { executable = ResolveCommand(executable); if (executable.empty()) throw hresult_error(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), L"Command not found"); }
     if (executable.rfind(L"helper:", 0) == 0) {
       const auto name = executable.substr(7); if (name.empty() || name.find_first_not_of(L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-") != std::wstring::npos) throw hresult_invalid_argument(L"Invalid helper name");
       wchar_t module[32768]{}; GetModuleFileNameW(nullptr, module, 32768);
@@ -117,7 +147,7 @@ struct Process : std::enable_shared_from_this<Process> {
     process.attach(info.hProcess); handle thread{info.hThread};
     if (!AssignProcessToJobObject(job.get(), process.get())) { auto error = GetLastError(); TerminateProcess(process.get(), 1); throw hresult_error(HRESULT_FROM_WIN32(error)); }
     if (ResumeThread(thread.get()) == static_cast<DWORD>(-1)) { Stop(); throw_last_error(); }
-    if (args.HasKey(L"input")) Write({to_string(args.GetNamedString(L"input")), false, std::nullopt});
+    if (inputBytes) Write({std::move(*inputBytes), false, std::nullopt});
   }
 };
 REACT_MODULE(SparkProcesses, L"NativeDesktopProcesses")
@@ -126,16 +156,30 @@ struct SparkProcesses {
   std::shared_ptr<State> state = std::make_shared<State>();
   REACT_INIT(Initialize) void Initialize(React::ReactContext const &context) noexcept { state->context = context; }
   ~SparkProcesses() { auto current = state; *current->active = false; if (current->context) current->context.UIDispatcher().Post([current]() { for (auto const &[id, process] : current->processes) process->Stop(); }); }
-  REACT_METHOD(call) void call(std::string method, std::string encoded, React::ReactPromise<std::string> promise) noexcept {
-    auto current = state;
-    current->context.UIDispatcher().Post([current, method, encoded, promise]() {
+  REACT_SYNC_METHOD(installBinary) std::optional<std::string> installBinary() noexcept {
+    try {
+    spark::binary::Install(state->context, "__sparkProcessesBinary", [current = state](std::string method, std::string encoded, std::optional<std::vector<uint8_t>> bytes, spark::binary::Completion finish) { Call(current, std::move(method), std::move(encoded), spark::binary::NativePromise(finish), std::move(bytes)); });
+      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 encoded, React::ReactPromise<std::string> promise) noexcept { Call(state, std::move(method), std::move(encoded), promise); }
+  static void Call(std::shared_ptr<State> current, std::string method, std::string encoded, spark::binary::NativePromise promise, std::optional<std::vector<uint8_t>> bytes = {}) {
+    current->context.UIDispatcher().Post([current, method = std::move(method), encoded = std::move(encoded), promise, bytes = std::move(bytes)]() mutable {
       try {
         if (!*current->active) { promise.Reject(React::ReactError{"E_CLOSED", "Process module is closed"}); return; }
-        auto args = Json::JsonObject::Parse(to_hstring(encoded)); auto id = to_string(args.GetNamedString(L"id"));
+        auto args = Json::JsonObject::Parse(to_hstring(encoded));
+        if (method == "resolveCommand") {
+          auto path = ResolveCommand(std::wstring(args.GetNamedString(L"command")));
+          promise.Resolve(to_string(path.empty() ? Json::JsonValue::CreateNullValue().Stringify() : Json::JsonValue::CreateStringValue(path).Stringify())); return;
+        }
+        auto id = to_string(args.GetNamedString(L"id"));
         auto found = current->processes.find(id);
         if (method == "spawn") {
           if (found != current->processes.end()) { promise.Reject(React::ReactError{"E_EXISTS", "Process id already exists"}); return; }
-          auto child = std::make_shared<Process>(); child->context = current->context; child->id = id; child->Start(args);
+          auto child = std::make_shared<Process>(); child->context = current->context; child->id = id; child->Start(args, std::move(bytes));
           const auto timeout = args.HasKey(L"timeoutMs") ? static_cast<DWORD>(std::clamp(args.GetNamedNumber(L"timeoutMs"), 1.0, static_cast<double>(INFINITE - 1))) : INFINITE;
           const bool stream = args.GetNamedBoolean(L"streamOutput", false);
           std::thread([current, child, timeout, stream]() {
@@ -151,20 +195,25 @@ struct SparkProcesses {
             TerminateJobObject(child->job.get(), 1); child->done = true; child->condition.notify_all();
             if (input.joinable()) input.join(); if (output.joinable()) output.join(); if (error.joinable()) error.join();
             current->context.UIDispatcher().Post([current, child, exit]() {
-              if (*current->active) current->context.EmitJSEvent(L"RCTDeviceEventEmitter", L"desktop", React::JSValueObject{{"type", "processExit"}, {"processId", child->id}, {"result", React::JSValueObject{
-                {"exitCode", static_cast<int64_t>(exit)}, {"signal", child->terminated.load()}, {"timedOut", child->timedOut.load()}, {"outputTruncated", child->truncated.load()},
-                {"stdout", UTF8(child->stdoutBytes)}, {"stderr", UTF8(child->stderrBytes)}, {"stdoutBase64", Base64(child->stdoutBytes)}, {"stderrBase64", Base64(child->stderrBytes)}}});
+              if (*current->active) {
+                Json::JsonObject result; result.SetNamedValue(L"exitCode", Json::JsonValue::CreateNumberValue(exit)); result.SetNamedValue(L"terminated", Json::JsonValue::CreateBooleanValue(child->terminated)); result.SetNamedValue(L"terminationSignal", Json::JsonValue::CreateNullValue()); result.SetNamedValue(L"timedOut", Json::JsonValue::CreateBooleanValue(child->timedOut)); result.SetNamedValue(L"outputTruncated", Json::JsonValue::CreateBooleanValue(child->truncated));
+                Json::JsonObject event; event.SetNamedValue(L"type", Json::JsonValue::CreateStringValue(L"processExit")); event.SetNamedValue(L"processId", Json::JsonValue::CreateStringValue(to_hstring(child->id))); event.SetNamedValue(L"result", result);
+                auto stdoutBytes = std::make_shared<CapturedBytes>(std::move(child->stdoutBytes)); auto stderrBytes = std::make_shared<CapturedBytes>(std::move(child->stderrBytes));
+                auto metadata = to_string(event.Stringify()); spark::binary::Emit(current->context.CallInvoker(), [metadata = std::move(metadata), stdoutBytes, stderrBytes](spark::binary::jsi::Runtime &rt) { auto value = spark::binary::JSON(metadata)(rt).asObject(rt); auto result = value.getPropertyAsObject(rt, "result"); result.setProperty(rt, "stdout", spark::binary::Buffer(rt, stdoutBytes)); result.setProperty(rt, "stderr", spark::binary::Buffer(rt, stderrBytes)); return spark::binary::jsi::Value(std::move(value)); });
+              }
               current->processes.erase(child->id);
             });
           }).detach();
           current->processes.emplace(id, child);
         } else if (found == current->processes.end() || found->second->done) { if (method == "terminate" || method == "closeInput") promise.Resolve("null"); else promise.Reject(React::ReactError{"E_CLOSED", "Process has exited"}); return; }
-        else if (method == "terminate") found->second->Stop();
-        else if (method == "write" || method == "closeInput") { found->second->Write({method == "write" ? to_string(args.GetNamedString(L"text")) : "", method == "closeInput", promise}); return; }
+        else if (method == "terminate") found->second->StopChecked();
+        else if (method == "write" || method == "closeInput") { found->second->Write({method == "write" && bytes ? std::move(*bytes) : std::vector<uint8_t>{}, method == "closeInput", promise}); return; }
         else throw hresult_invalid_argument(L"Unknown process operation");
         promise.Resolve("null");
-      } catch (hresult_error const &error) { promise.Reject(React::ReactError{"E_PROCESS", to_string(error.message())}); }
-      catch (std::exception const &error) { promise.Reject(React::ReactError{"E_PROCESS", error.what()}); }
+      } catch (hresult_error const &error) { const auto code = error.code();
+        const char *kind = code == E_INVALIDARG ? "E_INVALID_ARGUMENT" : code == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) || code == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) ? "E_NOT_FOUND" : code == E_ACCESSDENIED ? "E_PERMISSION_DENIED" : "E_NATIVE";
+        promise.Reject(React::ReactError{kind, to_string(error.message())}); }
+      catch (std::exception const &error) { promise.Reject(React::ReactError{"E_NATIVE", error.what()}); }
     });
   }
 };

package/vendor/node_modules/@legendapp/spark-processes/windows/SparkProcesses/SparkProcesses.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-secure-storage/macos/RNDesktopSecureStorage.mm

@@ -1,50 +1,59 @@
 #import "RNDesktopSecureStorage.h"
 #import <RNDesktopApp/SparkDesktop.h>
 #import <Security/Security.h>
+
+static NSDictionary *Failure(NSString *code, NSString *message) {
+  return @{ @"error": @{ @"code": code, @"message": message } };
+}
+static NSDictionary *StorageOperation(NSString *method, NSDictionary *args) {
+  NSString *key = args[@"key"];
+  if (![key isKindOfClass:NSString.class] || !key.length || key.length > 200) return Failure(@"E_INVALID_ARGUMENT", @"Expected a Keychain key of 1–200 characters");
+  NSString *service = SparkNamespace();
+  NSMutableDictionary *query = [@{ (__bridge id)kSecClass: (__bridge id)kSecClassGenericPassword,
+    (__bridge id)kSecAttrService: service, (__bridge id)kSecAttrAccount: key } mutableCopy];
+  OSStatus status;
+  if ([method isEqual:@"get"]) {
+    query[(__bridge id)kSecReturnData] = @YES;
+    query[(__bridge id)kSecMatchLimit] = (__bridge id)kSecMatchLimitOne;
+    CFTypeRef result = NULL;
+    status = SecItemCopyMatching((__bridge CFDictionaryRef)query, &result);
+    if (status == errSecItemNotFound) return @{ @"value": NSNull.null };
+    if (status == errSecSuccess) {
+      NSData *data = CFBridgingRelease(result);
+      NSString *value = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+      return value ? @{ @"value": value } : Failure(@"E_KEYCHAIN", @"Keychain item is not valid UTF-8");
+    }
+  } else if ([method isEqual:@"set"]) {
+    if (![args[@"value"] isKindOfClass:NSString.class]) return Failure(@"E_INVALID_ARGUMENT", @"Expected a string value");
+    NSData *value = [args[@"value"] dataUsingEncoding:NSUTF8StringEncoding];
+    NSDictionary *attributes = @{ (__bridge id)kSecValueData: value };
+    status = SecItemUpdate((__bridge CFDictionaryRef)query, (__bridge CFDictionaryRef)attributes);
+    if (status == errSecItemNotFound) {
+      [query addEntriesFromDictionary:attributes];
+      query[(__bridge id)kSecAttrAccessible] = (__bridge id)kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly;
+      status = SecItemAdd((__bridge CFDictionaryRef)query, NULL);
+      if (status == errSecDuplicateItem) {
+        [query removeObjectForKey:(__bridge id)kSecValueData];
+        [query removeObjectForKey:(__bridge id)kSecAttrAccessible];
+        status = SecItemUpdate((__bridge CFDictionaryRef)query, (__bridge CFDictionaryRef)attributes);
+      }
+    }
+  } else if ([method isEqual:@"remove"]) {
+    status = SecItemDelete((__bridge CFDictionaryRef)query);
+    if (status == errSecItemNotFound) status = errSecSuccess;
+  } else return Failure(@"E_INVALID_ARGUMENT", @"Unknown Keychain operation");
+  if (status == errSecSuccess) return @{ @"value": NSNull.null };
+  NSString *message = CFBridgingRelease(SecCopyErrorMessageString(status, NULL));
+  return Failure(@"E_KEYCHAIN", [NSString stringWithFormat:@"Keychain error %d: %@", (int)status, message ?: @"Unknown error"]);
+}
 @implementation RNDesktopSecureStorage
 RCT_EXPORT_MODULE(NativeDesktopSecureStorage)
 - (void)call:(NSString *)method args:(NSString *)json resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
-    NSDictionary *args = SparkArgs(json);
-    NSString *key = args[@"key"];
-    if (![key isKindOfClass:NSString.class] || !key.length || key.length > 200) { SparkInvalid(reject, @"Expected a Keychain key of 1–200 characters"); return; }
-    // Callers cannot override service identity and accidentally collide in Go.
-    NSMutableDictionary *query = [@{ (__bridge id)kSecClass: (__bridge id)kSecClassGenericPassword,
-      (__bridge id)kSecAttrService: SparkNamespace(), (__bridge id)kSecAttrAccount: key } mutableCopy];
-    OSStatus status;
-    if ([method isEqual:@"get"]) {
-      query[(__bridge id)kSecReturnData] = @YES;
-      query[(__bridge id)kSecMatchLimit] = (__bridge id)kSecMatchLimitOne;
-      CFTypeRef value = NULL;
-      status = SecItemCopyMatching((__bridge CFDictionaryRef)query, &value);
-      if (status == errSecItemNotFound) { resolve(@"null"); return; }
-      NSData *data = CFBridgingRelease(value);
-      if (status == errSecSuccess) {
-        NSString *text = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
-        if (!text) { reject(@"E_ENCODING", @"Keychain value is not UTF-8", nil); return; }
-        resolve(SparkJSON(text)); return;
-      }
-    } else if ([method isEqual:@"set"]) {
-      if (![args[@"value"] isKindOfClass:NSString.class]) { SparkInvalid(reject, @"Expected a string value"); return; }
-      NSData *value = [args[@"value"] dataUsingEncoding:NSUTF8StringEncoding];
-      NSDictionary *attributes = @{ (__bridge id)kSecValueData: value };
-      status = SecItemUpdate((__bridge CFDictionaryRef)query, (__bridge CFDictionaryRef)attributes);
-      if (status == errSecItemNotFound) {
-        [query addEntriesFromDictionary:attributes];
-        query[(__bridge id)kSecAttrAccessible] = (__bridge id)kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly;
-        status = SecItemAdd((__bridge CFDictionaryRef)query, NULL);
-        // Another caller may have added it after our update lookup.
-        if (status == errSecDuplicateItem) { [query removeObjectForKey:(__bridge id)kSecValueData]; [query removeObjectForKey:(__bridge id)kSecAttrAccessible]; status = SecItemUpdate((__bridge CFDictionaryRef)query, (__bridge CFDictionaryRef)attributes); }
-      }
-    } else if ([method isEqual:@"remove"]) {
-      status = SecItemDelete((__bridge CFDictionaryRef)query);
-      if (status == errSecItemNotFound) status = errSecSuccess;
-    } else { SparkInvalid(reject, @"Unknown Keychain operation"); return; }
-    if (status == errSecSuccess) resolve(@"null");
-    else {
-      NSString *message = CFBridgingRelease(SecCopyErrorMessageString(status, NULL));
-      reject(@"E_KEYCHAIN", [NSString stringWithFormat:@"Keychain error %d: %@", (int)status, message ?: @"Unknown error"], nil);
-    }
+    NSDictionary *result = StorageOperation(method, SparkArgs(json));
+    NSDictionary *error = result[@"error"];
+    if (error) reject(error[@"code"], error[@"message"], nil);
+    else resolve(SparkJSON(result[@"value"]));
   });
 }
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {

package/vendor/node_modules/@legendapp/spark-secure-storage/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-secure-storage",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.4",
   "license": "MIT",
   "main": "src/index",
   "react-native": "src/index",
@@ -41,7 +41,7 @@
     ]
   },
   "dependencies": {
-    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+    "@legendapp/spark-desktop-app": "0.0.1-next.4"
   },
   "peerDependenciesMeta": {
     "expo-secure-store": {

package/vendor/node_modules/@legendapp/spark-secure-storage/src/NativeDesktopSecureStorage.ts

@@ -3,4 +3,4 @@ import { TurboModuleRegistry } from "react-native";
 export interface Spec extends TurboModule {
   call(method: string, args: string): Promise<string>;
 }
-export default TurboModuleRegistry.getEnforcing<Spec>("NativeDesktopSecureStorage");
+export default TurboModuleRegistry.get<Spec>("NativeDesktopSecureStorage");

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

@@ -1,24 +1,26 @@
+import { Platform } from "react-native";
+import { SparkError, parseNativeResult, invokeNative } from "@legendapp/spark-desktop-app/src/contracts";
 import Native from "./NativeDesktopSecureStorage";
-function key(value: string) { if (!value.length || value.length > 200) throw new Error("Keychain keys must contain 1–200 characters"); return value; }
-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 secureStorage = {
-  get: (name: string) => call<string | null>("get", { key: key(name) }),
-  set: (name: string, value: string) => call("set", { key: key(name), value }),
-  remove: (name: string) => call("remove", { key: key(name) }),
-};
-
 import { validateItem, type SecureStoreOptions } from "./options";
 export type { SecureStoreOptions } from "./options";
-/** Basic Expo SecureStore subset; desktop service identity stays project-scoped. */
+function native() {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") throw new SparkError("E_UNSUPPORTED_PLATFORM", "Desktop secure storage is unavailable on this target");
+  if (!Native) throw new SparkError("E_MODULE_UNAVAILABLE", "NativeDesktopSecureStorage is not installed");
+  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);
+}
+/** Selected Expo subset; service identity is project-scoped. Missing is null, including on desktop. */
 export async function getItemAsync(key: string, options: SecureStoreOptions = {}): Promise<string | null> {
-  validateItem(key, options); return secureStorage.get(key);
+  validateItem(key, options); return call("get", { key }, (value): value is string | null => value === null || typeof value === "string");
 }
 export async function setItemAsync(key: string, value: string, options: SecureStoreOptions = {}): Promise<void> {
   validateItem(key, options);
-  if (typeof value !== "string") throw new TypeError("SecureStore values must be strings");
-  await secureStorage.set(key, value);
+  if (typeof value !== "string") throw new SparkError("E_INVALID_ARGUMENT", "SecureStore values must be strings");
+  await call("set", { key, value }, (value): value is null => value === null);
 }
 export async function deleteItemAsync(key: string, options: SecureStoreOptions = {}): Promise<void> {
-  validateItem(key, options); await secureStorage.remove(key);
+  validateItem(key, options); await call("remove", { key }, (value): value is null => value === null);
 }
-export async function isAvailableAsync(): Promise<boolean> { return true; }
+export async function isAvailableAsync(): Promise<boolean> { return (Platform.OS === "macos" || Platform.OS === "windows") && !!Native; }

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

@@ -11,4 +11,3 @@ export async function setItemAsync(key: string, value: string, options: SecureSt
 export async function deleteItemAsync(key: string, options: SecureStoreOptions = {}): Promise<void> {
   validateItem(key, options); await SecureStore.deleteItemAsync(key);
 }
-export const secureStorage = { get: getItemAsync, set: setItemAsync, remove: deleteItemAsync };