applaunchflow 0.3.1

package/build/http.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+import { createServer } from "node:http";
+import { pathToFileURL } from "node:url";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createAppLaunchFlowServer } from "./index.js";
+const DEFAULT_PORT = 8787;
+const DEFAULT_DASHBOARD_URL = "https://dashboard.applaunchflow.com";
+const REQUIRED_SCOPES = [
+    "projects:read",
+    "projects:write",
+    "assets:write",
+    "generations:write",
+];
+function normalizeBaseUrl(value) {
+    return value.replace(/\/+$/, "");
+}
+function dashboardBaseUrl() {
+    return normalizeBaseUrl(process.env.APPLAUNCHFLOW_BASE_URL || DEFAULT_DASHBOARD_URL);
+}
+function publicBaseUrl(request) {
+    const configured = process.env.APPLAUNCHFLOW_MCP_PUBLIC_URL;
+    if (configured) {
+        const parsed = new URL(configured);
+        if (process.env.NODE_ENV === "production" && parsed.protocol !== "https:") {
+            throw new Error("APPLAUNCHFLOW_MCP_PUBLIC_URL must use HTTPS in production");
+        }
+        parsed.pathname = parsed.pathname.replace(/\/mcp\/?$/, "");
+        parsed.search = "";
+        parsed.hash = "";
+        return normalizeBaseUrl(parsed.toString());
+    }
+    const host = request?.headers.host || `127.0.0.1:${DEFAULT_PORT}`;
+    const protocol = process.env.NODE_ENV === "production" ? "https" : "http";
+    return `${protocol}://${host}`;
+}
+function resourceIdentifier(request) {
+    return `${publicBaseUrl(request)}/mcp`;
+}
+function resourceMetadataUrl(request) {
+    return `${publicBaseUrl(request)}/.well-known/oauth-protected-resource`;
+}
+function json(response, status, payload, headers = {}) {
+    response.writeHead(status, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store",
+        ...headers,
+    });
+    response.end(JSON.stringify(payload));
+}
+function bearerToken(request) {
+    const header = request.headers.authorization;
+    if (!header)
+        return null;
+    const match = /^Bearer\s+(.+)$/i.exec(header);
+    return match?.[1]?.trim() || null;
+}
+function unauthorized(request, response) {
+    json(response, 401, {
+        jsonrpc: "2.0",
+        error: { code: -32001, message: "Authorization required" },
+        id: null,
+    }, {
+        "www-authenticate": `Bearer resource_metadata="${resourceMetadataUrl(request)}"`,
+    });
+}
+async function introspectToken(request, token) {
+    const response = await fetch(`${dashboardBaseUrl()}/api/auth/mcp/introspect`, {
+        headers: {
+            authorization: `Bearer ${token}`,
+            accept: "application/json",
+        },
+    });
+    if (!response.ok)
+        return null;
+    const payload = (await response.json());
+    if (!payload.active ||
+        !payload.userId ||
+        REQUIRED_SCOPES.some((scope) => !payload.scopes?.includes(scope))) {
+        return null;
+    }
+    const expectedResource = resourceIdentifier(request);
+    if (payload.resource && payload.resource !== expectedResource)
+        return null;
+    return {
+        token,
+        clientId: payload.clientId || "applaunchflow-mcp",
+        scopes: payload.scopes || [],
+        expiresAt: payload.expiresAt,
+        resource: new URL(expectedResource),
+        extra: { userId: payload.userId },
+    };
+}
+async function handleMcp(request, response) {
+    const token = bearerToken(request);
+    if (!token) {
+        unauthorized(request, response);
+        return;
+    }
+    let auth = null;
+    try {
+        auth = await introspectToken(request, token);
+    }
+    catch (error) {
+        console.error("Token introspection failed", error);
+        json(response, 503, {
+            jsonrpc: "2.0",
+            error: { code: -32002, message: "Authorization service unavailable" },
+            id: null,
+        });
+        return;
+    }
+    if (!auth) {
+        unauthorized(request, response);
+        return;
+    }
+    const server = createAppLaunchFlowServer({
+        baseUrl: dashboardBaseUrl(),
+        token,
+    });
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+    });
+    request.auth = auth;
+    try {
+        await server.connect(transport);
+        await transport.handleRequest(request, response);
+    }
+    catch (error) {
+        console.error("MCP request failed", error);
+        if (!response.headersSent) {
+            json(response, 500, {
+                jsonrpc: "2.0",
+                error: { code: -32603, message: "Internal server error" },
+                id: null,
+            });
+        }
+    }
+    finally {
+        await transport.close().catch(() => undefined);
+        await server.close().catch(() => undefined);
+    }
+}
+export function createHttpServer() {
+    process.env.APPLAUNCHFLOW_MCP_REMOTE = "1";
+    return createServer(async (request, response) => {
+        const url = new URL(request.url || "/", publicBaseUrl(request));
+        if (request.method === "GET" && url.pathname === "/healthz") {
+            json(response, 200, { ok: true, service: "applaunchflow-mcp" });
+            return;
+        }
+        if (request.method === "GET" &&
+            url.pathname === "/.well-known/oauth-protected-resource") {
+            json(response, 200, {
+                resource: resourceIdentifier(request),
+                authorization_servers: [dashboardBaseUrl()],
+                scopes_supported: REQUIRED_SCOPES,
+                bearer_methods_supported: ["header"],
+                resource_documentation: `${dashboardBaseUrl()}/docs/mcp`,
+            });
+            return;
+        }
+        if (url.pathname === "/mcp") {
+            await handleMcp(request, response);
+            return;
+        }
+        json(response, 404, { error: "Not found" });
+    });
+}
+async function main() {
+    const port = Number(process.env.PORT || DEFAULT_PORT);
+    const server = createHttpServer();
+    server.listen(port, "0.0.0.0", () => {
+        console.error(`AppLaunchFlow MCP HTTP server listening on port ${port}`);
+    });
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    void main();
+}

package/build/http.test.js

@@ -0,0 +1,111 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createServer as createNodeServer } from "node:http";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { createHttpServer } from "./http.js";
+async function withServer(callback) {
+    const server = createHttpServer();
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+    const address = server.address();
+    try {
+        await callback(`http://127.0.0.1:${address.port}`);
+    }
+    finally {
+        await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+    }
+}
+test("HTTP server exposes health and protected-resource metadata", async () => {
+    await withServer(async (baseUrl) => {
+        const health = await fetch(`${baseUrl}/healthz`);
+        assert.equal(health.status, 200);
+        assert.deepEqual(await health.json(), {
+            ok: true,
+            service: "applaunchflow-mcp",
+        });
+        const metadata = await fetch(`${baseUrl}/.well-known/oauth-protected-resource`);
+        assert.equal(metadata.status, 200);
+        const payload = (await metadata.json());
+        assert.equal(payload.resource, `${baseUrl}/mcp`);
+        assert.deepEqual(payload.authorization_servers, [
+            "https://dashboard.applaunchflow.com",
+        ]);
+    });
+});
+test("MCP endpoint challenges unauthenticated callers with resource metadata", async () => {
+    await withServer(async (baseUrl) => {
+        const response = await fetch(`${baseUrl}/mcp`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                jsonrpc: "2.0",
+                id: 1,
+                method: "initialize",
+                params: {
+                    protocolVersion: "2025-06-18",
+                    capabilities: {},
+                    clientInfo: { name: "test", version: "1.0.0" },
+                },
+            }),
+        });
+        assert.equal(response.status, 401);
+        assert.equal(response.headers.get("www-authenticate"), `Bearer resource_metadata="${baseUrl}/.well-known/oauth-protected-resource"`);
+    });
+});
+test("authenticated Streamable HTTP clients can initialize and discover tools", async () => {
+    const introspectionServer = createNodeServer((request, response) => {
+        if (request.url === "/api/auth/mcp/introspect" &&
+            request.headers.authorization === "Bearer test-access-token") {
+            response.writeHead(200, { "content-type": "application/json" });
+            response.end(JSON.stringify({
+                active: true,
+                userId: "00000000-0000-4000-8000-000000000001",
+                clientId: "test-client",
+                scopes: [
+                    "projects:read",
+                    "projects:write",
+                    "assets:write",
+                    "generations:write",
+                ],
+                expiresAt: Math.floor(Date.now() / 1000) + 3600,
+            }));
+            return;
+        }
+        response.writeHead(401).end();
+    });
+    await new Promise((resolve) => introspectionServer.listen(0, "127.0.0.1", resolve));
+    const introspectionAddress = introspectionServer.address();
+    const previousDashboard = process.env.APPLAUNCHFLOW_BASE_URL;
+    const previousPublicUrl = process.env.APPLAUNCHFLOW_MCP_PUBLIC_URL;
+    process.env.APPLAUNCHFLOW_BASE_URL = `http://127.0.0.1:${introspectionAddress.port}`;
+    try {
+        await withServer(async (baseUrl) => {
+            process.env.APPLAUNCHFLOW_MCP_PUBLIC_URL = `${baseUrl}/mcp`;
+            const transport = new StreamableHTTPClientTransport(new URL(`${baseUrl}/mcp`), {
+                requestInit: {
+                    headers: { authorization: "Bearer test-access-token" },
+                },
+            });
+            const client = new Client({ name: "http-test", version: "1.0.0" });
+            await client.connect(transport);
+            try {
+                const { tools } = await client.listTools();
+                assert.equal(tools.length, 43);
+            }
+            finally {
+                await client.close();
+            }
+        });
+    }
+    finally {
+        if (previousDashboard === undefined)
+            delete process.env.APPLAUNCHFLOW_BASE_URL;
+        else
+            process.env.APPLAUNCHFLOW_BASE_URL = previousDashboard;
+        if (previousPublicUrl === undefined)
+            delete process.env.APPLAUNCHFLOW_MCP_PUBLIC_URL;
+        else
+            process.env.APPLAUNCHFLOW_MCP_PUBLIC_URL = previousPublicUrl;
+        await new Promise((resolve, reject) => introspectionServer.close((error) => (error ? reject(error) : resolve())));
+    }
+});

package/build/index.js

@@ -0,0 +1,127 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { AppLaunchFlowClient, } from "./client/api.js";
+import { registerPrompts } from "./prompts/register.js";
+import { registerResources } from "./resources/register.js";
+import { registerAssetTools } from "./tools/assets.js";
+import { registerLayoutTools } from "./tools/layouts.js";
+import { registerProjectTools } from "./tools/projects.js";
+import { registerScreenshotTools } from "./tools/screenshots.js";
+import { registerTemplateTools } from "./tools/templates.js";
+import { registerGraphicsTools } from "./tools/graphics.js";
+import { registerPromoVideoTools } from "./tools/promovideo.js";
+import { registerMockupTools } from "./tools/mockups.js";
+import { registerLocalizationTools } from "./tools/localization.js";
+import { registerVariantTools } from "./tools/variants.js";
+import { registerKeywordTools } from "./tools/keywords.js";
+import { installToolMetadataPolicy } from "./tool-metadata.js";
+export const SERVER_INSTRUCTIONS = `
+AppLaunchFlow MCP supports four content types: app store screenshots, social graphics, promo videos, and mockup animations.
+Use it for project setup, screenshot uploads, AI generation of screenshots/graphics/videos, mockup animation editing, variant management, direct layout editing, and translation.
+Do not treat this MCP as an ASO or generic graphics-design assistant — every tool is scoped to one of those four content types.
+
+Use AppLaunchFlow MCP as an execution tool, not a questionnaire.
+
+Default behavior:
+- When the user wants help and no project has been selected yet, the first branch is always: create a new app or edit an existing app.
+- Do not start with template browsing before that project choice is resolved.
+- For concrete requests on an existing project, act directly instead of asking follow-up questions.
+- Only ask when a missing detail is required to avoid a materially wrong result, or when the request is genuinely ambiguous.
+- Do not force menu-style "what would you like to do next?" steps after each tool call.
+- The user can edit layouts in natural language. Translate those requests into direct MCP actions.
+- If a tool returns a user-facing URL, repeat the exact URL in the assistant reply. Do not say "link above" or assume tool output is visible to the user.
+- Initial creation tools return an editor URL. Include that exact URL in the reply so the user can open the result.
+- For edit tools (transform_layout, save_graphics_format, update_promo_video, update_mockup_animation, save_layout, save_graphics), include the editor URL as a reference without claiming a new browser tab was opened.
+
+Schema references (MCP resources — read them, they are not loaded automatically):
+- applaunchflow://schema/layout — every field of the layout JSON: all 11 node types, their properties, and valid value ranges. Used by BOTH screenshots and social graphics (a social layout is the same shape with exactly one screen and the format's canvas size).
+- applaunchflow://schema/transforms — the transform_layout operations, selector syntax, and the selector pitfalls that silently match every screen.
+- applaunchflow://schema/video-config — the full Remotion VideoConfig: six scene types and their content shapes, theme, text styles, ken burns, choreography preset ids, device/text overlays, audio.
+- For mockup animations the equivalent is the list_mockup_presets TOOL, not a resource.
+- Read the relevant resource before hand-writing or non-trivially editing JSON. A get_* response only shows what is currently set — it does not tell you what is possible.
+
+Screenshot workflows:
+- Entry point without a known project: ask whether the user wants to create a new app or edit an existing project. If they want existing, list/select projects. If they want new, create the project first.
+- For the normal style-choice flow, call list_source_screenshots, choose 3-7 real screenshots in story order, then call prepare_screenshot_styles. This generates or reuses one personalized catalog containing every template for phone, tablet, and desktop.
+- After preparation, call browse_templates with exactly the returned templateIds plus generationId and catalogKey so the gallery renders the real personalized results. Then immediately call apply_screenshot_style with the returned catalogKey and selected templateId. Applying creates a new variant from cache without another AI call. Never overwrite an existing variant.
+- Use generate_layouts only for an explicitly requested legacy/direct single-template generation. Do not use it for the normal visual style chooser.
+- For small, precise edits to existing known nodes, transform_layout can be used directly.
+- For any composition-sensitive edit, inspect the current layout first with get_layout. This includes adding screens, reusing screenshots, changing screenshot placement, moving text, changing spacing, or anything that should match the existing visual system.
+- Use transform_layout as the primary tool for editing current screens once you have enough layout context.
+- Default to layouts: ["mobile"] for transform_layout. Only include tablet/desktop if the user explicitly asks.
+- When editing a single screen, scope the transform to just that screen using the screens parameter (e.g. screens: [2]). Do not transform the entire layout when only one screen needs changes.
+- For adding new screens to an existing layout, prefer direct layout editing when the user wants to keep the current design. Only generate a fresh variant when the user asks for a new AI-generated layout/template.
+- When adding or editing elements, ensure text and screenshots do not overlap. Verify that positions place elements in distinct, non-conflicting areas of the canvas.
+- After composition-sensitive edits, inspect the returned translation or re-fetch the layout before reporting success. If elements overlap or are poorly positioned, fix them before telling the user the edit is done.
+- get_layout is mandatory before every direct transform_layout call. Do not edit a layout without a fresh read of the current state first.
+- ALWAYS use browse_templates after prepare_screenshot_styles when a screenshot template choice is needed. Pass the prepared templateIds, generationId, and catalogKey. Never offer templates via text bullet points. The connector returns a gallery URL, which you must show to the user before waiting for the selected template id.
+- When you need visual context about a screenshot (e.g. to extract colors, understand the app UI, or make context-specific edits), use view_screenshot to look at the actual image.
+- After generating a new variant, include the editor URL in the reply.
+
+Social graphics workflows (mirror the screenshot flow):
+- Call list_source_screenshots, select 3-7 real screenshots in story order, then call prepare_social_graphics_styles. This generates or reuses every social template across all six formats in one catalog.
+- Call browse_social_templates with the returned templateIds plus generationId and catalogKey so the gallery renders the personalized graphics, then immediately call apply_social_graphics_style with the selected templateId and catalogKey. Applying creates a fresh variant containing all six formats without another AI call.
+- Use generate_graphics only for an explicitly requested legacy/direct single-template generation. Never overwrite an existing graphics variant.
+- For edits to existing social graphics, ALWAYS call get_graphics_format first, then save_graphics_format. Mutate JSON for exactly one format in memory and save only that one format. The same get-before-edit receipt rule applies as for screenshots.
+- Default to the variant's primary format unless the user explicitly asks to edit another format.
+- Do not edit multiple formats in one pass. The user can sync the design to other formats later in the graphics editor UI.
+- When sharing or returning a graphics editor URL after an edit, include \`&format=<format>\` so the browser shows the format that was changed.
+- Use create_variant with contentType:"socialGraphics" or duplicate_variant to create a copy / fresh take without overwriting the current graphics variant.
+
+Promo video workflows:
+- generate_promo_video runs the AI generation pipeline against the project's screenshots and produces a complete Remotion video config. Omit variantId to create a new variant.
+- For edits to an existing promo video, ALWAYS call get_promo_video first to fetch the current config, mutate the config object in memory, then call update_promo_video with the full updated config. There is no granular transform tool for promo videos at this stage — full-config replace is the supported edit path. The same get-before-edit receipt rule as graphics applies: update_promo_video is locked until a fresh get_promo_video has been called for the same project/variant.
+- Use clear_promo_video to wipe a variant's video config when the user wants to start over.
+- Use create_variant with contentType:"promoVideo" or duplicate_variant for copies / A-B tests. duplicate_variant clones the source promo-video variant, including its config.
+- Promo video has no template gallery — the LLM produces the full config end-to-end. Do NOT call browse_templates / browse_social_templates for promo videos.
+
+Mockup animation workflows:
+- create_mockup_animation seeds a fresh mockup variant from a SCENE_PRESETS preset and a specific screenshot/recording path. Always omit variantId; a new variant is always created. Call list_mockup_media first to pick a screenshotPath, and list_mockup_presets to pick a presetId and learn the valid enum + bound values. Editor opens automatically.
+- For edits to an existing mockup animation, ALWAYS call get_mockup_animation first to fetch the current state, mutate the MockupProjectState object in memory, then call update_mockup_animation with the full updated state. There is no granular per-keyframe transform — full-state replace is the supported edit path. The same get-before-edit receipt rule applies: update_mockup_animation is locked until a fresh get_mockup_animation has been called for the same project/variant. Edits propagate live to any open mockup editor tab via realtime — do not open the editor again.
+- Use create_variant with contentType:"mockups" or duplicate_variant for additional A/B variants. duplicate_variant clones the source mockup variant, including its state. To start a variant over, call create_mockup_animation for a fresh variant instead.
+- Mockup animation has no template gallery — the LLM constructs the MockupProjectState end-to-end using values from list_mockup_presets. Do NOT call browse_templates / browse_social_templates for mockup animations.
+
+Translation and localization (screenshots only):
+- When the user asks to translate, localize, or create a version in another language for screenshots, ALWAYS use translate_layouts. Do NOT manually edit text nodes via transform_layout for translation.
+- translate_layouts uses AI to translate all text while preserving layout, positioning, and styling.
+- To apply the same transform across all screens, use transform_layout with screens: "all" in the target.
+- Translation is not currently exposed for social graphics or promo videos.
+
+Project creation should be fast and simple:
+1. Ask for the app name and platform (iOS or Android) using AskUserQuestion. Default platform to iOS.
+2. Autofill category and description from context (e.g. "Skyscanner" → category "Travel"). Do not ask the user for these.
+3. Call create_project immediately. Do not ask for confirmation or optional fields unless the user volunteers them.
+4. After creation, recommend uploading screenshots as the next step (screenshots are the input for both social graphics and promo video generation too).
+`.trim();
+const HOSTED_SERVER_INSTRUCTIONS = `
+HOSTED CONNECTOR SAFETY RULES:
+- Never reveal, repeat, log, or place OAuth access tokens, refresh tokens, authorization codes, PKCE verifiers, or read receipts in user-facing text.
+- A readReceipt returned inside structured tool data is an opaque safety input. Pass it only to the matching edit tool, for the exact same project, variant, language, and format.
+- Before deleting, clearing, overwriting, or replacing user content, require clear user intent for that exact action. Do not infer destructive intent from a broad request.
+- Hosted gallery tools return a URL instead of opening a local browser. Show the exact URL, stop, and wait for the user's chosen template id. Do not guess or apply a style before the user selects it.
+
+${SERVER_INSTRUCTIONS}
+`.trim();
+export function createAppLaunchFlowServer(credentials) {
+    const client = new AppLaunchFlowClient(credentials);
+    const server = new McpServer({
+        name: "applaunchflow-mcp",
+        version: "0.3.0",
+    }, {
+        instructions: HOSTED_SERVER_INSTRUCTIONS,
+    });
+    installToolMetadataPolicy(server, { hosted: true });
+    registerPrompts(server);
+    registerResources(server, client);
+    registerProjectTools(server, client);
+    registerAssetTools(server, client);
+    registerScreenshotTools(server, client);
+    registerLayoutTools(server, client);
+    registerTemplateTools(server, client);
+    registerGraphicsTools(server, client);
+    registerPromoVideoTools(server, client);
+    registerMockupTools(server, client);
+    registerLocalizationTools(server, client);
+    registerVariantTools(server, client);
+    registerKeywordTools(server, client);
+    return server;
+}

package/build/prompts/register.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+export function registerPrompts(server) {
+    server.registerPrompt("create-project-wizard", {
+        title: "Create Project Wizard",
+        description: "Guide the user through quick project creation: ask app name + platform, then create immediately.",
+        argsSchema: {
+            userGoal: z
+                .string()
+                .optional()
+                .describe("Optional user request or project idea to keep in view."),
+        },
+    }, async ({ userGoal }) => ({
+        description: "Use this prompt when the user wants to create a project through AppLaunchFlow MCP.",
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: [
+                        "Create an AppLaunchFlow project quickly.",
+                        "If no project is selected yet, the first branching question is whether the user wants to create a new app or edit an existing one.",
+                        "Ask for the app name and platform (iOS or Android) using AskUserQuestion.",
+                        "Autofill category and description from context — do not ask the user for these.",
+                        "Call create_project immediately after getting the name and platform.",
+                        "After creation, recommend uploading screenshots as the next step.",
+                        userGoal ? `User goal: ${userGoal}` : null,
+                    ]
+                        .filter(Boolean)
+                        .join("\n"),
+                },
+            },
+        ],
+    }));
+    server.registerPrompt("direct-editing-workflow", {
+        title: "Direct Editing Workflow",
+        description: "Guide layout editing on an existing screenshot variant without inventing a new visual system.",
+        argsSchema: {
+            userGoal: z
+                .string()
+                .optional()
+                .describe("Optional concrete editing request."),
+        },
+    }, async ({ userGoal }) => ({
+        description: "Use this prompt when the user wants to edit an existing layout or add screens while preserving the current design language.",
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: [
+                        "Operate directly on the existing AppLaunchFlow screenshot layout.",
+                        "Call get_layout first and inspect the relevant existing screens before every transform_layout call.",
+                        "This read-before-edit rule is mandatory even for small direct edits.",
+                        "Composition-sensitive edits include adding screens, reusing screenshots, changing screenshot placement, moving text, changing spacing, or any request that should match the current style.",
+                        "When preserving the current design, copy actual numeric values from nearby screens: text positions, widths, zIndex, screenshot position, scale, rotation, and typography attributes.",
+                        "Do not invent a fresh composition unless the user explicitly asks for a redesign.",
+                        "After applying composition-sensitive transforms, inspect the returned translation or fetch the layout again and verify that the new screens match the existing style and do not overlap key content.",
+                        userGoal ? `User goal: ${userGoal}` : null,
+                    ]
+                        .filter(Boolean)
+                        .join("\n"),
+                },
+            },
+        ],
+    }));
+}

package/build/read-receipt.test.js

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createHostedReadReceipt, verifyHostedReadReceipt, } from "./tools/utils.js";
+import { isPrivateOrReservedIp } from "./tools/assets.js";
+test("hosted read receipts are token-bound, target-bound, and expire", () => {
+    const issuedAt = 1_000_000;
+    const receipt = createHostedReadReceipt("layout::one", "access-token-a", issuedAt);
+    assert.equal(verifyHostedReadReceipt(receipt, "layout::one", "access-token-a", issuedAt + 60_000), true);
+    assert.equal(verifyHostedReadReceipt(receipt, "layout::two", "access-token-a", issuedAt + 60_000), false);
+    assert.equal(verifyHostedReadReceipt(receipt, "layout::one", "access-token-b", issuedAt + 60_000), false);
+    assert.equal(verifyHostedReadReceipt(receipt, "layout::one", "access-token-a", issuedAt + 10 * 60_000 + 1), false);
+});
+test("hosted read receipts reject malformed and future-issued values", () => {
+    assert.equal(verifyHostedReadReceipt("invalid", "target", "token"), false);
+    const receipt = createHostedReadReceipt("target", "token", 50_000);
+    assert.equal(verifyHostedReadReceipt(receipt, "target", "token", 49_999), false);
+});
+test("hosted asset fetches block private, mapped, and documentation networks", () => {
+    for (const address of [
+        "127.0.0.1",
+        "10.1.2.3",
+        "100.64.1.2",
+        "169.254.169.254",
+        "192.168.1.2",
+        "198.51.100.7",
+        "::1",
+        "::ffff:127.0.0.1",
+        "fc00::1",
+        "fe80::1",
+        "2001:db8::1",
+    ]) {
+        assert.equal(isPrivateOrReservedIp(address), true, address);
+    }
+    assert.equal(isPrivateOrReservedIp("8.8.8.8"), false);
+    assert.equal(isPrivateOrReservedIp("2606:4700:4700::1111"), false);
+});