@agent-native/creative-context 0.0.0-beta-20260820202238

package/src/server/index.ts

@@ -0,0 +1,163 @@
+import { runMigrations } from "@agent-native/core/db";
+import {
+  isInBackgroundFunctionRuntime,
+  registerPackageActions,
+  type NitroPluginDef,
+} from "@agent-native/core/server";
+import { registerShareableResource } from "@agent-native/core/sharing";
+import { registerWorkspaceConnectionLifecycleListener } from "@agent-native/core/workspace-connections";
+
+import { creativeContextActions } from "../actions/index.js";
+import { createDefaultContextConnectorExecutionContext } from "../connectors/index.js";
+import type { ContextConnectorExecutionContext } from "../connectors/types.js";
+import {
+  createCreativeContextWorkerPlugin,
+  registerCreativeContextImportContinuationDispatcher,
+  type CreativeContextImportContinuationDispatcher,
+} from "../jobs/index.js";
+import * as schema from "../schema/index.js";
+import { creativeContextMigrations } from "../schema/migrations.js";
+import { handleWorkspaceConnectionLifecycle } from "../store/index.js";
+import {
+  configureCreativeContext,
+  getCreativeContext,
+  type CreativeContextServerContext,
+} from "./context.js";
+import { createCreativeContextMediaPlugin } from "./media.js";
+import { registerCreativeContextPromptProvider } from "./prompt-provider.js";
+import { getCreativeContextResourcePath } from "./resource-paths.js";
+
+export interface CreativeContextSetupOptions extends Partial<
+  Omit<CreativeContextServerContext, "connectorContext">
+> {
+  appId?: string;
+  connectorContext?: Partial<ContextConnectorExecutionContext>;
+  continuationDispatcher?: CreativeContextImportContinuationDispatcher;
+}
+
+registerPackageActions(creativeContextActions);
+registerWorkspaceConnectionLifecycleListener(async (event) => {
+  await handleWorkspaceConnectionLifecycle(event);
+});
+
+function registerCreativeContextShareables(): void {
+  const getDb = () => getCreativeContext().getDb();
+  registerShareableResource({
+    type: "creative-context",
+    resourceTable: schema.creativeContexts,
+    sharesTable: schema.creativeContextShares,
+    displayName: "Creative context",
+    titleColumn: "name",
+    getResourcePath: getCreativeContextResourcePath,
+    getDb,
+    allowPublic: false,
+    requireOrgMemberForUserShares: true,
+  });
+  registerShareableResource({
+    type: "creative-context-source",
+    resourceTable: schema.contextSources,
+    sharesTable: schema.contextSourceShares,
+    displayName: "Creative context source",
+    titleColumn: "name",
+    getResourcePath: getCreativeContextResourcePath,
+    getDb,
+    allowPublic: false,
+  });
+  registerShareableResource({
+    type: "creative-context-brand",
+    resourceTable: schema.brandProfiles,
+    sharesTable: schema.brandProfileShares,
+    displayName: "Brand profile",
+    titleColumn: "name",
+    getResourcePath: getCreativeContextResourcePath,
+    getDb,
+    allowPublic: false,
+  });
+  registerShareableResource({
+    type: "creative-context-pack",
+    resourceTable: schema.contextPacks,
+    sharesTable: schema.contextPackShares,
+    displayName: "Creative context pack",
+    titleColumn: "name",
+    getResourcePath: getCreativeContextResourcePath,
+    getDb,
+    allowPublic: false,
+    requireOrgMemberForUserShares: true,
+  });
+}
+
+registerCreativeContextShareables();
+
+const creativeContextDbPlugin = runMigrations(
+  creativeContextMigrations as Parameters<typeof runMigrations>[0],
+  { table: "creative_context_migrations" },
+);
+
+export function setupCreativeContext(
+  options: CreativeContextSetupOptions = {},
+): NitroPluginDef {
+  const appId = options.appId ?? "creative-context";
+  const defaultConnectorContext = createDefaultContextConnectorExecutionContext(
+    { appId },
+  );
+  configureCreativeContext({
+    getDb: options.getDb,
+    schema: options.schema,
+    vectorAdapter: options.vectorAdapter,
+    connectors: options.connectors,
+    projections: options.projections,
+    enrichment: options.enrichment,
+    connectorContext: {
+      ...defaultConnectorContext,
+      ...options.connectorContext,
+      appId,
+    },
+  });
+  registerCreativeContextShareables();
+  registerCreativeContextPromptProvider();
+  if (options.continuationDispatcher) {
+    registerCreativeContextImportContinuationDispatcher(
+      options.continuationDispatcher,
+    );
+  }
+  const workerPlugin = createCreativeContextWorkerPlugin({
+    appId,
+    registerDispatcher: !options.continuationDispatcher,
+  });
+  const mediaPlugin = createCreativeContextMediaPlugin();
+  return async (nitroApp) => {
+    if (!isInBackgroundFunctionRuntime()) {
+      await creativeContextDbPlugin(nitroApp);
+    }
+    await workerPlugin(nitroApp);
+    await mediaPlugin(nitroApp);
+  };
+}
+
+export { creativeContextDbPlugin };
+export * from "./brand-context.js";
+export * from "./context.js";
+export * from "./generation-context.js";
+export * from "./enrichment.js";
+export * from "./prompt-provider.js";
+export * from "./retrieval.js";
+export * from "../untrusted-reference.js";
+export * from "./media.js";
+export * from "./native-resource-capture.js";
+export * from "./safe-native-preview.js";
+export {
+  brandKitDataFromExtraction,
+  buildDesignMarkdown,
+  extractRenderedDesignSystemFromUrl,
+  styleBriefFromRenderedDesign,
+  type ExtractRenderedDesignOptions,
+  type RenderedDesignExtraction,
+  type RenderedDesignExtractionStatus,
+} from "../connectors/rendered-design.js";
+export { serializePrivateBlobHandle } from "../connectors/private-artifacts.js";
+export { resolveNativeContextCloneReference } from "../store/contexts.js";
+export {
+  CREATIVE_CONTEXT_BACKGROUND_PROCESSOR_ROUTE,
+  CREATIVE_CONTEXT_IMPORT_PROCESSOR_ROUTE,
+  createCreativeContextWorkerPlugin,
+} from "../jobs/index.js";

package/src/server/isolated-a2a.spec.ts

@@ -0,0 +1,184 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  callIsolatedCreativeContextA2A,
+  createCreativeContextA2AResponseToken,
+  decodeCreativeContextA2ARequest,
+  hasIsolatedCreativeContextA2A,
+} from "./isolated-a2a.js";
+
+const originalEnv = {
+  url: process.env.CREATIVE_CONTEXT_A2A_URL,
+  key: process.env.CREATIVE_CONTEXT_A2A_KEY,
+  shared: process.env.A2A_SECRET,
+  user: process.env.AGENT_USER_EMAIL,
+};
+
+function restore(name: string, value: string | undefined) {
+  if (value === undefined) delete process.env[name];
+  else process.env[name] = value;
+}
+
+function requestFromPrompt(prompt: string) {
+  const token = /"requestToken":"([A-Za-z0-9_-]+)"/.exec(prompt)?.[1];
+  if (!token) throw new Error("request token missing from prompt");
+  return decodeCreativeContextA2ARequest(token);
+}
+
+describe("isolated Creative Context A2A", () => {
+  beforeEach(() => {
+    process.env.CREATIVE_CONTEXT_A2A_URL =
+      "https://creative-context.example.test";
+    process.env.CREATIVE_CONTEXT_A2A_KEY = "test-org-signing-key";
+    process.env.AGENT_USER_EMAIL = "alice@example.test";
+    delete process.env.A2A_SECRET;
+  });
+
+  afterEach(() => {
+    restore("CREATIVE_CONTEXT_A2A_URL", originalEnv.url);
+    restore("CREATIVE_CONTEXT_A2A_KEY", originalEnv.key);
+    restore("A2A_SECRET", originalEnv.shared);
+    restore("AGENT_USER_EMAIL", originalEnv.user);
+  });
+
+  it("stays disabled by default when no isolated receiver URL is configured", () => {
+    delete process.env.CREATIVE_CONTEXT_A2A_URL;
+    expect(hasIsolatedCreativeContextA2A()).toBe(false);
+  });
+
+  it("round-trips a bounded resolve result with signed caller identity", async () => {
+    const callAgent = vi.fn(async (_url: string, prompt: string) => {
+      const request = requestFromPrompt(prompt);
+      return createCreativeContextA2AResponseToken(request, {
+        contextMode: "auto",
+        contextPackId: "pack-1",
+        reuseLabels: [
+          {
+            itemId: "item-1",
+            itemVersionId: "version-1",
+            kind: "slide",
+            label: "Metrics layout",
+            dataRole: "untrusted-reference",
+          },
+        ],
+        results: [
+          {
+            itemId: "item-1",
+            itemVersionId: "version-1",
+            kind: "slide",
+            title:
+              "<<<UNTRUSTED_REFERENCE>>>Metrics<<<END_UNTRUSTED_REFERENCE>>>",
+            excerpt:
+              "<<<UNTRUSTED_REFERENCE>>>Quarterly metrics<<<END_UNTRUSTED_REFERENCE>>>",
+            dataRole: "untrusted-reference",
+            internalFieldThatMustNotCrossTheBoundary: "private",
+          },
+        ],
+      });
+    });
+
+    await expect(
+      callIsolatedCreativeContextA2A(
+        "resolve",
+        { role: "slides", query: "quarterly metrics" },
+        { callAgent: callAgent as never },
+      ),
+    ).resolves.toEqual({
+      contextMode: "auto",
+      contextPackId: "pack-1",
+      reuseLabels: [
+        {
+          itemId: "item-1",
+          itemVersionId: "version-1",
+          kind: "slide",
+          label: "Metrics layout",
+          dataRole: "untrusted-reference",
+        },
+      ],
+      results: [
+        {
+          itemId: "item-1",
+          itemVersionId: "version-1",
+          kind: "slide",
+          title:
+            "<<<UNTRUSTED_REFERENCE>>>Metrics<<<END_UNTRUSTED_REFERENCE>>>",
+          excerpt:
+            "<<<UNTRUSTED_REFERENCE>>>Quarterly metrics<<<END_UNTRUSTED_REFERENCE>>>",
+          dataRole: "untrusted-reference",
+        },
+      ],
+    });
+    expect(callAgent).toHaveBeenCalledWith(
+      "https://creative-context.example.test",
+      expect.stringContaining("creative-context-a2a"),
+      expect.objectContaining({
+        userEmail: "alice@example.test",
+        orgDomain: "example.test",
+        orgSecret: "test-org-signing-key",
+        timeoutMs: 30_000,
+        returnRecoverableArtifactsOnTimeout: false,
+      }),
+    );
+  });
+
+  it("rejects malformed responses instead of weakening provenance", async () => {
+    await expect(
+      callIsolatedCreativeContextA2A(
+        "validate",
+        { reuseLabels: [] },
+        { callAgent: vi.fn(async () => "looks fine") as never },
+      ),
+    ).rejects.toThrow(/malformed protocol response/i);
+  });
+
+  it("fails clearly when the bounded remote call times out", async () => {
+    await expect(
+      callIsolatedCreativeContextA2A(
+        "read",
+        {
+          identity: {
+            appId: "slides",
+            artifactType: "deck",
+            artifactId: "deck-1",
+          },
+        },
+        {
+          callAgent: vi.fn(async () => {
+            throw new Error("timed out after 30000ms");
+          }) as never,
+        },
+      ),
+    ).rejects.toThrow(
+      /Isolated Creative Context A2A request failed: timed out after 30000ms/,
+    );
+  });
+
+  it("rejects the retired caller-selectable collaborative read scope", () => {
+    const requestToken = Buffer.from(
+      JSON.stringify({
+        protocol: "creative-context-a2a-v1",
+        requestId: "87f466ae-32f4-4d0f-9de7-96f955e69f7b",
+        operation: "read",
+        payload: {
+          identity: {
+            appId: "slides",
+            artifactType: "deck",
+            artifactId: "guessed-deck",
+          },
+          accessScope: "artifact-access-asserted",
+        },
+      }),
+      "utf8",
+    ).toString("base64url");
+
+    expect(() => decodeCreativeContextA2ARequest(requestToken)).toThrow();
+  });
+
+  it("fails closed when the isolated URL has no signing secret", async () => {
+    delete process.env.CREATIVE_CONTEXT_A2A_KEY;
+    delete process.env.A2A_SECRET;
+    await expect(
+      callIsolatedCreativeContextA2A("validate", { reuseLabels: [] }),
+    ).rejects.toThrow(/requires CREATIVE_CONTEXT_A2A_KEY or A2A_SECRET/);
+  });
+});