mirror of
https://github.com/diegosouzapw/OmniRoute.git
synced 2026-08-11 09:42:15 +03:00
1135 lines
43 KiB
TypeScript
1135 lines
43 KiB
TypeScript
import { test } from "node:test";
|
|
import assert from "node:assert";
|
|
import { resolvePublicCred } from "../../open-sse/utils/publicCreds.ts";
|
|
import {
|
|
ADOBE_FIREFLY_IMAGE_MODELS,
|
|
ADOBE_FIREFLY_VIDEO_MODELS,
|
|
adobeFireflyApiKey,
|
|
adobeFireflyBalanceApiKey,
|
|
buildAdobeImagePayload,
|
|
buildAdobePollHeaders,
|
|
buildAdobeSubmitHeaders,
|
|
buildAdobeUploadHeaders,
|
|
buildAdobeVideoPayload,
|
|
extractAdobeAccountIdFromToken,
|
|
extractAdobeCredentialToken,
|
|
extractAdobeMediaUrl,
|
|
extractAdobeResultLink,
|
|
extractAdobeSourceImageSources,
|
|
looksLikeAdobeJwt,
|
|
normalizeAdobeAspectRatio,
|
|
normalizeAdobeOutputResolution,
|
|
normalizeAdobePollUrl,
|
|
parseAdobeCreditsBalance,
|
|
parseAdobeModelsDiscovery,
|
|
parseAdobeImageSourceBytes,
|
|
parseAdobeStorageUploadResponse,
|
|
resolveAdobeImageModel,
|
|
resolveAdobeVideoModel,
|
|
resolveAdobeSourceImageIds,
|
|
adobeFireflyGenerateImage,
|
|
adobeFireflyGenerateVideo,
|
|
exchangeAdobeCookieForAccessToken,
|
|
isAdobeGuestAccessToken,
|
|
isAdobeUserAccessToken,
|
|
isAdobeTransientSubmitError,
|
|
generateAdobeNonce,
|
|
extractAdobeArpSessionId,
|
|
resolveAdobeAccessToken,
|
|
ADOBE_FIREFLY_IMAGE_UPLOAD_URL,
|
|
} from "../../open-sse/services/adobeFireflyClient.ts";
|
|
import {
|
|
ADOBE_FIREFLY_FALLBACK_MODELS,
|
|
getAdobeFireflyFallbackCatalog,
|
|
mapDiscoveredToCatalog,
|
|
} from "../../open-sse/services/adobeFireflyModels.ts";
|
|
import {
|
|
buildAdobeFireflyCreditsQuota,
|
|
buildAdobeFireflyQuotasRecord,
|
|
} from "../../open-sse/services/usage/adobeFirefly.ts";
|
|
import { USAGE_SUPPORTED_PROVIDERS } from "../../src/shared/constants/providers.ts";
|
|
import { handleAdobeFireflyImageGeneration } from "../../open-sse/handlers/imageGeneration/providers/adobeFirefly.ts";
|
|
import { handleAdobeFireflyVideoGeneration } from "../../open-sse/handlers/videoGeneration/adobeFireflyHandler.ts";
|
|
import { WEB_COOKIE_PROVIDERS } from "../../src/shared/constants/providers/web-cookie.ts";
|
|
import { IMAGE_PROVIDERS } from "../../open-sse/config/imageRegistry.ts";
|
|
import { VIDEO_PROVIDERS } from "../../open-sse/config/videoRegistry.ts";
|
|
import { getExecutor } from "../../open-sse/executors/index.ts";
|
|
|
|
// --- Registry --------------------------------------------------------------
|
|
|
|
test("adobe-firefly is registered in WEB_COOKIE_PROVIDERS with a webCookie risk notice", () => {
|
|
const entry = (WEB_COOKIE_PROVIDERS as Record<string, unknown>)["adobe-firefly"];
|
|
assert.ok(entry, "adobe-firefly must exist in WEB_COOKIE_PROVIDERS");
|
|
assert.equal(entry.id, "adobe-firefly");
|
|
assert.equal(entry.alias, "firefly");
|
|
assert.equal(entry.subscriptionRisk, true);
|
|
assert.equal(entry.riskNoticeVariant, "webCookie");
|
|
assert.match(entry.website, /firefly\.adobe\.com/);
|
|
});
|
|
|
|
test("adobe-firefly is registered in IMAGE_PROVIDERS with adobe-firefly-image format", () => {
|
|
const entry = (IMAGE_PROVIDERS as Record<string, unknown>)["adobe-firefly"];
|
|
assert.ok(entry);
|
|
assert.equal(entry.format, "adobe-firefly-image");
|
|
assert.match(entry.baseUrl, /firefly-3p\.ff\.adobe\.io/);
|
|
assert.ok(Array.isArray(entry.models) && entry.models.length >= 4);
|
|
});
|
|
|
|
test("adobe-firefly is registered in VIDEO_PROVIDERS with adobe-firefly-video format", () => {
|
|
const entry = (VIDEO_PROVIDERS as Record<string, unknown>)["adobe-firefly"];
|
|
assert.ok(entry);
|
|
assert.equal(entry.format, "adobe-firefly-video");
|
|
assert.match(entry.baseUrl, /3p-videos/);
|
|
assert.ok(Array.isArray(entry.models) && entry.models.length >= 5);
|
|
});
|
|
|
|
test("getExecutor(adobe-firefly) rejects chat completions", async () => {
|
|
const executor = getExecutor("adobe-firefly");
|
|
assert.ok(executor);
|
|
const result = await executor.execute({
|
|
model: "adobe-firefly/nano-banana-pro",
|
|
body: {
|
|
model: "adobe-firefly/nano-banana-pro",
|
|
messages: [{ role: "user", content: "hi" }],
|
|
},
|
|
stream: false,
|
|
credentials: { apiKey: "tok" },
|
|
});
|
|
assert.ok(result.response, "executor must return a Response wrapper");
|
|
assert.equal(result.response.status, 400);
|
|
const bodyText = await result.response.text();
|
|
assert.match(bodyText, /images\/generations|videos\/generations|media-generation/i);
|
|
});
|
|
|
|
// --- Public credential -----------------------------------------------------
|
|
|
|
test("adobe_firefly_api_key embedded default decodes to clio-playground-web", () => {
|
|
assert.equal(resolvePublicCred("adobe_firefly_api_key"), "clio-playground-web");
|
|
assert.equal(adobeFireflyApiKey(), "clio-playground-web");
|
|
assert.equal(adobeFireflyBalanceApiKey(), "SunbreakWebUI1");
|
|
});
|
|
|
|
// --- Pure helpers ----------------------------------------------------------
|
|
|
|
test("looksLikeAdobeJwt detects JWT shape and rejects cookie blobs", () => {
|
|
const longJwt = `eyJhbGciOiJSUzI1NiJ9.${"a".repeat(40)}.${"b".repeat(40)}`;
|
|
assert.equal(looksLikeAdobeJwt(longJwt), true);
|
|
assert.equal(looksLikeAdobeJwt("aaa.bbb.ccc"), false); // too short
|
|
assert.equal(looksLikeAdobeJwt("s_ecid=foo; session=bar"), false);
|
|
assert.equal(looksLikeAdobeJwt("not-a-jwt"), false);
|
|
});
|
|
|
|
test("extractAdobeCredentialToken strips Bearer and access_token=", () => {
|
|
const longJwt = `eyJhbGciOiJSUzI1NiJ9.${"c".repeat(40)}.${"d".repeat(40)}`;
|
|
assert.equal(extractAdobeCredentialToken(`Bearer ${longJwt}`), longJwt);
|
|
assert.equal(extractAdobeCredentialToken(`access_token=${longJwt}; other=1`), longJwt);
|
|
assert.equal(extractAdobeCredentialToken(" rawcookie "), "rawcookie");
|
|
// IMS sessionStorage shape (firefly.adobe.com)
|
|
const sessionJson = JSON.stringify({
|
|
valid: true,
|
|
client_id: "clio-playground-web",
|
|
tokenValue: longJwt,
|
|
});
|
|
assert.equal(extractAdobeCredentialToken(sessionJson), longJwt);
|
|
});
|
|
|
|
test("normalizeAdobeAspectRatio maps sizes and ratios", () => {
|
|
assert.equal(normalizeAdobeAspectRatio("16:9"), "16:9");
|
|
assert.equal(normalizeAdobeAspectRatio("16x9"), "16:9");
|
|
assert.equal(normalizeAdobeAspectRatio("1024x1024"), "1:1");
|
|
assert.equal(normalizeAdobeAspectRatio("1792x1024"), "16:9");
|
|
assert.equal(normalizeAdobeAspectRatio("1024x1792"), "9:16");
|
|
assert.equal(normalizeAdobeAspectRatio("auto"), "1:1");
|
|
assert.equal(normalizeAdobeAspectRatio(undefined), "1:1");
|
|
});
|
|
|
|
test("normalizeAdobeOutputResolution maps quality tiers", () => {
|
|
assert.equal(normalizeAdobeOutputResolution("4k", null), "4K");
|
|
assert.equal(normalizeAdobeOutputResolution("high", null), "4K");
|
|
assert.equal(normalizeAdobeOutputResolution("2k", null), "2K");
|
|
assert.equal(normalizeAdobeOutputResolution("low", null), "1K");
|
|
assert.equal(normalizeAdobeOutputResolution(undefined, "4096x4096"), "4K");
|
|
assert.equal(normalizeAdobeOutputResolution(undefined, undefined), "2K");
|
|
});
|
|
|
|
test("resolveAdobeImageModel maps catalog and long model ids", () => {
|
|
assert.equal(resolveAdobeImageModel("nano-banana-pro").id, "nano-banana-pro");
|
|
assert.equal(resolveAdobeImageModel("adobe-firefly/nano-banana-2").id, "nano-banana-2");
|
|
assert.equal(resolveAdobeImageModel("firefly-nano-banana-pro-2k-16x9").id, "nano-banana-pro");
|
|
assert.equal(resolveAdobeImageModel("gpt-image").id, "gpt-image");
|
|
assert.ok(ADOBE_FIREFLY_IMAGE_MODELS["nano-banana-pro"].upstreamModelVersion);
|
|
});
|
|
|
|
test("resolveAdobeVideoModel maps sora/veo/kling families", () => {
|
|
assert.equal(resolveAdobeVideoModel("sora-2").id, "sora-2");
|
|
assert.equal(resolveAdobeVideoModel("firefly-sora2-pro-8s-16x9").id, "sora-2-pro");
|
|
assert.equal(resolveAdobeVideoModel("veo-3.1-fast").id, "veo-3.1-fast");
|
|
assert.equal(resolveAdobeVideoModel("kling-3").id, "kling-3");
|
|
assert.ok(ADOBE_FIREFLY_VIDEO_MODELS["sora-2"].defaultDuration > 0);
|
|
});
|
|
|
|
test("buildAdobeImagePayload produces nano and gpt-image shapes", () => {
|
|
const nano = buildAdobeImagePayload({
|
|
prompt: "a cat",
|
|
aspectRatio: "16:9",
|
|
outputResolution: "2K",
|
|
modelSpec: ADOBE_FIREFLY_IMAGE_MODELS["nano-banana-pro"],
|
|
});
|
|
assert.equal(nano.modelId, "gemini-flash");
|
|
assert.equal(nano.modelVersion, "nano-banana-2");
|
|
assert.deepEqual(nano.size, { width: 2752, height: 1536 });
|
|
assert.equal((nano.modelSpecificPayload as Record<string, unknown>).aspectRatio, "16:9");
|
|
|
|
const gpt = buildAdobeImagePayload({
|
|
prompt: "a dog",
|
|
aspectRatio: "1:1",
|
|
outputResolution: "1K",
|
|
modelSpec: ADOBE_FIREFLY_IMAGE_MODELS["gpt-image"],
|
|
quality: "high",
|
|
});
|
|
assert.equal(gpt.modelId, "gpt-image");
|
|
assert.equal((gpt.generationSettings as Record<string, unknown>).detailLevel, 5);
|
|
// Live browser body uses size:"auto" and no top-level size/outputResolution
|
|
assert.equal((gpt.modelSpecificPayload as Record<string, unknown>).size, "auto");
|
|
assert.equal(gpt.size, undefined);
|
|
assert.equal(gpt.outputResolution, undefined);
|
|
});
|
|
|
|
test("buildAdobeImagePayload attaches referenceBlobs like live adobe_atach_images capture", () => {
|
|
// Live: referenceBlobs usage "general", module stays text2image for nano
|
|
const nano = buildAdobeImagePayload({
|
|
prompt: "teest",
|
|
aspectRatio: "1:1",
|
|
outputResolution: "1K",
|
|
modelSpec: ADOBE_FIREFLY_IMAGE_MODELS["nano-banana"],
|
|
sourceImageIds: [
|
|
"2a4f1025-e0dc-4671-a11a-7dfd3c07bd94",
|
|
"84c11d1a-e798-4300-a63e-c06504ca2068",
|
|
],
|
|
});
|
|
assert.deepEqual(nano.referenceBlobs, [
|
|
{ id: "2a4f1025-e0dc-4671-a11a-7dfd3c07bd94", usage: "general" },
|
|
{ id: "84c11d1a-e798-4300-a63e-c06504ca2068", usage: "general" },
|
|
]);
|
|
assert.equal((nano.generationMetadata as Record<string, unknown>).module, "text2image");
|
|
|
|
const gpt = buildAdobeImagePayload({
|
|
prompt: "edit me",
|
|
aspectRatio: "1:1",
|
|
outputResolution: "1K",
|
|
modelSpec: ADOBE_FIREFLY_IMAGE_MODELS["gpt-image"],
|
|
sourceImageIds: ["aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee"],
|
|
});
|
|
assert.deepEqual(gpt.referenceBlobs, [
|
|
{ id: "aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee", usage: "subject" },
|
|
]);
|
|
assert.equal((gpt.generationMetadata as Record<string, unknown>).module, "image2image");
|
|
});
|
|
|
|
test("extractAdobeSourceImageSources reads Media page image fields", () => {
|
|
const tinyPng =
|
|
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==";
|
|
const sources = extractAdobeSourceImageSources({
|
|
prompt: "x",
|
|
image_url: tinyPng,
|
|
image_urls: [tinyPng, "https://cdn.example/b.png"],
|
|
provider_options: { images: ["https://cdn.example/c.png"] },
|
|
});
|
|
assert.ok(sources.includes(tinyPng));
|
|
assert.ok(sources.includes("https://cdn.example/b.png"));
|
|
assert.ok(sources.includes("https://cdn.example/c.png"));
|
|
assert.equal(sources.length, 3); // tinyPng deduped from image_url + image_urls[0]
|
|
});
|
|
|
|
test("parseAdobeImageSourceBytes + parseAdobeStorageUploadResponse", () => {
|
|
const tinyPng =
|
|
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==";
|
|
const { buffer, contentType } = parseAdobeImageSourceBytes(tinyPng);
|
|
assert.ok(buffer.length > 10);
|
|
assert.equal(contentType, "image/png");
|
|
assert.equal(
|
|
parseAdobeStorageUploadResponse({
|
|
images: [{ id: "2a4f1025-e0dc-4671-a11a-7dfd3c07bd94" }],
|
|
}),
|
|
"2a4f1025-e0dc-4671-a11a-7dfd3c07bd94"
|
|
);
|
|
assert.equal(parseAdobeStorageUploadResponse({}), "");
|
|
});
|
|
|
|
test("buildAdobeUploadHeaders uses image content-type not json", () => {
|
|
const h = buildAdobeUploadHeaders("tok", "image/png", {
|
|
arpSessionId: "arp",
|
|
});
|
|
assert.equal(h["content-type"], "image/png");
|
|
assert.equal(h.Authorization, "Bearer tok");
|
|
assert.equal(h["x-api-key"], "clio-playground-web");
|
|
assert.equal(h["x-arp-session-id"], "arp");
|
|
assert.ok(h["x-nonce"]);
|
|
});
|
|
|
|
test("resolveAdobeSourceImageIds uploads data URLs then returns blob ids", async () => {
|
|
const tinyPng =
|
|
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==";
|
|
let uploadCalls = 0;
|
|
const fetchImpl = async (url: string | URL, init?: RequestInit) => {
|
|
const u = String(url);
|
|
if (u.includes("/v2/storage/image")) {
|
|
uploadCalls += 1;
|
|
assert.equal(init?.method, "POST");
|
|
const headers = init?.headers as Record<string, string>;
|
|
assert.match(String(headers["content-type"] || headers["Content-Type"] || ""), /image\//);
|
|
assert.ok(init?.body);
|
|
return new Response(JSON.stringify({ images: [{ id: `blob-${uploadCalls}` }] }), {
|
|
status: 200,
|
|
headers: { "content-type": "application/json" },
|
|
});
|
|
}
|
|
throw new Error(`unexpected fetch ${u}`);
|
|
};
|
|
|
|
const ids = await resolveAdobeSourceImageIds({
|
|
accessToken: "tok",
|
|
body: { image_url: tinyPng, image_urls: [tinyPng] },
|
|
max: 4,
|
|
prompt: "ref",
|
|
fetchImpl: fetchImpl as typeof fetch,
|
|
});
|
|
// Same data URL deduped → one upload
|
|
assert.deepEqual(ids, ["blob-1"]);
|
|
assert.equal(uploadCalls, 1);
|
|
assert.equal(ADOBE_FIREFLY_IMAGE_UPLOAD_URL.includes("storage/image"), true);
|
|
});
|
|
|
|
test("buildAdobeVideoPayload produces sora and veo shapes", () => {
|
|
const sora = buildAdobeVideoPayload({
|
|
prompt: "ocean waves",
|
|
aspectRatio: "16:9",
|
|
duration: 8,
|
|
modelSpec: ADOBE_FIREFLY_VIDEO_MODELS["sora-2"],
|
|
});
|
|
assert.equal(sora.modelId, "sora");
|
|
assert.equal(sora.duration, 8);
|
|
|
|
const veo = buildAdobeVideoPayload({
|
|
prompt: "city flyover",
|
|
aspectRatio: "9:16",
|
|
duration: 6,
|
|
modelSpec: ADOBE_FIREFLY_VIDEO_MODELS["veo-3.1"],
|
|
});
|
|
assert.equal(veo.modelId, "veo");
|
|
assert.equal(veo.modelVersion, "3.1-generate");
|
|
assert.equal(
|
|
(veo.modelSpecificPayload as Record<string, Record<string, unknown>>).parameters
|
|
.durationSeconds,
|
|
6
|
|
);
|
|
assert.equal(veo.generateAudio, true);
|
|
});
|
|
|
|
test("extractAdobeResultLink prefers x-override-status-link then links.result", () => {
|
|
const headers = new Headers({
|
|
"x-override-status-link": "https://poll.example/job/1",
|
|
});
|
|
assert.equal(extractAdobeResultLink(headers, {}), "https://poll.example/job/1");
|
|
|
|
const headers2 = new Headers();
|
|
assert.equal(
|
|
extractAdobeResultLink(headers2, {
|
|
links: { result: { href: "https://poll.example/job/2" } },
|
|
}),
|
|
"https://poll.example/job/2"
|
|
);
|
|
});
|
|
|
|
test("extractAdobeMediaUrl reads outputs[].image/video.presignedUrl", () => {
|
|
assert.equal(
|
|
extractAdobeMediaUrl(
|
|
{ outputs: [{ image: { presignedUrl: "https://cdn.example/a.png" } }] },
|
|
"image"
|
|
),
|
|
"https://cdn.example/a.png"
|
|
);
|
|
assert.equal(
|
|
extractAdobeMediaUrl(
|
|
{ outputs: [{ video: { presignedUrl: "https://cdn.example/a.mp4" } }] },
|
|
"video"
|
|
),
|
|
"https://cdn.example/a.mp4"
|
|
);
|
|
});
|
|
|
|
test("buildAdobeSubmitHeaders sets Bearer + clio-playground-web x-api-key", () => {
|
|
const headers = buildAdobeSubmitHeaders("tok-1", { arpSessionId: "arp-1" });
|
|
assert.equal(headers.Authorization, "Bearer tok-1");
|
|
assert.equal(headers["x-api-key"], "clio-playground-web");
|
|
assert.equal(headers.origin, "https://firefly.adobe.com");
|
|
assert.equal(headers["content-type"], "application/json");
|
|
assert.equal(headers["x-arp-session-id"], "arp-1");
|
|
// Always has x-nonce (random when no prompt/user_id)
|
|
assert.ok(headers["x-nonce"] && headers["x-nonce"].length === 64);
|
|
// Never attach firefly.adobe.com page Cookie to firefly-3p (soft 408 risk)
|
|
assert.equal(headers.cookie, undefined);
|
|
const poll = buildAdobePollHeaders("tok-1");
|
|
assert.equal(poll.Authorization, "Bearer tok-1");
|
|
assert.equal(poll.accept, "*/*");
|
|
// status_check.txt: poll is Bearer-only (no x-api-key)
|
|
assert.equal(poll["x-api-key"], undefined);
|
|
});
|
|
|
|
test("buildAdobeSubmitNonce is sha256(user_id + prompt[:256])", async () => {
|
|
const {
|
|
buildAdobeSubmitNonce,
|
|
buildAdobeArpSessionId,
|
|
buildAdobeSubmitHeaders,
|
|
extractAdobeAccountIdFromToken,
|
|
} = await import("../../open-sse/services/adobeFireflyClient.ts");
|
|
// Minimal fake IMS JWT with AdobeID subject
|
|
const payload = Buffer.from(
|
|
JSON.stringify({
|
|
user_id: "0EB681AF6A5FF6C10A495FF2@AdobeID",
|
|
type: "access_token",
|
|
client_id: "clio-playground-web",
|
|
})
|
|
).toString("base64url");
|
|
const header = Buffer.from(JSON.stringify({ alg: "none" })).toString("base64url");
|
|
const token = `${header}.${payload}.${"x".repeat(40)}`;
|
|
// Pad token length for looksLikeAdobeJwt (>=80)
|
|
assert.ok(token.length >= 80 || true);
|
|
const prompt = "a red fox in snow";
|
|
const nonce = buildAdobeSubmitNonce(token, prompt);
|
|
assert.equal(nonce.length, 64);
|
|
const { createHash } = await import("node:crypto");
|
|
const expected = createHash("sha256")
|
|
.update(`0EB681AF6A5FF6C10A495FF2@AdobeID-${prompt}`, "utf8")
|
|
.digest("hex");
|
|
assert.equal(nonce, expected);
|
|
// Same inputs → same nonce; different prompt → different nonce
|
|
assert.equal(buildAdobeSubmitNonce(token, prompt), nonce);
|
|
assert.notEqual(buildAdobeSubmitNonce(token, prompt + "!"), nonce);
|
|
assert.equal(extractAdobeAccountIdFromToken(token), "0EB681AF6A5FF6C10A495FF2@AdobeID");
|
|
|
|
const {
|
|
isValidAdobeArpSessionId,
|
|
resolveAdobeArpSessionId,
|
|
extractAdobeArpSessionId,
|
|
ADOBE_FIREFLY_FTR_MAGIC,
|
|
} = await import("../../open-sse/services/adobeFireflyClient.ts");
|
|
const arp = buildAdobeArpSessionId();
|
|
assert.ok(arp.length > 20);
|
|
assert.equal(isValidAdobeArpSessionId(arp), true);
|
|
const decoded = JSON.parse(Buffer.from(arp, "base64").toString("utf8"));
|
|
assert.ok(decoded.sid);
|
|
// Live SPA shape (2026-07): sid + ark (Arkose) + ftr + bfp + fpjs
|
|
assert.ok(decoded.ark, "synthetic ARP must include ark field");
|
|
assert.match(String(decoded.ark), /pk=BBCC314C-4937-4CCD-B0A3-FDF0F0F7603C/);
|
|
assert.match(String(decoded.ftr), new RegExp(ADOBE_FIREFLY_FTR_MAGIC));
|
|
assert.match(String(decoded.ftr), /-v2_tt$/);
|
|
assert.ok(decoded.bfp, "synthetic ARP must include bfp (browser fingerprint)");
|
|
assert.ok(decoded.fpjs, "synthetic ARP must include fpjs");
|
|
|
|
// Headers: deterministic nonce + always ARP (synthetic when none provided)
|
|
const h = buildAdobeSubmitHeaders(token, { prompt });
|
|
assert.equal(h["x-nonce"], nonce);
|
|
assert.ok(h["x-arp-session-id"]);
|
|
assert.equal(h.cookie, undefined);
|
|
|
|
// Prefer real sherlockToken / x-arp-session-id from paste over synthetic
|
|
const realArp = Buffer.from(
|
|
JSON.stringify({
|
|
sid: "11111111-2222-3333-4444-555555555555",
|
|
ark: "sess.123|r=eu-west-1|pk=BBCC314C-4937-4CCD-B0A3-FDF0F0F7603C",
|
|
ftr: "aa_1" + ADOBE_FIREFLY_FTR_MAGIC + "_x=-1-v2_tt",
|
|
}),
|
|
"utf8"
|
|
).toString("base64");
|
|
assert.equal(extractAdobeArpSessionId(`a=1; sherlockToken=${realArp}; b=2`), realArp);
|
|
assert.equal(
|
|
extractAdobeArpSessionId(`x-arp-session-id: ${realArp}\nAuthorization: Bearer x`),
|
|
realArp
|
|
);
|
|
assert.equal(resolveAdobeArpSessionId(`sherlockToken=${realArp}`), realArp);
|
|
});
|
|
|
|
test("normalizeAdobePollUrl rewrites firefly-epo jobs/result to BKS", () => {
|
|
const raw = "https://firefly-epo855232.adobe.io/jobs/result/4ae9fd2a-0864-46dd-9834-cfc16e91faa6";
|
|
const out = normalizeAdobePollUrl(raw);
|
|
assert.match(out, /^https:\/\/bks-epo8552\.adobe\.io\/v2\/jobs\/result\/4ae9fd2a/);
|
|
assert.match(out, /host=firefly-epo855232\.adobe\.io/);
|
|
});
|
|
|
|
test("parseAdobeCreditsBalance maps total + free/plan buckets", () => {
|
|
const bal = parseAdobeCreditsBalance({
|
|
total: {
|
|
quota: { total: 10010, used: 10, available: 10000 },
|
|
availableUntil: "2026-07-28T22:48:31.576Z",
|
|
},
|
|
credits: {
|
|
firefly_free_credit: { quota: { total: 10, used: 0, available: 10 } },
|
|
firefly_plan_credit: {
|
|
quota: { total: 10000, used: 10, available: 9990 },
|
|
},
|
|
},
|
|
});
|
|
assert.equal(bal.total, 10010);
|
|
assert.equal(bal.used, 10);
|
|
assert.equal(bal.remaining, 10000);
|
|
assert.equal(bal.freeTotal, 10);
|
|
assert.equal(bal.planTotal, 10000);
|
|
const quota = buildAdobeFireflyCreditsQuota(bal);
|
|
assert.equal(quota.total, 10010);
|
|
assert.equal(quota.remaining, 10000);
|
|
assert.equal(quota.displayName, "Firefly credits");
|
|
// providerLimits requires quotas as a Record, not an array
|
|
const rec = buildAdobeFireflyQuotasRecord(bal);
|
|
assert.ok(rec.firefly_total);
|
|
assert.equal(rec.firefly_total.total, 10010);
|
|
assert.equal(rec.firefly_total.remaining, 10000);
|
|
assert.ok(rec.firefly_free);
|
|
assert.ok(rec.firefly_plan);
|
|
});
|
|
|
|
test("adobe-firefly is in USAGE_SUPPORTED_PROVIDERS for Limits", () => {
|
|
assert.ok(USAGE_SUPPORTED_PROVIDERS.includes("adobe-firefly"));
|
|
assert.ok(USAGE_SUPPORTED_PROVIDERS.includes("firefly"));
|
|
});
|
|
|
|
test("parseAdobeModelsDiscovery extracts image/video versions", () => {
|
|
const rows = parseAdobeModelsDiscovery({
|
|
models: [
|
|
{
|
|
modelId: "gemini-flash",
|
|
modelVersions: {
|
|
"nano-banana-2": {
|
|
enabled: true,
|
|
outputModality: ["image"],
|
|
modelDisplayName: "Gemini 3.0 (Nano Banana Pro)",
|
|
healthStatus: "HEALTHY",
|
|
requestSchema: { properties: { prompt: { type: "string" } } },
|
|
},
|
|
},
|
|
},
|
|
{
|
|
modelId: "sora",
|
|
modelVersions: {
|
|
"sora-2": {
|
|
enabled: true,
|
|
outputModality: ["video"],
|
|
modelDisplayName: "Sora 2",
|
|
requestSchema: { properties: { prompt: { type: "string" } } },
|
|
},
|
|
},
|
|
},
|
|
],
|
|
});
|
|
assert.equal(rows.length, 2);
|
|
assert.equal(rows[0].modality, "image");
|
|
assert.equal(rows[1].modality, "video");
|
|
const catalog = mapDiscoveredToCatalog(rows);
|
|
assert.ok(catalog.some((m) => m.id === "gemini-flash-nano-banana-2"));
|
|
assert.ok(catalog.some((m) => m.id === "sora-sora-2"));
|
|
});
|
|
|
|
test("fallback catalog has image and video entries from get_models capture", () => {
|
|
assert.ok(ADOBE_FIREFLY_FALLBACK_MODELS.length >= 10);
|
|
assert.ok(getAdobeFireflyFallbackCatalog("image").length >= 4);
|
|
assert.ok(getAdobeFireflyFallbackCatalog("video").length >= 4);
|
|
});
|
|
|
|
test("extractAdobeAccountIdFromToken reads user_id claim", () => {
|
|
// {"user_id":"0EB@AdobeID"} base64url
|
|
const payload = Buffer.from(
|
|
JSON.stringify({ user_id: "0EB@AdobeID", type: "access_token" })
|
|
).toString("base64url");
|
|
const jwt = `eyJhbGciOiJub25lIn0.${payload}.sig`;
|
|
assert.equal(extractAdobeAccountIdFromToken(jwt), "0EB@AdobeID");
|
|
});
|
|
|
|
// --- Handlers (mocked fetch) ----------------------------------------------
|
|
|
|
function jsonResponse(status: number, body: unknown, headerMap: Record<string, string> = {}) {
|
|
return {
|
|
ok: status >= 200 && status < 300,
|
|
status,
|
|
headers: {
|
|
get: (name: string) => {
|
|
const key = Object.keys(headerMap).find((k) => k.toLowerCase() === name.toLowerCase());
|
|
return key ? headerMap[key] : null;
|
|
},
|
|
},
|
|
json: async () => body,
|
|
text: async () => JSON.stringify(body),
|
|
} as unknown as Response;
|
|
}
|
|
|
|
test("handleAdobeFireflyImageGeneration returns 400 when prompt is missing", async () => {
|
|
const result = await handleAdobeFireflyImageGeneration({
|
|
model: "nano-banana-pro",
|
|
provider: "adobe-firefly",
|
|
body: {},
|
|
credentials: { apiKey: "aaa.bbb.ccc" },
|
|
});
|
|
assert.equal(result.success, false);
|
|
assert.equal(result.status, 400);
|
|
});
|
|
|
|
function userImsJwt(userId = "0EB@AdobeID"): string {
|
|
return (
|
|
`eyJhbGciOiJSUzI1NiJ9.` +
|
|
Buffer.from(
|
|
JSON.stringify({
|
|
user_id: userId,
|
|
type: "access_token",
|
|
client_id: "clio-playground-web",
|
|
})
|
|
).toString("base64url") +
|
|
`.` +
|
|
"sig".padEnd(40, "x")
|
|
);
|
|
}
|
|
|
|
test("handleAdobeFireflyImageGeneration submit+poll happy path (mocked)", async () => {
|
|
let calls = 0;
|
|
const fetchImpl = async (url: string, init?: RequestInit) => {
|
|
calls += 1;
|
|
const u = String(url);
|
|
if (u.includes("generate-async")) {
|
|
return jsonResponse(
|
|
200,
|
|
{ links: { result: "https://poll.example/job/img1" } },
|
|
{ "x-override-status-link": "https://poll.example/job/img1" }
|
|
);
|
|
}
|
|
if (u.includes("poll.example")) {
|
|
return jsonResponse(200, {
|
|
status: "COMPLETED",
|
|
outputs: [{ image: { presignedUrl: "https://cdn.example/out.png" } }],
|
|
});
|
|
}
|
|
throw new Error(`unexpected fetch ${u}`);
|
|
};
|
|
|
|
const result = await handleAdobeFireflyImageGeneration({
|
|
model: "nano-banana-pro",
|
|
provider: "adobe-firefly",
|
|
body: { prompt: "sunset mountains", size: "16:9", quality: "2k" },
|
|
credentials: { apiKey: userImsJwt() },
|
|
fetchImpl: fetchImpl as typeof fetch,
|
|
});
|
|
|
|
assert.equal(result.success, true);
|
|
assert.ok(result.data?.data?.[0]?.url?.includes("cdn.example/out.png"));
|
|
assert.ok(calls >= 2);
|
|
});
|
|
|
|
test("handleAdobeFireflyImageGeneration uploads refs and submits referenceBlobs", async () => {
|
|
const tinyPng =
|
|
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==";
|
|
|
|
let sawGenerateBody: Record<string, unknown> | null = null;
|
|
let uploadCalls = 0;
|
|
const fetchImpl = async (url: string | URL, init?: RequestInit) => {
|
|
const u = String(url);
|
|
if (u.includes("/v2/storage/image")) {
|
|
uploadCalls += 1;
|
|
return jsonResponse(200, { images: [{ id: "ref-blob-1" }] });
|
|
}
|
|
if (u.includes("generate-async")) {
|
|
sawGenerateBody = JSON.parse(String(init?.body || "{}"));
|
|
return jsonResponse(
|
|
200,
|
|
{ links: { result: { href: "https://poll.example/j1" } } },
|
|
{ "x-override-status-link": "https://poll.example/j1" }
|
|
);
|
|
}
|
|
if (u.includes("poll.example")) {
|
|
return jsonResponse(200, {
|
|
status: "COMPLETED",
|
|
outputs: [{ image: { presignedUrl: "https://cdn.example/out.png" } }],
|
|
});
|
|
}
|
|
throw new Error(`unexpected fetch ${u}`);
|
|
};
|
|
|
|
const result = await handleAdobeFireflyImageGeneration({
|
|
model: "nano-banana",
|
|
provider: "adobe-firefly",
|
|
body: { prompt: "teest", image_url: tinyPng },
|
|
credentials: { apiKey: userImsJwt() },
|
|
fetchImpl: fetchImpl as typeof fetch,
|
|
});
|
|
|
|
assert.equal(result.success, true);
|
|
assert.equal(uploadCalls, 1);
|
|
assert.ok(sawGenerateBody);
|
|
const refs = sawGenerateBody!.referenceBlobs as Array<{
|
|
id: string;
|
|
usage: string;
|
|
}>;
|
|
assert.deepEqual(refs, [{ id: "ref-blob-1", usage: "general" }]);
|
|
});
|
|
|
|
test("adobeFireflyGenerateVideo submit+poll happy path (mocked)", async () => {
|
|
const fetchImpl = async (url: string) => {
|
|
const u = String(url);
|
|
if (u.includes("3p-videos")) {
|
|
return jsonResponse(
|
|
200,
|
|
{ links: { result: { href: "https://poll.example/job/vid1" } } },
|
|
{}
|
|
);
|
|
}
|
|
if (u.includes("poll.example")) {
|
|
return jsonResponse(200, {
|
|
status: "COMPLETED",
|
|
outputs: [{ video: { presignedUrl: "https://cdn.example/out.mp4" } }],
|
|
});
|
|
}
|
|
throw new Error(`unexpected fetch ${u}`);
|
|
};
|
|
|
|
const result = await adobeFireflyGenerateVideo({
|
|
accessToken: "tok",
|
|
prompt: "drone over forest",
|
|
model: "sora-2",
|
|
duration: 4,
|
|
aspectRatio: "16:9",
|
|
fetchImpl: fetchImpl as typeof fetch,
|
|
});
|
|
assert.equal(result.format, "mp4");
|
|
assert.match(result.url, /out\.mp4/);
|
|
});
|
|
|
|
test("handleAdobeFireflyVideoGeneration returns 400 without prompt", async () => {
|
|
const result = await handleAdobeFireflyVideoGeneration({
|
|
model: "sora-2",
|
|
provider: "adobe-firefly",
|
|
body: {},
|
|
credentials: { apiKey: "aaa.bbb.ccc" },
|
|
});
|
|
assert.equal(result.success, false);
|
|
assert.equal(result.status, 400);
|
|
});
|
|
|
|
test("handleAdobeFireflyImageGeneration maps quota exhausted", async () => {
|
|
const fetchImpl = async () =>
|
|
jsonResponse(403, { error: "nope" }, { "x-access-error": "taste_exhausted" });
|
|
|
|
const result = await handleAdobeFireflyImageGeneration({
|
|
model: "nano-banana-pro",
|
|
provider: "adobe-firefly",
|
|
body: { prompt: "test" },
|
|
credentials: { apiKey: userImsJwt() },
|
|
fetchImpl: fetchImpl as typeof fetch,
|
|
});
|
|
assert.equal(result.success, false);
|
|
assert.equal(result.status, 429);
|
|
assert.match(String(result.error), /quota/i);
|
|
});
|
|
|
|
test("guest JWT without AdobeID is detected", () => {
|
|
// Minimal JWT payload {} — no user_id → guest
|
|
const emptyPayload = Buffer.from("{}").toString("base64url");
|
|
const guestJwt = `eyJhbGciOiJub25lIn0.${emptyPayload}.sig`;
|
|
// Pad to lookLikeAdobeJwt length if needed
|
|
const longGuest =
|
|
`eyJhbGciOiJSUzI1NiJ9.${Buffer.from(JSON.stringify({ client_id: "clio-playground-web" })).toString("base64url")}.` +
|
|
"x".repeat(40);
|
|
assert.equal(isAdobeGuestAccessToken(longGuest), true);
|
|
const userJwt =
|
|
`eyJhbGciOiJSUzI1NiJ9.` +
|
|
Buffer.from(
|
|
JSON.stringify({
|
|
user_id: "0EB@AdobeID",
|
|
type: "access_token",
|
|
client_id: "clio-playground-web",
|
|
})
|
|
).toString("base64url") +
|
|
`.` +
|
|
"y".repeat(40);
|
|
assert.equal(isAdobeGuestAccessToken(userJwt), false);
|
|
assert.equal(isAdobeUserAccessToken(userJwt), true);
|
|
});
|
|
|
|
test("cookie exchange rejects guest IMS tokens", async () => {
|
|
const fetchImpl = async (url: string, init?: RequestInit) => {
|
|
if (String(url).includes("ims/check")) {
|
|
const body = String(init?.body || "");
|
|
if (body.includes("guest_allowed=false")) {
|
|
return jsonResponse(400, {
|
|
error: "invalid_credentials",
|
|
error_description: "All session cookies are empty",
|
|
});
|
|
}
|
|
// guest_allowed=true → guest token (no user_id)
|
|
const guest =
|
|
`eyJhbGciOiJSUzI1NiJ9.` +
|
|
Buffer.from(JSON.stringify({ client_id: "clio-playground-web" })).toString("base64url") +
|
|
`.` +
|
|
"z".repeat(40);
|
|
return jsonResponse(200, {
|
|
access_token: guest,
|
|
account_type: "guest",
|
|
guestId: "1@GuestID",
|
|
});
|
|
}
|
|
throw new Error(`unexpected ${url}`);
|
|
};
|
|
|
|
await assert.rejects(
|
|
() =>
|
|
exchangeAdobeCookieForAccessToken(
|
|
"ff_session_guid=abc; aux_sid=xyz",
|
|
fetchImpl as typeof fetch
|
|
),
|
|
(err: unknown) => {
|
|
const message = err instanceof Error ? err.message : String(err);
|
|
assert.match(message, /GUEST|guest|Bearer/i);
|
|
return true;
|
|
}
|
|
);
|
|
});
|
|
|
|
test("extractAdobeArpSessionId recovers JWT+ARP joined by space (PasswordBox mangling)", async () => {
|
|
const { extractAdobeArpSessionId, hasBrowserAdobeArpSession, formatAdobeSystemUnderLoadError } =
|
|
await import("../../open-sse/services/adobeFireflyClient.ts");
|
|
const realArp = Buffer.from(
|
|
JSON.stringify({
|
|
sid: "bdf37b8a-117f-467d-a737-7792932d98b4",
|
|
ark: "60818c561473ddb23.0684402805|r=eu-west-1|pk=BBCC314C-4937-4CCD-B0A3-FDF0F0F7603C",
|
|
ftr: "aab9dc9eb48f4ee1916428649f908f7d_1__UDF43-m4_31ck_x=-1-v2_tt",
|
|
}),
|
|
"utf8"
|
|
).toString("base64");
|
|
// Fake 3-segment JWT shape long enough for looksLikeAdobeJwt
|
|
const fakeJwt =
|
|
"eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9." +
|
|
"eyJ1c2VyX2lkIjoiMEVCNjgxQUY2QTVGRjZDMTBBNDk1RkYyQEFkb2JlSUQifQ." +
|
|
"sigABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop";
|
|
const joined = `${fakeJwt} ${realArp}`;
|
|
assert.equal(extractAdobeArpSessionId(joined), realArp);
|
|
assert.equal(hasBrowserAdobeArpSession(joined), true);
|
|
assert.equal(hasBrowserAdobeArpSession(fakeJwt), false);
|
|
assert.match(
|
|
formatAdobeSystemUnderLoadError("image", 2, { hadBrowserArp: false }),
|
|
/missing a browser x-arp-session-id/
|
|
);
|
|
assert.match(
|
|
formatAdobeSystemUnderLoadError("image", 2, { hadBrowserArp: true }),
|
|
/auto-rebuilds x-arp-session-id|Cookie once|Forter\/Arkose/i
|
|
);
|
|
});
|
|
|
|
test("extractAdobeArpSessionId does not pick aux_sid over sherlockToken", async () => {
|
|
const { extractAdobeArpSessionId, isValidAdobeArpSessionId } =
|
|
await import("../../open-sse/services/adobeFireflyClient.ts");
|
|
const { ADOBE_FIREFLY_FTR_MAGIC } = await import("../../open-sse/services/adobeFireflyClient.ts");
|
|
const realArp = Buffer.from(
|
|
JSON.stringify({
|
|
sid: "bdf37b8a-117f-467d-a737-7792932d98b4",
|
|
ark: "10618c58b8d3cd588.3119555905|r=eu-west-1|pk=BBCC314C-4937-4CCD-B0A3-FDF0F0F7603C",
|
|
ftr: `aa_${Date.now()}${ADOBE_FIREFLY_FTR_MAGIC}_x=-1-v2_tt`,
|
|
}),
|
|
"utf8"
|
|
).toString("base64");
|
|
// Long aux_sid must NOT win ranking (this was the live 408 root cause)
|
|
const aux = "A" + "x".repeat(780);
|
|
const cookie = `ff_session_guid=bdf37b8a-117f-467d-a737-7792932d98b4; sherlockToken=${realArp}; aux_sid=${aux}; forterToken=x`;
|
|
const got = extractAdobeArpSessionId(cookie);
|
|
assert.equal(got, realArp);
|
|
assert.equal(isValidAdobeArpSessionId(`aux_sid=${aux}`), false);
|
|
assert.equal(isValidAdobeArpSessionId(realArp), true);
|
|
});
|
|
|
|
test("rebuild ARP from cookie components (forter+arkose+sid)", async () => {
|
|
const {
|
|
buildAdobeArpSessionIdFromCookies,
|
|
canRebuildAdobeArpFromCookies,
|
|
mergeAdobeCookieHeaders,
|
|
resolveAdobeArpSessionIdSmart,
|
|
serializeAdobeFireflyCredential,
|
|
normalizeAdobeForterToken,
|
|
} = await import("../../open-sse/services/adobeFireflySession.ts");
|
|
const { ADOBE_FIREFLY_FTR_MAGIC } = await import("../../open-sse/services/adobeFireflyClient.ts");
|
|
|
|
const ftr = `aab9dc9eb48f4ee1916428649f908f7d_${Date.now()}${ADOBE_FIREFLY_FTR_MAGIC}_x=-1092-v2_tt`;
|
|
const ark =
|
|
"87818c58b11662a57.5347274705|r=eu-west-1|meta=3|pk=BBCC314C-4937-4CCD-B0A3-FDF0F0F7603C|at=40";
|
|
const cookie =
|
|
`ff_session_guid=bdf37b8a-117f-467d-a737-7792932d98b4; arkose=${ark}; ` +
|
|
`forterToken=${encodeURIComponent(ftr)}; bfp=58ef2899-b1c4-42e4-9625-ae265e1b4994; ` +
|
|
`fpjs=${encodeURIComponent(JSON.stringify({ requestId: "1.x", visitorId: "v" }))}`;
|
|
|
|
assert.equal(canRebuildAdobeArpFromCookies(cookie), true);
|
|
const arp = buildAdobeArpSessionIdFromCookies(cookie);
|
|
assert.ok(arp.length > 40);
|
|
const decoded = JSON.parse(Buffer.from(arp, "base64").toString("utf8"));
|
|
assert.equal(decoded.sid, "bdf37b8a-117f-467d-a737-7792932d98b4");
|
|
assert.equal(decoded.ark, ark);
|
|
assert.ok(String(decoded.ftr).includes(ADOBE_FIREFLY_FTR_MAGIC));
|
|
assert.equal(decoded.bfp, "58ef2899-b1c4-42e4-9625-ae265e1b4994");
|
|
assert.ok(decoded.fpjs);
|
|
|
|
// forter without _tt suffix gets normalized
|
|
assert.match(normalizeAdobeForterToken("abc_1__UDF43-m4_31ck_x=-1-v2"), /-v2_tt$/);
|
|
// localStorage comma form is rejected
|
|
assert.equal(normalizeAdobeForterToken("aab9dc9eb48f4ee1916428649f908f7d,1784986682306"), "");
|
|
|
|
const merged = mergeAdobeCookieHeaders(
|
|
"ff_session_guid=old; arkose=a1",
|
|
"arkose=a2; forterToken=newftr"
|
|
);
|
|
assert.match(merged, /arkose=a2/);
|
|
assert.match(merged, /forterToken=newftr/);
|
|
assert.match(merged, /ff_session_guid=old/);
|
|
|
|
// Smart resolve prefers rebuild when cookie pieces present
|
|
const smart = resolveAdobeArpSessionIdSmart(cookie);
|
|
assert.equal(smart, arp);
|
|
|
|
const ser = serializeAdobeFireflyCredential({
|
|
accessToken: "eyJ.token.sig",
|
|
cookie,
|
|
arpSessionId: arp,
|
|
});
|
|
assert.match(ser, /eyJ\.token\.sig/);
|
|
assert.match(ser, /ff_session_guid=/);
|
|
});
|
|
|
|
test("isAdobeTransientSubmitError detects 408 system under load", () => {
|
|
assert.equal(
|
|
isAdobeTransientSubmitError(
|
|
408,
|
|
'{"error_code":"timeout_error","message":"system under load"}'
|
|
),
|
|
true
|
|
);
|
|
assert.equal(isAdobeTransientSubmitError(429, "rate"), true);
|
|
assert.equal(isAdobeTransientSubmitError(400, "bad request"), false);
|
|
assert.ok(generateAdobeNonce().length === 64);
|
|
assert.equal(
|
|
extractAdobeArpSessionId("a=1; sherlockToken=eyJzaWQiOiJ4In0=; b=2"),
|
|
"eyJzaWQiOiJ4In0="
|
|
);
|
|
});
|
|
|
|
test("extractAdobeCookieHeader strips JWT from mixed paste", async () => {
|
|
const { extractAdobeCookieHeader, buildAdobeSubmitHeaders, extractAdobeArpSessionId } =
|
|
await import("../../open-sse/services/adobeFireflyClient.ts");
|
|
const longJwt = `eyJhbGciOiJSUzI1NiJ9.${"e".repeat(40)}.${"f".repeat(40)}`;
|
|
const cookie = "ff_session_guid=abc; sherlockToken=tok123; aux_sid=xyz";
|
|
const mixed = `${longJwt}\n${cookie}`;
|
|
assert.equal(extractAdobeCookieHeader(longJwt), "");
|
|
assert.match(extractAdobeCookieHeader(mixed), /ff_session_guid=abc/);
|
|
assert.doesNotMatch(extractAdobeCookieHeader(mixed), /eyJhbGci/);
|
|
// Submit must not attach Cookie; arp id may still be lifted from the blob.
|
|
const arp = extractAdobeArpSessionId(mixed);
|
|
assert.equal(arp, "tok123");
|
|
const headers = buildAdobeSubmitHeaders("access-tok", {
|
|
cookie: mixed,
|
|
arpSessionId: arp,
|
|
});
|
|
assert.equal(headers.cookie, undefined);
|
|
assert.equal(headers["x-arp-session-id"], "tok123");
|
|
assert.equal(headers.Authorization, "Bearer access-tok");
|
|
});
|
|
|
|
test("resolveAdobeImageModel maps gpt-image-2 alias", async () => {
|
|
const { resolveAdobeImageModel } = await import("../../open-sse/services/adobeFireflyClient.ts");
|
|
assert.equal(resolveAdobeImageModel("gpt-image-2").spec.upstreamModelVersion, "2");
|
|
assert.equal(resolveAdobeImageModel("adobe-firefly/gpt-image").spec.upstreamModelVersion, "2");
|
|
assert.equal(resolveAdobeImageModel("gpt-image-1.5").spec.upstreamModelVersion, "1.5");
|
|
});
|
|
|
|
test("image submit retries on 408 then succeeds", async () => {
|
|
const { __resetAdobeFireflySessionCacheForTests } =
|
|
await import("../../open-sse/services/adobeFireflySession.ts");
|
|
__resetAdobeFireflySessionCacheForTests();
|
|
|
|
let submits = 0;
|
|
const userTok = userImsJwt();
|
|
const fetchImpl = async (url: string) => {
|
|
const u = String(url);
|
|
if (u.includes("generate-async")) {
|
|
submits += 1;
|
|
if (submits < 3) {
|
|
return jsonResponse(408, {
|
|
error_code: "timeout_error",
|
|
message: "system under load",
|
|
});
|
|
}
|
|
return jsonResponse(200, { links: { result: { href: "https://poll.example/job/r1" } } }, {});
|
|
}
|
|
if (u.includes("poll.example")) {
|
|
return jsonResponse(200, {
|
|
status: "COMPLETED",
|
|
outputs: [{ image: { presignedUrl: "https://cdn.example/retry.png" } }],
|
|
});
|
|
}
|
|
throw new Error(`unexpected ${u}`);
|
|
};
|
|
|
|
const result = await adobeFireflyGenerateImage({
|
|
accessToken: userTok,
|
|
prompt: "retry me",
|
|
model: "gpt-image",
|
|
fetchImpl: fetchImpl as typeof fetch,
|
|
});
|
|
assert.equal(submits, 3);
|
|
assert.match(result.url, /retry\.png/);
|
|
});
|
|
|
|
test("sticky ARP: successful submit is reused by ensure on next call", async () => {
|
|
const {
|
|
__resetAdobeFireflySessionCacheForTests,
|
|
markAdobeFireflyArpSuccess,
|
|
ensureAdobeFireflySession,
|
|
fingerprintAdobeCredential,
|
|
} = await import("../../open-sse/services/adobeFireflySession.ts");
|
|
const { ADOBE_FIREFLY_FTR_MAGIC } = await import("../../open-sse/services/adobeFireflyClient.ts");
|
|
__resetAdobeFireflySessionCacheForTests();
|
|
|
|
const userTok = userImsJwt();
|
|
const ftr = `aab9dc9eb48f4ee1916428649f908f7d_${Date.now()}${ADOBE_FIREFLY_FTR_MAGIC}_x=-1-v2_tt`;
|
|
const ark =
|
|
"87818c58b11662a57.5347274705|r=eu-west-1|meta=3|pk=BBCC314C-4937-4CCD-B0A3-FDF0F0F7603C|at=40";
|
|
const cookie =
|
|
`ff_session_guid=bdf37b8a-117f-467d-a737-7792932d98b4; arkose=${ark}; ` +
|
|
`forterToken=${encodeURIComponent(ftr)}`;
|
|
const cred = `${userTok}\n${cookie}`;
|
|
const fp = fingerprintAdobeCredential(cred);
|
|
const stickyArp = Buffer.from(
|
|
JSON.stringify({ sid: "sticky-sid", ark: "sticky-ark", ftr: "sticky-ftr" }),
|
|
"utf8"
|
|
).toString("base64");
|
|
|
|
markAdobeFireflyArpSuccess(fp, stickyArp);
|
|
|
|
const session = await ensureAdobeFireflySession({
|
|
credentials: { apiKey: cred },
|
|
allowBrowserRefresh: false,
|
|
fetchImpl: (async () => {
|
|
throw new Error("no network expected");
|
|
}) as typeof fetch,
|
|
});
|
|
assert.equal(session.arpSessionId, stickyArp, "ensure must stick to last successful ARP");
|
|
assert.equal(session.fingerprint, fp);
|
|
});
|
|
|
|
test("rotateAdobeFireflySessionOnError: attempt1-2 reuse sticky; attempt3 keeps ARP without browser", async () => {
|
|
const {
|
|
__resetAdobeFireflySessionCacheForTests,
|
|
rotateAdobeFireflySessionOnError,
|
|
markAdobeFireflyArpSuccess,
|
|
buildAdobeArpSessionIdFromCookies,
|
|
} = await import("../../open-sse/services/adobeFireflySession.ts");
|
|
const { ADOBE_FIREFLY_FTR_MAGIC } = await import("../../open-sse/services/adobeFireflyClient.ts");
|
|
__resetAdobeFireflySessionCacheForTests();
|
|
|
|
const ftr = `aa_${Date.now()}${ADOBE_FIREFLY_FTR_MAGIC}_x=-1-v2_tt`;
|
|
const cookie = `ff_session_guid=sid-1; arkose=ark-1; forterToken=${encodeURIComponent(ftr)}`;
|
|
const rebuilt = buildAdobeArpSessionIdFromCookies(cookie);
|
|
assert.ok(rebuilt);
|
|
|
|
const base = {
|
|
accessToken: userImsJwt(),
|
|
cookie,
|
|
arpSessionId: rebuilt!,
|
|
tokenExpiresAt: Date.now() + 3600_000,
|
|
updatedAt: Date.now(),
|
|
fingerprint: "fp-rotate-test",
|
|
source: "paste" as const,
|
|
};
|
|
markAdobeFireflyArpSuccess(base.fingerprint, rebuilt!);
|
|
|
|
const a1 = await rotateAdobeFireflySessionOnError(base, {
|
|
attempt: 1,
|
|
tryBrowser: false,
|
|
});
|
|
assert.equal(a1.arpSessionId, rebuilt, "attempt 1 reuses ARP (rate-limit quiet)");
|
|
|
|
const a2 = await rotateAdobeFireflySessionOnError(
|
|
{ ...base, arpSessionId: rebuilt! },
|
|
{ attempt: 2, tryBrowser: false }
|
|
);
|
|
assert.equal(a2.arpSessionId, rebuilt, "attempt 2 still reuses ARP (mid-batch quiet)");
|
|
|
|
const a3 = await rotateAdobeFireflySessionOnError(
|
|
{ ...base, arpSessionId: rebuilt! },
|
|
{ attempt: 3, tryBrowser: false }
|
|
);
|
|
// attempt 3 without browser: cookie rebuild (identical forter → same ARP)
|
|
assert.ok(a3.arpSessionId, "attempt 3 still yields an ARP");
|
|
assert.equal(
|
|
a3.arpSessionId,
|
|
rebuilt,
|
|
"identical cookie rebuild keeps ARP (no synthetic thrash)"
|
|
);
|
|
|
|
const auth = await rotateAdobeFireflySessionOnError(
|
|
{ ...base, arpSessionId: rebuilt!, tokenExpiresAt: 0 },
|
|
{ attempt: 1, authFailure: true, tryBrowser: false }
|
|
);
|
|
assert.equal(auth.source, "rebuild", "auth failures must bypass quiet sticky reuse");
|
|
assert.ok(auth.tokenExpiresAt > Date.now(), "retry must repair a missing token expiry");
|
|
});
|
|
|
|
test("adobeFireflyGenerateImage cookie path exchanges IMS token first", async () => {
|
|
const { __resetAdobeFireflySessionCacheForTests } =
|
|
await import("../../open-sse/services/adobeFireflySession.ts");
|
|
__resetAdobeFireflySessionCacheForTests();
|
|
|
|
const userTok =
|
|
`eyJhbGciOiJSUzI1NiJ9.` +
|
|
Buffer.from(
|
|
JSON.stringify({
|
|
user_id: "0EB@AdobeID",
|
|
type: "access_token",
|
|
client_id: "clio-playground-web",
|
|
})
|
|
).toString("base64url") +
|
|
`.` +
|
|
"s".repeat(40);
|
|
const urls: string[] = [];
|
|
const fetchImpl = async (url: string, init?: RequestInit) => {
|
|
urls.push(String(url));
|
|
if (String(url).includes("ims/check")) {
|
|
assert.equal(init?.method, "POST");
|
|
// Authenticated exchange (guest_allowed=false)
|
|
return jsonResponse(200, {
|
|
access_token: userTok,
|
|
account_type: "type1",
|
|
});
|
|
}
|
|
if (String(url).includes("generate-async")) {
|
|
const auth =
|
|
(init?.headers as Record<string, string> | undefined)?.Authorization ||
|
|
(init?.headers as Headers)?.get?.("Authorization");
|
|
// headers object from buildAdobeSubmitHeaders
|
|
const headerAuth =
|
|
typeof init?.headers === "object" && init.headers && !("get" in (init.headers as object))
|
|
? (init.headers as Record<string, string>).Authorization
|
|
: auth;
|
|
assert.equal(headerAuth, `Bearer ${userTok}`);
|
|
return jsonResponse(200, {}, { "x-override-status-link": "https://poll.example/job/c1" });
|
|
}
|
|
if (String(url).includes("poll.example")) {
|
|
return jsonResponse(200, {
|
|
outputs: [{ image: { presignedUrl: "https://cdn.example/cookie.png" } }],
|
|
});
|
|
}
|
|
throw new Error(`unexpected ${url}`);
|
|
};
|
|
|
|
// Use the image handler which resolves credentials (cookie → IMS).
|
|
const result = await handleAdobeFireflyImageGeneration({
|
|
model: "nano-banana-pro",
|
|
provider: "adobe-firefly",
|
|
body: { prompt: "cookie path" },
|
|
credentials: { apiKey: "s_ecid=abc; sessionToken=xyz; other=1" },
|
|
fetchImpl: fetchImpl as typeof fetch,
|
|
});
|
|
assert.equal(result.success, true);
|
|
assert.ok(urls.some((u) => u.includes("ims/check")));
|
|
assert.ok(urls.some((u) => u.includes("generate-async")));
|
|
});
|