@intuned/runtime-dev 1.3.13-kv.1 → 1.3.14-ts-runtime-helpers

package/dist/runtime/captcha.test.js

@@ -0,0 +1,214 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _captcha = require("./captcha");
+_vitest.vi.mock("fastify", () => {
+  const fastify = () => ({
+    post: _vitest.vi.fn(),
+    setNotFoundHandler: _vitest.vi.fn(),
+    listen: _vitest.vi.fn(async () => undefined),
+    close: _vitest.vi.fn(async () => undefined)
+  });
+  return {
+    default: fastify
+  };
+});
+class FakeExtensionServer {
+  captchas = new Map();
+  subscribers = new Set();
+  subscribeCalls = 0;
+  unsubscribeCalls = 0;
+  seed(captchas) {
+    this.captchas.clear();
+    for (const c of captchas) this.captchas.set(c.id, c);
+  }
+  async upsertCaptcha(captcha) {
+    this.captchas.set(captcha.id, captcha);
+    for (const h of this.subscribers) {
+      await h(captcha);
+    }
+  }
+  async getCaptchas(_page, status) {
+    const list = [...this.captchas.values()];
+    return status ? list.filter(c => c.status === status) : list;
+  }
+  async subscribe(_page, handler) {
+    this.subscribeCalls += 1;
+    this.subscribers.add(handler);
+  }
+  async unsubscribe(_page, handler) {
+    this.unsubscribeCalls += 1;
+    this.subscribers.delete(handler);
+  }
+}
+let server;
+_vitest.vi.mock("../common/extension/intunedExtensionServer", () => {
+  return {
+    getIntunedExtensionServer: () => server
+  };
+});
+function makeMockPage() {
+  return {
+    waitForLoadState: _vitest.vi.fn().mockResolvedValue(undefined)
+  };
+}
+(0, _vitest.beforeEach)(() => {
+  _vitest.vi.useFakeTimers();
+  server = new FakeExtensionServer();
+});
+(0, _vitest.afterEach)(() => {
+  _vitest.vi.useRealTimers();
+  _vitest.vi.restoreAllMocks();
+});
+(0, _vitest.describe)("runtime/captcha", () => {
+  (0, _vitest.it)("waitForCaptchaSolve: resolves after settle period when no captchas are present", async () => {
+    const page = makeMockPage();
+    const p = (0, _captcha.waitForCaptchaSolve)(page, {
+      timeoutInMs: 1000,
+      settlePeriodInMs: 10
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    await p;
+    (0, _vitest.expect)(page.waitForLoadState).not.toHaveBeenCalled();
+    (0, _vitest.expect)(server.subscribeCalls).toBe(1);
+    (0, _vitest.expect)(server.unsubscribeCalls).toBe(1);
+  });
+  (0, _vitest.it)("withWaitForCaptchaSolve: preserves return value and waits for networkidle by default", async () => {
+    const page = makeMockPage();
+    const p = (0, _captcha.withWaitForCaptchaSolve)(async () => "ok", {
+      page,
+      timeoutInMs: 1000,
+      settleDurationMs: 10
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    await (0, _vitest.expect)(p).resolves.toBe("ok");
+    (0, _vitest.expect)(page.waitForLoadState).toHaveBeenCalledWith("networkidle");
+  });
+  (0, _vitest.it)("withWaitForCaptchaSolve: skips networkidle when disabled", async () => {
+    const page = makeMockPage();
+    const p = (0, _captcha.withWaitForCaptchaSolve)(async () => "ok", {
+      page,
+      timeoutInMs: 1000,
+      settleDurationMs: 10,
+      waitForNetworkSettled: false
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    await (0, _vitest.expect)(p).resolves.toBe("ok");
+    (0, _vitest.expect)(page.waitForLoadState).not.toHaveBeenCalled();
+  });
+  (0, _vitest.it)("waitForCaptchaSolve: completes when a solving captcha becomes solved", async () => {
+    const page = makeMockPage();
+    server.seed([{
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "solving",
+      retryCount: 0
+    }]);
+    const p = (0, _captcha.waitForCaptchaSolve)(page, {
+      timeoutInMs: 1000,
+      settlePeriodInMs: 10
+    });
+    await Promise.resolve();
+    await server.upsertCaptcha({
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "solved",
+      retryCount: 0
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    await (0, _vitest.expect)(p).resolves.toBeUndefined();
+  });
+  (0, _vitest.it)("waitForCaptchaSolve: throws on captcha error", async () => {
+    const page = makeMockPage();
+    server.seed([{
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "solving",
+      retryCount: 0
+    }]);
+    const p = (0, _captcha.waitForCaptchaSolve)(page, {
+      timeoutInMs: 1000,
+      settlePeriodInMs: 10
+    });
+    const assertion = (0, _vitest.expect)(p).rejects.toThrow("CAPTCHA Solve Error: UNEXPECTED_ERROR");
+    await Promise.resolve();
+    await server.upsertCaptcha({
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "error",
+      retryCount: 0,
+      error: {
+        code: "UNEXPECTED_ERROR"
+      }
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    await assertion;
+    (0, _vitest.expect)(server.unsubscribeCalls).toBe(1);
+  });
+  (0, _vitest.it)("waitForCaptchaSolve: times out if captchas are still pending", async () => {
+    const page = makeMockPage();
+    server.seed([{
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "solving",
+      retryCount: 0
+    }]);
+    const p = (0, _captcha.waitForCaptchaSolve)(page, {
+      timeoutInMs: 5,
+      settlePeriodInMs: 1
+    });
+    const assertion = (0, _vitest.expect)(p).rejects.toThrow("CAPTCHA Solve timed out with pending captchas.");
+    await Promise.resolve();
+    await _vitest.vi.advanceTimersByTimeAsync(6);
+    await _vitest.vi.advanceTimersByTimeAsync(1);
+    await assertion;
+    (0, _vitest.expect)(server.unsubscribeCalls).toBe(1);
+  });
+  (0, _vitest.it)("waitForCaptchaSolve: waits for all captchas to resolve", async () => {
+    const page = makeMockPage();
+    server.seed([{
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "solving",
+      retryCount: 0
+    }, {
+      id: "c2",
+      tabId: 0,
+      type: "hcaptcha",
+      status: "solving",
+      retryCount: 0
+    }]);
+    const p = (0, _captcha.waitForCaptchaSolve)(page, {
+      timeoutInMs: 1000,
+      settlePeriodInMs: 10
+    });
+    await Promise.resolve();
+    await server.upsertCaptcha({
+      id: "c1",
+      tabId: 0,
+      type: "recaptcha",
+      status: "solved",
+      retryCount: 0
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    let settled = false;
+    p.then(() => settled = true).catch(() => settled = true);
+    await Promise.resolve();
+    (0, _vitest.expect)(settled).toBe(false);
+    await server.upsertCaptcha({
+      id: "c2",
+      tabId: 0,
+      type: "hcaptcha",
+      status: "detached",
+      retryCount: 0
+    });
+    await _vitest.vi.advanceTimersByTimeAsync(10);
+    await (0, _vitest.expect)(p).resolves.toBeUndefined();
+  });
+});

package/dist/runtime/index.d.ts

@@ -5,4 +5,5 @@ export { persistentStore } from "./persistentStore";
 export { getAuthSessionParameters } from "./getAuthSessionParameters";
 export { runInfo } from "./runInfo";
 export { RunError } from "./RunError";
+export { waitForCaptchaSolve, withWaitForCaptchaSolve, onCaptchaEvent, onceCaptchaEvent, removeCaptchaEventListener, pauseCaptchaSolver, resumeCaptchaSolver, } from "./captcha";
 export { getDownloadDirectoryPath } from "./downloadDirectory";

package/dist/runtime/index.js

@@ -39,18 +39,60 @@ Object.defineProperty(exports, "getDownloadDirectoryPath", {
     return _downloadDirectory.getDownloadDirectoryPath;
   }
 });
+Object.defineProperty(exports, "onCaptchaEvent", {
+  enumerable: true,
+  get: function () {
+    return _captcha.onCaptchaEvent;
+  }
+});
+Object.defineProperty(exports, "onceCaptchaEvent", {
+  enumerable: true,
+  get: function () {
+    return _captcha.onceCaptchaEvent;
+  }
+});
+Object.defineProperty(exports, "pauseCaptchaSolver", {
+  enumerable: true,
+  get: function () {
+    return _captcha.pauseCaptchaSolver;
+  }
+});
 Object.defineProperty(exports, "persistentStore", {
   enumerable: true,
   get: function () {
     return _persistentStore.persistentStore;
   }
 });
+Object.defineProperty(exports, "removeCaptchaEventListener", {
+  enumerable: true,
+  get: function () {
+    return _captcha.removeCaptchaEventListener;
+  }
+});
+Object.defineProperty(exports, "resumeCaptchaSolver", {
+  enumerable: true,
+  get: function () {
+    return _captcha.resumeCaptchaSolver;
+  }
+});
 Object.defineProperty(exports, "runInfo", {
   enumerable: true,
   get: function () {
     return _runInfo.runInfo;
   }
 });
+Object.defineProperty(exports, "waitForCaptchaSolve", {
+  enumerable: true,
+  get: function () {
+    return _captcha.waitForCaptchaSolve;
+  }
+});
+Object.defineProperty(exports, "withWaitForCaptchaSolve", {
+  enumerable: true,
+  get: function () {
+    return _captcha.withWaitForCaptchaSolve;
+  }
+});
 var _extendPayload = require("./extendPayload");
 var _extendTimeout = require("./extendTimeout");
 var _attemptStore = require("./attemptStore");
@@ -58,4 +100,5 @@ var _persistentStore = require("./persistentStore");
 var _getAuthSessionParameters = require("./getAuthSessionParameters");
 var _runInfo = require("./runInfo");
 var _RunError = require("./RunError");
+var _captcha = require("./captcha");
 var _downloadDirectory = require("./downloadDirectory");

package/dist/runtime/persistentStore.test.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _zod = require("zod");
+var _persistentStore = require("./persistentStore");
+var _jwtTokenManager = require("../common/jwtTokenManager");
+_vitest.vi.mock("../common/jwtTokenManager", () => ({
+  callBackendFunctionWithToken: _vitest.vi.fn()
+}));
+(0, _vitest.describe)("Cache", () => {
+  (0, _vitest.beforeEach)(() => {
+    _vitest.vi.clearAllMocks();
+  });
+  (0, _vitest.describe)("get", () => {
+    (0, _vitest.it)("should return value when successful", async () => {
+      const mockResponse = {
+        ok: true,
+        json: _vitest.vi.fn().mockResolvedValue({
+          value: "cached_data"
+        })
+      };
+      _vitest.vi.mocked(_jwtTokenManager.callBackendFunctionWithToken).mockResolvedValue(mockResponse);
+      const result = await _persistentStore.persistentStore.get("test_key");
+      (0, _vitest.expect)(result).toBe("cached_data");
+      (0, _vitest.expect)(_jwtTokenManager.callBackendFunctionWithToken).toHaveBeenCalledWith("kv-store/test_key", {
+        method: "GET"
+      });
+      (0, _vitest.expect)(mockResponse.json).toHaveBeenCalled();
+    });
+    (0, _vitest.it)("should throw error when response is not ok", async () => {
+      const mockResponse = {
+        ok: false,
+        json: _vitest.vi.fn().mockResolvedValue({
+          message: "Cache miss"
+        })
+      };
+      _vitest.vi.mocked(_jwtTokenManager.callBackendFunctionWithToken).mockResolvedValue(mockResponse);
+      await (0, _vitest.expect)(_persistentStore.persistentStore.get("test_key")).rejects.toThrow("Cache miss");
+    });
+    (0, _vitest.it)("should throw error for empty key", async () => {
+      await (0, _vitest.expect)(_persistentStore.persistentStore.get("")).rejects.toThrow(_zod.ZodError);
+    });
+    (0, _vitest.it)("should throw error for key with colon", async () => {
+      await (0, _vitest.expect)(_persistentStore.persistentStore.get("invalid:key")).rejects.toThrow(_zod.ZodError);
+    });
+    (0, _vitest.it)("should throw error for key with hash", async () => {
+      await (0, _vitest.expect)(_persistentStore.persistentStore.get("invalid#key")).rejects.toThrow(_zod.ZodError);
+    });
+  });
+  (0, _vitest.describe)("set", () => {
+    (0, _vitest.it)("should call backend correctly when successful", async () => {
+      const mockResponse = {
+        ok: true,
+        json: _vitest.vi.fn().mockResolvedValue({})
+      };
+      _vitest.vi.mocked(_jwtTokenManager.callBackendFunctionWithToken).mockResolvedValue(mockResponse);
+      const testValue = {
+        data: "test"
+      };
+      await _persistentStore.persistentStore.set("test_key", testValue);
+      (0, _vitest.expect)(_jwtTokenManager.callBackendFunctionWithToken).toHaveBeenCalledWith("kv-store/test_key", {
+        method: "PUT",
+        body: JSON.stringify(testValue),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      (0, _vitest.expect)(mockResponse.json).toHaveBeenCalled();
+    });
+    (0, _vitest.it)("should throw error when response is not ok", async () => {
+      const mockResponse = {
+        ok: false,
+        json: _vitest.vi.fn().mockResolvedValue({
+          message: "Set failed"
+        })
+      };
+      _vitest.vi.mocked(_jwtTokenManager.callBackendFunctionWithToken).mockResolvedValue(mockResponse);
+      await (0, _vitest.expect)(_persistentStore.persistentStore.set("test_key", "value")).rejects.toThrow("Set failed");
+    });
+    (0, _vitest.it)("should throw error for empty key", async () => {
+      await (0, _vitest.expect)(_persistentStore.persistentStore.set("", "value")).rejects.toThrow(_zod.ZodError);
+    });
+    (0, _vitest.it)("should throw error for key with forbidden characters", async () => {
+      await (0, _vitest.expect)(_persistentStore.persistentStore.set("invalid:key", "value")).rejects.toThrow(_zod.ZodError);
+      await (0, _vitest.expect)(_persistentStore.persistentStore.set("invalid#key", "value")).rejects.toThrow(_zod.ZodError);
+    });
+    (0, _vitest.it)("should handle different value types", async () => {
+      const mockResponse = {
+        ok: true,
+        json: _vitest.vi.fn().mockResolvedValue({})
+      };
+      _vitest.vi.mocked(_jwtTokenManager.callBackendFunctionWithToken).mockResolvedValue(mockResponse);
+      await _persistentStore.persistentStore.set("key1", "string_value");
+      await _persistentStore.persistentStore.set("key2", {
+        object: "value"
+      });
+      await _persistentStore.persistentStore.set("key3", 123);
+      (0, _vitest.expect)(_jwtTokenManager.callBackendFunctionWithToken).toHaveBeenCalledTimes(3);
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intuned/runtime-dev",
-  "version": "1.3.13-kv.1",
+  "version": "1.3.14-ts-runtime-helpers",
   "description": "Intuned runtime",
   "exports": {
     ".": "./dist/index.js",
@@ -30,6 +30,7 @@
     "intuned-auth-session-load": "vite-node ./src/commands/auth/load.ts",
     "intuned-ts-check": "yarn prepublishOnly && vite-node ./src/commands/ts-check.ts",
     "intuned": "vite-node ./src/commands/intuned-cli/main.ts",
+    "intuned-get-headless-user-agent": "vite-node ./src/commands/get-headless-user-agent.ts",
     "build": "rm -rf dist && tsc -p tsconfig.json  && yarn copy-dts && babel src --out-dir dist --extensions '.ts' &&  cp -r ./src/common/assets dist/common/assets",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -50,6 +51,7 @@
     "intuned-browser-start": "bin/intuned-browser-start",
     "intuned-browser-save-state": "bin/intuned-browser-save-state",
     "intuned-ts-check": "bin/intuned-ts-check",
+    "intuned-get-headless-user-agent": "bin/intuned-get-headless-user-agent",
     "intuned": "bin/intuned"
   },
   "dependencies": {
@@ -68,6 +70,7 @@
     "commander": "14.0.0",
     "cross-fetch": "^4.0.0",
     "dotenv": "^16.3.1",
+    "fastify": "4.29.0",
     "fs-extra": "^11.3.0",
     "image-size": "^1.1.1",
     "jsonc-parser": "^3.3.1",