@rxflex/rom 0.0.8 → 0.0.9

package/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "rom-node-native"
 description = "Native napi-rs bridge for the ROM Node.js bindings"
-version = "0.0.8"
+version = "0.0.9"
 edition = "2024"
 homepage = "https://github.com/Rxflex/rom"
 license = "MIT"

package/README.md

@@ -46,6 +46,9 @@ console.log(await runtime.evalAsync("(async () => String(globalThis.__romValue))
 Config keys use the Rust runtime field names, so use snake_case such as `cors_enabled` and `proxy_url`.
 `cors_enabled` is `false` by default.
 When the native addon is loaded, one `RomRuntime` instance keeps JS globals alive across multiple `eval()` and `evalAsync()` calls.
+For cookie seeding, the wrapper accepts either serialized `cookie_store`, a raw cookie header string such as `"api_uid=seeded; _nano_fp=abc"`, or a `cookies` alias with string/object/array inputs.
+For storage seeding, the wrapper accepts `local_storage` and `session_storage` as serialized JSON objects, plain JS objects, or entry arrays such as `[['VerifyAuthToken', 'seeded']]`.
+The default navigator surface is Chrome-like, including `navigator.userAgent`, `navigator.vendor`, and `navigator.userAgentData`.
 
 ## Optional native build
 

package/native/lib.rs

@@ -78,6 +78,18 @@ impl NativeRomRuntime {
             .map(|value| value.to_owned())
     }
 
+    #[napi(js_name = "exportLocalStorage")]
+    pub fn export_local_storage(&self) -> Result<String> {
+        map_runtime_error(self.runtime.export_local_storage())
+            .map(|value| value.to_owned())
+    }
+
+    #[napi(js_name = "exportSessionStorage")]
+    pub fn export_session_storage(&self) -> Result<String> {
+        map_runtime_error(self.runtime.export_session_storage())
+            .map(|value| value.to_owned())
+    }
+
     #[napi(js_name = "evalJson")]
     pub fn eval_json(&self, script: String, asynchronous: bool) -> Result<String> {
         let value = if asynchronous {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rxflex/rom",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "type": "module",
   "description": "Node.js wrapper for the ROM browser-like runtime",
   "license": "MIT",

package/scripts/smoke.mjs

@@ -1,10 +1,16 @@
 import { RomRuntime, hasNativeBinding } from "../src/index.js";
 
 async function main() {
-  const runtime = new RomRuntime({ href: "https://example.test/" });
+  const runtime = new RomRuntime({
+    href: "https://example.test/",
+    cookie_store: "seed=1; path=/",
+    local_storage: { VerifyAuthToken: "seeded-storage" },
+  });
   const href = await runtime.evalAsync("(async () => location.href)()");
   await runtime.evalAsync("(async () => { globalThis.__romSmokeValue = 42; return 'ok'; })()");
   const persisted = await runtime.evalAsync("(async () => String(globalThis.__romSmokeValue))()");
+  const cookie = await runtime.evalAsync("(async () => document.cookie)()");
+  const storage = await runtime.evalAsync("(async () => localStorage.getItem('VerifyAuthToken'))()");
   const snapshot = await runtime.surfaceSnapshot();
 
   if (!hasNativeBinding()) {
@@ -23,7 +29,15 @@ async function main() {
     throw new Error(`Expected persisted global state, got: ${persisted}`);
   }
 
-  console.log(JSON.stringify({ native: true, href, persisted }));
+  if (cookie !== "seed=1") {
+    throw new Error(`Expected seeded cookie, got: ${cookie}`);
+  }
+
+  if (storage !== "seeded-storage") {
+    throw new Error(`Expected seeded localStorage, got: ${storage}`);
+  }
+
+  console.log(JSON.stringify({ native: true, href, persisted, cookie, storage }));
 }
 
 main().catch((error) => {

package/src/index.d.ts

@@ -1,3 +1,25 @@
+export interface CookieEntry {
+  name: string;
+  value: string;
+  domain?: string;
+  hostOnly?: boolean;
+  path?: string;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: "Lax" | "Strict" | "None";
+  expiresAt?: number | null;
+}
+
+export type CookieInput =
+  | string
+  | CookieEntry[]
+  | Record<string, string | number | boolean | null | undefined>;
+
+export type StorageInput =
+  | string
+  | Record<string, string | number | boolean | null | undefined>
+  | Array<[string, string | number | boolean | null | undefined]>;
+
 export interface RuntimeConfig {
   href?: string;
   referrer?: string;
@@ -11,7 +33,12 @@ export interface RuntimeConfig {
   webdriver?: boolean;
   cors_enabled?: boolean;
   proxy_url?: string | null;
-  cookie_store?: string | null;
+  cookie_store?: CookieInput | null;
+  cookies?: CookieInput | null;
+  local_storage?: StorageInput | null;
+  session_storage?: StorageInput | null;
+  localStorage?: StorageInput | null;
+  sessionStorage?: StorageInput | null;
 }
 
 export declare class RomRuntime {

package/src/index.js

@@ -8,6 +8,15 @@ const __dirname = path.dirname(__filename);
 const repoRoot = path.resolve(__dirname, "..", "..", "..");
 const nativeBridge = loadNativeBridge();
 const NativeRomRuntime = nativeBridge?.NativeRomRuntime ?? null;
+const COOKIE_ATTRIBUTE_NAMES = new Set([
+  "domain",
+  "path",
+  "expires",
+  "max-age",
+  "samesite",
+  "secure",
+  "httponly",
+]);
 
 function resolveBridgeCommand() {
   if (process.env.ROM_BRIDGE_BIN) {
@@ -90,21 +99,256 @@ function runBridge(command, payload) {
 }
 
 function applyBridgeState(targetConfig, state) {
-  if (!state || typeof state.cookie_store !== "string") {
+  if (!state || typeof state !== "object") {
     return targetConfig;
   }
 
+  const nextConfig = { ...targetConfig };
+  if (typeof state.cookie_store === "string") {
+    nextConfig.cookie_store = state.cookie_store;
+  }
+  if (typeof state.local_storage === "string") {
+    nextConfig.local_storage = state.local_storage;
+  }
+  if (typeof state.session_storage === "string") {
+    nextConfig.session_storage = state.session_storage;
+  }
+
+  return nextConfig;
+}
+
+function normalizeRuntimeConfig(config = {}) {
+  const normalized = { ...config };
+  const cookieStore = normalizeCookieStoreInput(
+    normalized.cookie_store ?? normalized.cookies ?? null,
+    normalized.href,
+  );
+  const localStorage = normalizeStorageInput(
+    normalized.local_storage ?? normalized.localStorage ?? null,
+  );
+  const sessionStorage = normalizeStorageInput(
+    normalized.session_storage ?? normalized.sessionStorage ?? null,
+  );
+
+  delete normalized.cookies;
+  delete normalized.localStorage;
+  delete normalized.sessionStorage;
+  if (cookieStore !== null) {
+    normalized.cookie_store = cookieStore;
+  }
+  if (localStorage !== null) {
+    normalized.local_storage = localStorage;
+  }
+  if (sessionStorage !== null) {
+    normalized.session_storage = sessionStorage;
+  }
+
+  return normalized;
+}
+
+function normalizeCookieStoreInput(value, href) {
+  if (value === null || value === undefined || value === "") {
+    return null;
+  }
+
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return null;
+    }
+
+    if (looksLikeSerializedCookieStore(trimmed)) {
+      return trimmed;
+    }
+
+    return serializeCookieEntries(parseCookieHeaderString(trimmed, href));
+  }
+
+  if (Array.isArray(value)) {
+    return serializeCookieEntries(normalizeCookieEntries(value, href));
+  }
+
+  if (typeof value === "object") {
+    return serializeCookieEntries(normalizeCookieEntries(value, href));
+  }
+
+  return null;
+}
+
+function normalizeStorageInput(value) {
+  if (value === null || value === undefined || value === "") {
+    return null;
+  }
+
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed || !looksLikeSerializedStorage(trimmed)) {
+      return null;
+    }
+    return serializeStorageEntries(JSON.parse(trimmed));
+  }
+
+  if (Array.isArray(value) || typeof value === "object") {
+    return serializeStorageEntries(value);
+  }
+
+  return null;
+}
+
+function looksLikeSerializedCookieStore(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed);
+  } catch {
+    return false;
+  }
+}
+
+function looksLikeSerializedStorage(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) || (!!parsed && typeof parsed === "object");
+  } catch {
+    return false;
+  }
+}
+
+function normalizeCookieEntries(value, href) {
+  if (Array.isArray(value)) {
+    return value
+      .map((entry) => normalizeCookieEntryObject(entry, href))
+      .filter(Boolean);
+  }
+
+  return Object.entries(value).map(([name, entryValue]) =>
+    createCookieEntry(name, entryValue, href),
+  );
+}
+
+function normalizeCookieEntryObject(entry, href) {
+  if (!entry || typeof entry !== "object") {
+    return null;
+  }
+
+  const url = safeCookieUrl(href);
+  const path = typeof entry.path === "string" && entry.path.startsWith("/") ? entry.path : "/";
+  const domain =
+    typeof entry.domain === "string" && entry.domain.trim()
+      ? entry.domain.trim().replace(/^\./, "").toLowerCase()
+      : url.hostname.toLowerCase();
+
+  return {
+    name: String(entry.name ?? ""),
+    value: String(entry.value ?? ""),
+    domain,
+    hostOnly: entry.hostOnly ?? !("domain" in entry),
+    path,
+    secure: Boolean(entry.secure ?? (url.protocol === "https:")),
+    httpOnly: Boolean(entry.httpOnly),
+    sameSite: normalizeSameSite(entry.sameSite),
+    expiresAt: normalizeExpiresAt(entry.expiresAt),
+  };
+}
+
+function parseCookieHeaderString(value, href) {
+  return value
+    .split(";")
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .map((part) => {
+      const separator = part.indexOf("=");
+      if (separator <= 0) {
+        return null;
+      }
+
+      const name = part.slice(0, separator).trim();
+      if (!name || COOKIE_ATTRIBUTE_NAMES.has(name.toLowerCase())) {
+        return null;
+      }
+
+      return createCookieEntry(name, part.slice(separator + 1), href);
+    })
+    .filter(Boolean);
+}
+
+function createCookieEntry(name, value, href) {
+  const url = safeCookieUrl(href);
   return {
-    ...targetConfig,
-    cookie_store: state.cookie_store,
+    name: String(name),
+    value: String(value),
+    domain: url.hostname.toLowerCase(),
+    hostOnly: true,
+    path: "/",
+    secure: url.protocol === "https:",
+    httpOnly: false,
+    sameSite: "Lax",
+    expiresAt: null,
   };
 }
 
+function safeCookieUrl(href) {
+  try {
+    return new URL(href || "https://rom.local/");
+  } catch {
+    return new URL("https://rom.local/");
+  }
+}
+
+function normalizeSameSite(value) {
+  const normalized = String(value ?? "Lax").toLowerCase();
+  if (normalized === "strict") {
+    return "Strict";
+  }
+  if (normalized === "none") {
+    return "None";
+  }
+  return "Lax";
+}
+
+function normalizeExpiresAt(value) {
+  if (value === null || value === undefined || value === "") {
+    return null;
+  }
+
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+
+function serializeCookieEntries(entries) {
+  if (!Array.isArray(entries) || entries.length === 0) {
+    return null;
+  }
+
+  return JSON.stringify(entries.filter((entry) => entry && entry.name));
+}
+
+function serializeStorageEntries(value) {
+  if (Array.isArray(value)) {
+    return JSON.stringify(
+      Object.fromEntries(
+        value
+          .filter((entry) => Array.isArray(entry) && entry.length >= 2)
+          .map(([key, entryValue]) => [String(key), String(entryValue)]),
+      ),
+    );
+  }
+
+  if (value && typeof value === "object") {
+    return JSON.stringify(
+      Object.fromEntries(
+        Object.entries(value).map(([key, entryValue]) => [key, String(entryValue)]),
+      ),
+    );
+  }
+
+  return null;
+}
+
 export class RomRuntime {
   #nativeRuntime = null;
 
   constructor(config = {}) {
-    this.config = config;
+    this.config = normalizeRuntimeConfig(config);
     if (typeof NativeRomRuntime === "function") {
       this.#nativeRuntime = new NativeRomRuntime(JSON.stringify(this.config));
     }
@@ -121,12 +365,31 @@ export class RomRuntime {
     };
   }
 
+  #applyStorageState(key, value) {
+    if (typeof value !== "string") {
+      return;
+    }
+
+    this.config = {
+      ...this.config,
+      [key]: value,
+    };
+  }
+
   #syncNativeState() {
-    if (!this.#nativeRuntime || typeof this.#nativeRuntime.exportCookieStore !== "function") {
+    if (!this.#nativeRuntime) {
       return;
     }
 
-    this.#applyCookieStore(this.#nativeRuntime.exportCookieStore());
+    if (typeof this.#nativeRuntime.exportCookieStore === "function") {
+      this.#applyCookieStore(this.#nativeRuntime.exportCookieStore());
+    }
+    if (typeof this.#nativeRuntime.exportLocalStorage === "function") {
+      this.#applyStorageState("local_storage", this.#nativeRuntime.exportLocalStorage());
+    }
+    if (typeof this.#nativeRuntime.exportSessionStorage === "function") {
+      this.#applyStorageState("session_storage", this.#nativeRuntime.exportSessionStorage());
+    }
   }
 
   async #runNative(method, ...args) {