@agent-native/creative-context 0.1.0

package/src/server/media.ts

@@ -0,0 +1,117 @@
+import {
+  getH3App,
+  getSession,
+  runWithRequestContext,
+  type NitroPluginDef,
+} from "@agent-native/core/server";
+import { eq } from "drizzle-orm";
+
+import {
+  parsePrivateBlobHandle,
+  readPrivateArtifact,
+} from "../connectors/private-artifacts.js";
+import { CREATIVE_CONTEXT_MEDIA_ROUTE } from "../media-url.js";
+import { getCreativeContextItem } from "../store/index.js";
+import { getCreativeContext } from "./context.js";
+
+const SAFE_MIME_TYPES = new Set([
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/gif",
+  "image/svg+xml",
+]);
+
+export function createCreativeContextMediaPlugin(): NitroPluginDef {
+  return async (nitroApp: object) => {
+    getH3App(nitroApp).use(CREATIVE_CONTEXT_MEDIA_ROUTE, async (event: any) => {
+      if (event?.req?.method !== "GET") {
+        return new Response("Method not allowed", { status: 405 });
+      }
+      const session = await getSession(event).catch(() => null);
+      const userEmail = session?.email?.trim().toLowerCase();
+      if (!userEmail) {
+        return new Response("Authentication required", { status: 401 });
+      }
+      const orgId = session?.orgId;
+      const url = new URL(
+        event.req.url,
+        event.req.headers?.get?.("origin") ?? "http://localhost",
+      );
+      const mediaId = url.searchParams.get("mediaId");
+      let loaded: Awaited<ReturnType<typeof readCreativeContextMedia>> | null;
+      try {
+        loaded = await runWithRequestContext({ userEmail, orgId }, () =>
+          readCreativeContextMedia({
+            mediaId: mediaId ?? undefined,
+            itemId: url.searchParams.get("itemId") ?? undefined,
+            itemVersionId: url.searchParams.get("itemVersionId") ?? undefined,
+          }),
+        );
+      } catch {
+        loaded = null;
+      }
+      if (!loaded) return new Response("Not found", { status: 404 });
+      const { data, mimeType } = loaded;
+      if (!SAFE_MIME_TYPES.has(mimeType)) {
+        return new Response("Unsupported media type", { status: 415 });
+      }
+      const body = data.buffer.slice(
+        data.byteOffset,
+        data.byteOffset + data.byteLength,
+      ) as ArrayBuffer;
+      return new Response(body, {
+        headers: {
+          "Cache-Control": "private, max-age=300",
+          "Content-Type": mimeType,
+          "Content-Security-Policy":
+            "sandbox; default-src 'none'; style-src 'unsafe-inline'",
+          "X-Content-Type-Options": "nosniff",
+        },
+      });
+    });
+  };
+}
+
+export async function readCreativeContextMedia(input: {
+  mediaId?: string;
+  itemId?: string;
+  itemVersionId?: string;
+}) {
+  let itemId = input.itemId;
+  let itemVersionId = input.itemVersionId;
+  if (input.mediaId) {
+    const { getDb, schema } = getCreativeContext();
+    const rows = await getDb()
+      .select({
+        itemId: schema.contextMedia.itemId,
+        itemVersionId: schema.contextMedia.itemVersionId,
+      })
+      .from(schema.contextMedia)
+      .where(eq(schema.contextMedia.id, input.mediaId))
+      .limit(1);
+    itemId = rows[0]?.itemId;
+    itemVersionId = rows[0]?.itemVersionId;
+  }
+  if (!itemId) throw new Error("Creative context media was not found");
+  const detail = await getCreativeContextItem(itemId, itemVersionId);
+  if (!detail) throw new Error("Creative context media is not accessible");
+  const media = input.mediaId
+    ? detail.media.find((entry) => entry.id === input.mediaId)
+    : null;
+  const handle = parsePrivateBlobHandle(
+    media?.storageKey ?? detail.item.thumbnailBlobRef,
+  );
+  if (!handle) throw new Error("Creative context media has no private blob");
+  return {
+    data: await readPrivateArtifact(
+      handle,
+      getCreativeContext().connectorContext,
+    ),
+    mimeType: media?.mimeType ?? handle.mimeType ?? "application/octet-stream",
+    itemId: detail.item.id,
+    itemVersionId: detail.version.id,
+    mediaId: media?.id ?? null,
+    media,
+  };
+}

package/src/server/prompt-provider.spec.ts

@@ -0,0 +1,78 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  readAppState: vi.fn(),
+  getBrandProfile: vi.fn(),
+  provider: null as null | {
+    load: (context: {
+      owner: string;
+      compact: boolean;
+      orgId: string | null;
+    }) => Promise<unknown> | unknown;
+  },
+}));
+
+vi.mock("@agent-native/core/application-state", () => ({
+  readAppState: mocks.readAppState,
+}));
+
+vi.mock("@agent-native/core/server", () => ({
+  registerPromptContextProvider: vi.fn((provider) => {
+    mocks.provider = provider;
+    return () => {
+      mocks.provider = null;
+    };
+  }),
+}));
+
+vi.mock("../store/brand.js", () => ({
+  getBrandProfile: mocks.getBrandProfile,
+}));
+
+import {
+  publishedBrandContextInput,
+  registerCreativeContextPromptProvider,
+} from "./prompt-provider.js";
+
+describe("creative context prompt provider", () => {
+  beforeEach(() => {
+    mocks.readAppState.mockReset();
+    mocks.getBrandProfile.mockReset();
+  });
+
+  it("maps only structured published payload fields into the compiler", () => {
+    expect(
+      publishedBrandContextInput("brand", "dna", {
+        summary: "untrusted free-form summary",
+        visual: {
+          colors: [{ role: "accent", value: "#5B4FE9" }],
+          fonts: [{ family: "Inter" }],
+        },
+        voice: { descriptors: ["direct"] },
+      }),
+    ).toEqual({
+      profileId: "brand",
+      dnaVersionId: "dna",
+      colors: [{ role: "accent", value: "#5B4FE9" }],
+      fonts: [{ family: "Inter" }],
+      numericScales: undefined,
+      voiceDescriptors: ["direct"],
+      layoutPatterns: undefined,
+      logos: undefined,
+      terminology: undefined,
+      exclusions: undefined,
+      inventory: undefined,
+    });
+  });
+
+  it("structurally omits published brand context when context mode is off", async () => {
+    mocks.readAppState.mockResolvedValue({ contextMode: "off" });
+    const unregister = registerCreativeContextPromptProvider();
+
+    await expect(
+      mocks.provider?.load({ owner: "user", compact: false, orgId: null }),
+    ).resolves.toBeNull();
+    expect(mocks.getBrandProfile).not.toHaveBeenCalled();
+    unregister();
+  });
+});

package/src/server/prompt-provider.ts

@@ -0,0 +1,73 @@
+import { readAppState } from "@agent-native/core/application-state";
+import { registerPromptContextProvider } from "@agent-native/core/server";
+
+import { getBrandProfile } from "../store/brand.js";
+import type { BrandDnaPayload } from "../types.js";
+import {
+  compilePublishedBrandContext,
+  type PublishedBrandContextInput,
+} from "./brand-context.js";
+
+const PROVIDER_ID = "creative-context";
+let unregisterProvider: (() => void) | null = null;
+
+function objectValue(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+export function publishedBrandContextInput(
+  profileId: string,
+  dnaVersionId: string,
+  payload: BrandDnaPayload,
+): PublishedBrandContextInput {
+  const visual = objectValue(payload.visual);
+  const voice = objectValue(payload.voice);
+  return {
+    profileId,
+    dnaVersionId,
+    colors: payload.colors ?? visual.colors,
+    fonts: payload.fonts ?? visual.fonts,
+    numericScales:
+      payload.numericScales ?? visual.numericScales ?? visual.scales,
+    voiceDescriptors:
+      payload.voiceDescriptors ?? voice.descriptors ?? voice.tone,
+    layoutPatterns:
+      payload.layoutPatterns ?? visual.layoutPatterns ?? payload.motifs,
+    logos: payload.logos ?? visual.logos,
+    terminology: payload.terminology,
+    exclusions: payload.exclusions ?? payload.constraints,
+    inventory: payload.inventory,
+  };
+}
+
+export function registerCreativeContextPromptProvider(): () => void {
+  if (unregisterProvider) return unregisterProvider;
+  const unregister = registerPromptContextProvider({
+    id: PROVIDER_ID,
+    async load() {
+      const state = await readAppState("creative-context").catch(() => null);
+      if (state?.contextMode === "off") return null;
+      const { profile, dna } = await getBrandProfile({});
+      if (!profile || !dna || dna.status !== "published") return null;
+      return {
+        label: "Published brand context",
+        content: compilePublishedBrandContext(
+          publishedBrandContextInput(profile.id, dna.id, dna.payload),
+        ),
+        provenance: "runtime-context",
+        governance: profile.visibility === "org" ? "inherited" : "user",
+        sourceRef: {
+          scope: profile.visibility === "org" ? "organization" : "personal",
+          path: "context/brand-context.md",
+        },
+      };
+    },
+  });
+  unregisterProvider = () => {
+    unregister();
+    unregisterProvider = null;
+  };
+  return unregisterProvider;
+}

package/src/server/public-serialization.spec.ts

@@ -0,0 +1,149 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  sanitizePublicMetadata,
+  serializePublicBrandProfile,
+  serializePublicContextDetail,
+  serializePublicJob,
+  serializePublicReviewItems,
+} from "./public-serialization.js";
+
+const PRIVATE_HANDLE = "creative-context-blob:private-object";
+
+function serialized(value: unknown): string {
+  return JSON.stringify(value);
+}
+
+function expectNoCapabilities(value: unknown) {
+  const output = serialized(value);
+  expect(output).not.toContain(PRIVATE_HANDLE);
+  expect(output).not.toMatch(
+    /storageKey|blobRef|rawSnapshotBlobRef|providerUrl|leaseToken|leaseOwner|secret-token/i,
+  );
+}
+
+describe("creative context public serialization", () => {
+  it("recursively removes capability-looking keys and values", () => {
+    const result = sanitizePublicMetadata({
+      safe: "caption",
+      nested: {
+        storageKey: PRIVATE_HANDLE,
+        providerUrl: "https://provider.example/private",
+        token: "secret-token",
+        values: [PRIVATE_HANDLE, "safe"],
+      },
+    });
+    expect(result).toEqual({ safe: "caption", nested: { values: ["safe"] } });
+  });
+
+  it("redacts capability URLs embedded inside warning and error strings", () => {
+    expect(
+      sanitizePublicMetadata(
+        "Fetch failed for https://provider.example/private?token=example: timeout",
+      ),
+    ).toBe("Fetch failed for [redacted] timeout");
+    expect(
+      sanitizePublicMetadata(
+        "Warning: creative-context-blob:v1:opaque-example is unavailable",
+      ),
+    ).toBe("Warning: [redacted] is unavailable");
+  });
+
+  it("replaces context item media handles with an access-scoped id URL", () => {
+    const result = serializePublicContextDetail({
+      item: {
+        id: "item-1",
+        thumbnailBlobRef: PRIVATE_HANDLE,
+        canonicalUrl: "https://provider.example/private?token=example",
+        provenance: {
+          warning:
+            "Source https://provider.example/private?token=example failed",
+          role: "hero",
+        },
+      },
+      version: {
+        id: "version-1",
+        rawSnapshotBlobRef: PRIVATE_HANDLE,
+        metadata: { blobRef: PRIVATE_HANDLE, role: "hero" },
+      },
+      chunks: [{ id: "chunk-1", metadata: { storageKey: PRIVATE_HANDLE } }],
+      media: [
+        {
+          id: "media-1",
+          storageKey: PRIVATE_HANDLE,
+          provenanceUrl: "https://provider.example/private",
+          url: null,
+          metadata: { providerUrl: "https://provider.example/private" },
+        },
+      ],
+      edges: [{ id: "edge-1", metadata: { label: "derived" } }],
+    } as any);
+    expect(result.item.hasThumbnail).toBe(true);
+    expect(result.item).toMatchObject({
+      canonicalUrl: null,
+      provenance: { warning: "Source [redacted] failed", role: "hero" },
+    });
+    expect(result.media[0]?.url).toBe(
+      "/_agent-native/creative-context/media?mediaId=media-1",
+    );
+    expect(result.media[0]?.hasOriginal).toBe(true);
+    expectNoCapabilities(result);
+  });
+
+  it("omits leases, requests, checkpoints, and nested result capabilities", () => {
+    const result = serializePublicJob({
+      id: "job-1",
+      sourceId: "source-1",
+      kind: "import",
+      status: "running",
+      mode: "incremental",
+      progressCurrent: 2,
+      progressTotal: 4,
+      attempts: 1,
+      leaseOwner: "worker-secret",
+      leaseToken: "secret-token",
+      leaseExpiresAt: "tomorrow",
+      nextResumeAt: null,
+      budget: { token: "secret-token" },
+      checkpoint: { blobRef: PRIVATE_HANDLE },
+      request: { providerUrl: "https://provider.example/private" },
+      result: { safe: 2, nested: { storageKey: PRIVATE_HANDLE } },
+      error: null,
+      createdAt: "now",
+      startedAt: "now",
+      completedAt: null,
+    });
+    expect(result).toMatchObject({ id: "job-1", result: { safe: 2 } });
+    expectNoCapabilities(result);
+  });
+
+  it("sanitizes brand payloads and review provenance", () => {
+    const brand = serializePublicBrandProfile({
+      profile: { id: "brand-1" } as any,
+      dna: {
+        id: "dna-1",
+        payload: {
+          summary: "Safe",
+          visual: { layoutPatterns: [{ thumbnailBlobRef: PRIVATE_HANDLE }] },
+        },
+      } as any,
+      versions: [],
+    });
+    const review = serializePublicReviewItems([
+      {
+        id: "item-1",
+        thumbnailBlobRef: PRIVATE_HANDLE,
+        provenance: {
+          providerUrl: "https://provider.example/private",
+          source: "figma",
+        },
+      } as any,
+    ]);
+    expect(review[0]).toMatchObject({
+      id: "item-1",
+      hasThumbnail: true,
+      provenance: { source: "figma" },
+    });
+    expectNoCapabilities({ brand, review });
+  });
+});

package/src/server/public-serialization.ts

@@ -0,0 +1,130 @@
+import { creativeContextMediaUrl } from "../media-url.js";
+import type {
+  BrandDnaVersion,
+  BrandProfile,
+  ContextDetail,
+  ContextJob,
+  ContextReviewItem,
+} from "../types.js";
+
+const BLOCKED_METADATA_KEY =
+  /(?:authorization|token|secret|password|cookie|storageKey|blobRef|rawSnapshot|downloadUrl|providerUrl|leaseToken|leaseOwner)/i;
+const CAPABILITY_VALUE =
+  /(?:creative-context-blob:|private-blob:|https?:\/\/)[^\s<>{}\[\]"']*/gi;
+
+export function sanitizePublicMetadata(value: unknown): unknown {
+  if (typeof value === "string") {
+    CAPABILITY_VALUE.lastIndex = 0;
+    if (!CAPABILITY_VALUE.test(value)) return value;
+    CAPABILITY_VALUE.lastIndex = 0;
+    const redacted = value.replace(CAPABILITY_VALUE, "[redacted]").trim();
+    return redacted === "[redacted]" ? undefined : redacted;
+  }
+  if (Array.isArray(value)) {
+    return value
+      .map(sanitizePublicMetadata)
+      .filter((entry) => entry !== undefined);
+  }
+  if (!value || typeof value !== "object") return value;
+  const output: Record<string, unknown> = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (BLOCKED_METADATA_KEY.test(key)) continue;
+    const sanitized = sanitizePublicMetadata(child);
+    if (sanitized !== undefined) output[key] = sanitized;
+  }
+  return output;
+}
+
+export function sanitizePublicString(value: string): string {
+  const sanitized = sanitizePublicMetadata(value);
+  return typeof sanitized === "string" ? sanitized : "[redacted]";
+}
+
+export function serializePublicContextDetail(context: ContextDetail) {
+  const { thumbnailBlobRef, provenance, canonicalUrl, ...item } = context.item;
+  const sanitizedCanonicalUrl = sanitizePublicMetadata(canonicalUrl);
+  const {
+    rawSnapshotBlobRef,
+    metadata: versionMetadata,
+    ...version
+  } = context.version;
+  return {
+    item: {
+      ...item,
+      canonicalUrl:
+        typeof sanitizedCanonicalUrl === "string"
+          ? sanitizedCanonicalUrl
+          : null,
+      provenance: sanitizePublicMetadata(provenance),
+      hasThumbnail: Boolean(thumbnailBlobRef),
+    },
+    version: {
+      ...version,
+      hasRawSnapshot: Boolean(rawSnapshotBlobRef),
+      metadata: sanitizePublicMetadata(versionMetadata),
+    },
+    chunks: context.chunks.map(({ metadata, ...chunk }) => ({
+      ...chunk,
+      metadata: sanitizePublicMetadata(metadata),
+    })),
+    media: context.media.map(
+      ({ storageKey, provenanceUrl, url, metadata, ...media }) => ({
+        ...media,
+        url: creativeContextMediaUrl({ mediaId: media.id }),
+        hasOriginal: Boolean(storageKey || provenanceUrl || url),
+        metadata: sanitizePublicMetadata(metadata),
+      }),
+    ),
+    edges: context.edges.map(({ metadata, ...edge }) => ({
+      ...edge,
+      metadata: sanitizePublicMetadata(metadata),
+    })),
+  };
+}
+
+export function serializePublicBrandProfile(input: {
+  profile: BrandProfile | null;
+  dna: BrandDnaVersion | null;
+  versions: BrandDnaVersion[];
+}) {
+  const sanitizeVersion = (version: BrandDnaVersion | null) =>
+    version
+      ? {
+          ...version,
+          payload: sanitizePublicMetadata(version.payload),
+        }
+      : null;
+  return {
+    profile: input.profile,
+    dna: sanitizeVersion(input.dna),
+    versions: input.versions.map((version) => sanitizeVersion(version)!),
+  };
+}
+
+export function serializePublicJob(job: ContextJob | null) {
+  if (!job) return null;
+  return {
+    id: job.id,
+    sourceId: job.sourceId,
+    kind: job.kind,
+    status: job.status,
+    mode: job.mode,
+    progressCurrent: job.progressCurrent,
+    progressTotal: job.progressTotal,
+    attempts: job.attempts,
+    nextResumeAt: job.nextResumeAt,
+    result: sanitizePublicMetadata(job.result),
+    error: sanitizePublicMetadata(job.error) ?? null,
+    createdAt: job.createdAt,
+    startedAt: job.startedAt,
+    completedAt: job.completedAt,
+  };
+}
+
+export function serializePublicReviewItems(items: ContextReviewItem[]) {
+  return items.map(({ thumbnailBlobRef, provenance, ...item }) => ({
+    ...item,
+    hasThumbnail: Boolean(thumbnailBlobRef),
+    provenance: sanitizePublicMetadata(provenance),
+  }));
+}

package/src/server/resource-paths.spec.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest";
+
+import { getCreativeContextResourcePath } from "./resource-paths.js";
+
+describe("creative context shareable resource paths", () => {
+  it("opens the Library tab exposed by each app", () => {
+    expect(getCreativeContextResourcePath()).toBe("/agent#library");
+  });
+});

package/src/server/resource-paths.ts

@@ -0,0 +1,5 @@
+export const CREATIVE_CONTEXT_LIBRARY_PATH = "/agent#library";
+
+export function getCreativeContextResourcePath(): string {
+  return CREATIVE_CONTEXT_LIBRARY_PATH;
+}