@noodleseed/one 0.155.0 → 0.156.0

package/dist/assistant-embed-profile.js

@@ -0,0 +1,150 @@
+import { embedBrowserContractTest } from './assistant-embed-tests.js';
+/** Reuse preflight's explicit env aliases instead of duplicating browser configuration. */
+export function embedCheckCommand(surface) {
+    const flags = surface === 'public'
+        ? ' --env-alias NOODLE_SERVICE_URL=NEXT_PUBLIC_NOODLE_SERVICE_URL --require-env NEXT_PUBLIC_NOODLE_EMBED_ID'
+        : surface === 'mixed'
+            ? ' --require-env NEXT_PUBLIC_NOODLE_EMBED_ID --require-env NEXT_PUBLIC_NOODLE_SERVICE_URL'
+            : '';
+    return `noodle assistant embed --check --surface ${surface}${flags} --json`;
+}
+/** Public mounting uses the existing hosted session source, never a customer proxy route. */
+export function publicEmbedFiles(surface) {
+    const mixed = surface === 'mixed';
+    return {
+        'test/noodle-assistant.browser.mjs': embedBrowserContractTest(),
+        'components/noodle-assistant.tsx': `'use client';
+
+import dynamic from 'next/dynamic';
+${mixed ? "import { useEffect, useRef } from 'react';\n" : ''}
+const NoodleAssistant = dynamic(
+  () => import('@noodleseed/assistant/react').then((mod) => mod.NoodleAssistant),
+  { ssr: false },
+);
+${mixed
+            ? `
+export interface AssistantSignInRequest {
+  readonly signInTicket: string;
+  readonly expiresAt: string;
+  readonly intent: 'sign-in' | 'sign-up';
+}
+
+/** Bind the ticket to your backend's existing login transaction; never put it in a URL or storage. */
+export function AssistantWidget({ principalKey, onSignInRequested }: {
+  /** Null while anonymous; change this stable user/tenant key whenever the signed-in account changes. */
+  readonly principalKey: string | null;
+  readonly onSignInRequested: (request: AssistantSignInRequest) => void;
+}) {
+  const host = useRef<HTMLDivElement>(null);
+  useEffect(() => {
+    const element = host.current;
+    if (!element) return;
+    const signIn = (event: Event) => {
+      if (!(event instanceof CustomEvent)) return;
+      const detail: unknown = event.detail;
+      if (typeof detail !== 'object' || detail === null ||
+          !('signInTicket' in detail) || typeof detail.signInTicket !== 'string' ||
+          !('expiresAt' in detail) || typeof detail.expiresAt !== 'string' ||
+          !('intent' in detail) || (detail.intent !== 'sign-in' && detail.intent !== 'sign-up')) return;
+      onSignInRequested({ signInTicket: detail.signInTicket, expiresAt: detail.expiresAt, intent: detail.intent });
+    };
+    element.addEventListener('assistant-sign-in-requested', signIn);
+    return () => element.removeEventListener('assistant-sign-in-requested', signIn);
+  }, [onSignInRequested]);
+  return <div ref={host}>{principalKey === null ? <NoodleAssistant
+    key="anonymous"
+    embedId={process.env.NEXT_PUBLIC_NOODLE_EMBED_ID}
+    serviceUrl={process.env.NEXT_PUBLIC_NOODLE_SERVICE_URL}
+    theme="auto"
+  /> : <NoodleAssistant
+    key={principalKey}
+    sessionEndpoint="/api/assistant/session"
+    theme="auto"
+  />}</div>;
+}`
+            : `
+/** The embed ID is public configuration; the runtime owns anonymous sessions and admission. */
+export function AssistantWidget() {
+  return <NoodleAssistant
+    embedId={process.env.NEXT_PUBLIC_NOODLE_EMBED_ID}
+    serviceUrl={process.env.NEXT_PUBLIC_NOODLE_SERVICE_URL}
+    theme="auto"
+  />;
+}`}
+`,
+        '.env.local.example': `# Public configuration only; safe in the browser bundle.
+# Use the local embed ID printed by noodle dev, or the hosted ID printed by noodle deploy.
+NEXT_PUBLIC_NOODLE_EMBED_ID=
+NEXT_PUBLIC_NOODLE_SERVICE_URL=https://cloud.noodleseed.dev
+${mixed ? '' : 'PUBLIC_APP_ORIGIN=http://localhost:3000\n'}# Run checks with these names exported; the CLI does not load application dotenv files.
+# Declare the page's exact origin in publicWebsite({ origins: [...] }).
+# If the host sends CSP, allow the service in connect-src and frame-src.
+# Script-tag mounts also require script-src. No customer backend config route is needed.
+`,
+        'NOODLE-INTEGRATION.md': embedIntegrationGuide(surface),
+    };
+}
+/** One customer handoff accompanies every installed profile and its machine-readable plan. */
+export function embedIntegrationGuide(surface) {
+    return `# Noodle application integration
+
+Surface: **${surface}**. Installation is not integration proof: application authorization, backend operations
+and browser behavior are **unverified** until the checks below execute against your application.
+
+## Application-owned changes
+
+${surface === 'public'
+        ? `Set the public embed ID and service URL, then render \`AssistantWidget\`. Public sessions need no customer
+backend session/config route or backend credential. Reuse existing business endpoints for capability data.
+Public admission and capability allowlists are enforced by the runtime; Origin alone is not authentication.`
+        : `Implement \`authenticateAssistantRequest\` in \`lib/noodle-assistant-auth.ts\` using the existing login/session
+and backend membership checks. It returns null for signed-out callers. Derive identity, tenant, roles,
+scopes and routing server-side; never accept them from browser JSON. Preserve your application's CSRF policy.
+Keep backend exchange credentials in the existing server secret manager, never in browser-prefixed variables.`}
+${surface === 'mixed'
+        ? `
+Supply \`AssistantWidget\`'s \`principalKey\` (null while anonymous, then a stable user/tenant key) and
+\`onSignInRequested\` callback. The key resets browser state on account changes; it is not authentication.
+Bind \`signInTicket\` to a short-lived backend login
+transaction before using the existing login or signup flow. After authentication, spend that ticket through
+the generated authentication adapter by returning \`signInTicket\` with the verified user; the maintained handler
+spends it and forwards the response unchanged
+through the destination's same-origin session endpoint. Never put a ticket in URLs, analytics, logs or durable
+browser storage. Ticket possession is not authentication or confirmation. This application-owned transaction
+is unverified until your login round trip is tested; do not silently replace it with a new anonymous session.
+`
+        : ''}
+
+Reuse the application's existing business functions and authorization. Add a thin stable HTTPS handler only
+when no suitable API exists. Keep \`server.ts\` in the Noodle project; do not duplicate business logic or create
+a second login system. The customer application remains the system of record.
+
+## Verify before declaring readiness
+
+1. Install a compatible \`@noodleseed/assistant\` version in this application's package manager and build the host.
+${surface === 'public' ? '' : '   The server entry must export `createAssistantSessionHandler`. Run the supplied contract suite with your Vitest runner: `vitest run test/noodle-assistant.test.ts`. If the application has no Vitest dependency, add it using its existing package manager first. The suite exercises the generated route with synthetic identities; add real session/membership acceptance cases in your existing test harness.\n'}
+2. Configure the exact origins and operator bindings; do not put environment-specific secrets in source.
+3. With these environment names exported, run \`${embedCheckCommand(surface)}\`; this is static evidence only.
+4. ${surface === 'public' ? 'Exercise anonymous discovery and a safe handoff, and prove private capabilities are unavailable.' : 'Test signed-out JSON 401, wrong-origin rejection, invalid JSON/content type, and successful verified identity.'}
+5. Test cross-tenant denial at the real application boundary and an authorized read plus confirmed action or handoff.
+6. Exercise the actual browser mount, CSP, one turn and any linked App in an authorized local or sandbox environment.
+
+The supplied mount check runs with \`node --test test/noodle-assistant.browser.mjs\` while the application is
+running at \`PUBLIC_APP_ORIGIN\`. It uses Playwright and Chromium; reuse the application's browser-test setup,
+or add Playwright as a development dependency and install Chromium first. Reuse existing login fixtures for
+protected pages. This check does not submit a turn, confirm an action or claim production readiness.
+
+Missing credentials, a test identity, a reachable sandbox or an authorized action remain unverified. Mock tests
+prove only their fixtures. Do not call a production mutation just to complete a check.
+
+## Ownership and updates
+
+These files are customer-owned after installation. Preview with \`noodle assistant embed --surface ${surface} --dry-run --json\`;
+reruns create missing files and report conflicts without overwriting modifications. Review changes before using
+\`--force\`. Keep custom session/business code and secrets; update library versions through the normal dependency
+workflow and rerun the integration checks. Deployment, configuration writes and publication need their own authority.
+
+Guide: https://docs.noodleseed.dev/docs/guides/embedded-assistant
+`;
+}
+//# sourceMappingURL=assistant-embed-profile.js.map

package/dist/assistant-embed-profile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistant-embed-profile.js","sourceRoot":"","sources":["../src/assistant-embed-profile.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,2FAA2F;AAC3F,MAAM,UAAU,iBAAiB,CAAC,OAAqB;IACrD,MAAM,KAAK,GACT,OAAO,KAAK,QAAQ;QAClB,CAAC,CAAC,0GAA0G;QAC5G,CAAC,CAAC,OAAO,KAAK,OAAO;YACnB,CAAC,CAAC,yFAAyF;YAC3F,CAAC,CAAC,EAAE,CAAC;IACX,OAAO,4CAA4C,OAAO,GAAG,KAAK,SAAS,CAAC;AAC9E,CAAC;AAED,6FAA6F;AAC7F,MAAM,UAAU,gBAAgB,CAAC,OAA2B;IAC1D,MAAM,KAAK,GAAG,OAAO,KAAK,OAAO,CAAC;IAClC,OAAO;QACL,mCAAmC,EAAE,wBAAwB,EAAE;QAC/D,iCAAiC,EAAE;;;EAGrC,KAAK,CAAC,CAAC,CAAC,8CAA8C,CAAC,CAAC,CAAC,EAAE;;;;;EAM3D,KAAK;YACH,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCJ;YACE,CAAC,CAAC;;;;;;;;EASN;CACC;QACG,oBAAoB,EAAE;;;;EAIxB,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,2CAA2C;;;;CAIzD;QACG,uBAAuB,EAAE,qBAAqB,CAAC,OAAO,CAAC;KACxD,CAAC;AACJ,CAAC;AAED,8FAA8F;AAC9F,MAAM,UAAU,qBAAqB,CAAC,OAAqB;IACzD,OAAO;;aAEI,OAAO;;;;;EAMlB,OAAO,KAAK,QAAQ;QAClB,CAAC,CAAC;;4GAEsG;QACxG,CAAC,CAAC;;;8GAIN;EAEE,OAAO,KAAK,OAAO;QACjB,CAAC,CAAC;;;;;;;;;;CAUL;QACG,CAAC,CAAC,EACN;;;;;;;;;EASE,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,sZAAsZ;;kDAElY,iBAAiB,CAAC,OAAO,CAAC;KACvE,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,kGAAkG,CAAC,CAAC,CAAC,gHAAgH;;;;;;;;;;;;;;qGAc5I,OAAO;;;;;;CAM3G,CAAC;AACF,CAAC"}

package/dist/assistant-embed-scaffold-template.d.ts

@@ -5,7 +5,8 @@
  * reconciles per file and never overwrites user edits without `--force`
  * (docs/roadmap/embedded-assistant-hardening.md S8).
  */
-export type EmbedFramework = 'nextjs';
+export type EmbedFramework = 'nextjs' | 'django-vue';
+export type EmbedSurface = 'authenticated' | 'public' | 'mixed';
 /** Return the canonical files for embedding an assistant in one supported host framework. */
-export declare function embedScaffoldFiles(framework: EmbedFramework): Record<string, string>;
+export declare function embedScaffoldFiles(framework: EmbedFramework, surface?: EmbedSurface): Record<string, string>;
 //# sourceMappingURL=assistant-embed-scaffold-template.d.ts.map

package/dist/assistant-embed-scaffold-template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assistant-embed-scaffold-template.d.ts","sourceRoot":"","sources":["../src/assistant-embed-scaffold-template.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;AAEtC,6FAA6F;AAC7F,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAqIpF"}
+{"version":3,"file":"assistant-embed-scaffold-template.d.ts","sourceRoot":"","sources":["../src/assistant-embed-scaffold-template.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,YAAY,CAAC;AACrD,MAAM,MAAM,YAAY,GAAG,eAAe,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEhE,6FAA6F;AAC7F,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,cAAc,EACzB,OAAO,GAAE,YAA8B,GACtC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAqFxB"}

package/dist/assistant-embed-scaffold-template.js

@@ -5,99 +5,41 @@
  * reconciles per file and never overwrites user edits without `--force`
  * (docs/roadmap/embedded-assistant-hardening.md S8).
  */
+import { djangoEmbedFiles } from './assistant-embed-django.js';
+import { embedIntegrationGuide, publicEmbedFiles } from './assistant-embed-profile.js';
+import { embedBrowserContractTest, nextSessionContractTest } from './assistant-embed-tests.js';
 /** Return the canonical files for embedding an assistant in one supported host framework. */
-export function embedScaffoldFiles(framework) {
+export function embedScaffoldFiles(framework, surface = 'authenticated') {
+    if (framework === 'django-vue') {
+        if (surface !== 'authenticated')
+            throw new Error('django-vue supports authenticated surfaces only');
+        return djangoEmbedFiles();
+    }
     if (framework !== 'nextjs')
         throw new Error(`unsupported framework: ${String(framework)}`);
-    return {
-        'app/api/assistant/session/route.ts': `import { createAssistantSession } from '@noodleseed/assistant/server';
+    if (surface === 'public')
+        return publicEmbedFiles(surface);
+    const files = {
+        'app/api/assistant/session/route.ts': `import { createAssistantSessionHandler } from '@noodleseed/assistant/server';
 import { authenticateAssistantRequest } from '../../../../lib/noodle-assistant-auth';
 
-type AssistantContextValue = string | number | boolean | null;
-type AssistantSessionRequest = {
-  readonly context?: Readonly<Record<string, AssistantContextValue>>;
-};
-
-/**
- * Exchange the signed-in user for a short-lived assistant session.
- * The browser never sees NOODLE_ASSISTANT_CLIENT_SECRET or a model key.
- */
-export async function POST(request: Request) {
-  const appOrigin = requireEnv('PUBLIC_APP_ORIGIN');
-  if (request.headers.get('origin') !== appOrigin) {
-    return jsonError(403, 'origin is not allowed');
-  }
-  if (request.headers.get('content-type')?.split(';', 1)[0]?.trim().toLowerCase() !== 'application/json') {
-    return jsonError(415, 'application/json required');
-  }
-
-  // This direct adapter call avoids auth middleware turning an API failure into an HTML login redirect.
-  const identity = await authenticateAssistantRequest(request);
-  if (identity === null) return jsonError(401, 'authentication required');
-
-  let parsed: unknown;
-  try {
-    parsed = await request.json();
-  } catch {
-    return jsonError(400, 'invalid JSON');
-  }
-  if (!isAssistantSessionRequest(parsed)) {
-    return jsonError(400, 'invalid request body');
-  }
-
-  const session = await createAssistantSession({
-    serviceUrl: requireEnv('NOODLE_SERVICE_URL'),
-    clientId: requireEnv('NOODLE_ASSISTANT_CLIENT_ID'),
-    clientSecret: requireEnv('NOODLE_ASSISTANT_CLIENT_SECRET'),
-    origin: appOrigin,
-    ...identity,
-    ...(parsed.context !== undefined ? { context: parsed.context } : {}),
-  });
-  // Forward the session unchanged: the widget reads endpoints/configuration from it directly.
-  return Response.json(session, { headers: { 'Cache-Control': 'no-store' } });
-}
-
-/** Accept only the bounded body that the embedding backend may forward into an assistant session. */
-function isAssistantSessionRequest(value: unknown): value is AssistantSessionRequest {
-  if (!isRecord(value) || Object.keys(value).some((key) => key !== 'context')) return false;
-  if (value.context === undefined) return true;
-  return (
-    isRecord(value.context) &&
-    Object.values(value.context).every(
-      (entry) =>
-        entry === null ||
-        typeof entry === 'string' ||
-        typeof entry === 'number' ||
-        typeof entry === 'boolean',
-    )
-  );
-}
-
-/** Reject null and arrays before reading JSON object fields. */
-function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function requireEnv(name: string): string {
-  const value = process.env[name];
-  if (value === undefined || value === '') throw new Error(\`\${name} is not configured\`);
-  return value;
-}
-
-function jsonError(status: number, error: string): Response {
-  return Response.json({ error }, { status, headers: { 'Cache-Control': 'no-store' } });
-}
+// Library-owned guards, bounded parsing and exchange. Only the existing login adapter is app-specific.
+// Keep these credentials server-only and preserve any stricter application CSRF middleware.
+export const POST = createAssistantSessionHandler({
+  serviceUrl: process.env.NOODLE_SERVICE_URL,
+  clientId: process.env.NOODLE_ASSISTANT_CLIENT_ID,
+  clientSecret: process.env.NOODLE_ASSISTANT_CLIENT_SECRET,
+  origin: process.env.PUBLIC_APP_ORIGIN,
+  authenticate: authenticateAssistantRequest,
+});
 `,
-        'lib/noodle-assistant-auth.ts': `import type { CreateAssistantSessionInput } from '@noodleseed/assistant/server';
+        'lib/noodle-assistant-auth.ts': `import type { AssistantSessionIdentity } from '@noodleseed/assistant/server';
 
 /**
  * The only application-specific adapter in the generated integration. Replace the function body with
  * the host application's existing cookie/JWT auth and server-owned membership lookup.
  */
-export type NoodleAssistantIdentity = Pick<
-  CreateAssistantSessionInput,
-  'user' | 'claims' | 'preferences' | 'routing'
->;
+export type NoodleAssistantIdentity = AssistantSessionIdentity;
 
 export async function authenticateAssistantRequest(
   _request: Request,
@@ -105,6 +47,8 @@ export async function authenticateAssistantRequest(
   // Return null for a signed-out request; the route converts it to a JSON 401. Do not redirect here.
   // Derive roles, scopes, claims, and routing only from verified backend state. In particular,
   // routing.endpoints must come from server-owned membership, never request JSON or headers.
+  // For mixed-mode continuation, return signInTicket only from the backend-bound login transaction;
+  // browser JSON cannot select it. The library preserves the continued session and automatic resume.
   //
   // The route's JSON content type plus exact-Origin check is its minimum cookie/CSRF boundary. If the
   // host requires a CSRF token header, keep that middleware and use the DOM-free client with an injected
@@ -112,6 +56,8 @@ export async function authenticateAssistantRequest(
   return null;
 }
 `,
+        'test/noodle-assistant.test.ts': nextSessionContractTest(),
+        'test/noodle-assistant.browser.mjs': embedBrowserContractTest(),
         'components/noodle-assistant.tsx': `'use client';
 
 import dynamic from 'next/dynamic';
@@ -123,8 +69,10 @@ const NoodleAssistant = dynamic(
 );
 
 /** Mount only inside the authenticated application surface. */
-export function AssistantWidget() {
-  return <NoodleAssistant sessionEndpoint="/api/assistant/session" theme="auto" />;
+export function AssistantWidget({ principalKey }: { readonly principalKey: string }) {
+  // Stable user/tenant key from existing application state. Remount when the account changes.
+  // This key clears browser state; the backend session adapter remains the identity authority.
+  return <NoodleAssistant key={principalKey} sessionEndpoint="/api/assistant/session" theme="auto" />;
 }
 `,
         '.env.local.example': `# Backend-only assistant credentials — from \`noodle assistant clients create\`.
@@ -140,5 +88,12 @@ PUBLIC_APP_ORIGIN=http://localhost:3000
 # noodle assistant embed --check --json
 `,
     };
+    return {
+        ...files,
+        ...(surface === 'mixed' ? publicEmbedFiles(surface) : {}),
+        '.env.local.example': files['.env.local.example'] +
+            (surface === 'mixed' ? publicEmbedFiles(surface)['.env.local.example'] : ''),
+        'NOODLE-INTEGRATION.md': embedIntegrationGuide(surface),
+    };
 }
 //# sourceMappingURL=assistant-embed-scaffold-template.js.map

package/dist/assistant-embed-scaffold-template.js.map

@@ -1 +1 @@
-{"version":3,"file":"assistant-embed-scaffold-template.js","sourceRoot":"","sources":["../src/assistant-embed-scaffold-template.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,6FAA6F;AAC7F,MAAM,UAAU,kBAAkB,CAAC,SAAyB;IAC1D,IAAI,SAAS,KAAK,QAAQ;QAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IAC3F,OAAO;QACL,oCAAoC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EzC;QACG,8BAA8B,EAAE;;;;;;;;;;;;;;;;;;;;;;;CAuBnC;QACG,iCAAiC,EAAE;;;;;;;;;;;;;;CActC;QACG,oBAAoB,EAAE;;;;;;;;;;;CAWzB;KACE,CAAC;AACJ,CAAC"}
+{"version":3,"file":"assistant-embed-scaffold-template.js","sourceRoot":"","sources":["../src/assistant-embed-scaffold-template.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACvF,OAAO,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAK/F,6FAA6F;AAC7F,MAAM,UAAU,kBAAkB,CAChC,SAAyB,EACzB,UAAwB,eAAe;IAEvC,IAAI,SAAS,KAAK,YAAY,EAAE,CAAC;QAC/B,IAAI,OAAO,KAAK,eAAe;YAC7B,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;QACrE,OAAO,gBAAgB,EAAE,CAAC;IAC5B,CAAC;IACD,IAAI,SAAS,KAAK,QAAQ;QAAE,MAAM,IAAI,KAAK,CAAC,0BAA0B,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IAC3F,IAAI,OAAO,KAAK,QAAQ;QAAE,OAAO,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC3D,MAAM,KAAK,GAAG;QACZ,oCAAoC,EAAE;;;;;;;;;;;;CAYzC;QACG,8BAA8B,EAAE;;;;;;;;;;;;;;;;;;;;;;CAsBnC;QACG,+BAA+B,EAAE,uBAAuB,EAAE;QAC1D,mCAAmC,EAAE,wBAAwB,EAAE;QAC/D,iCAAiC,EAAE;;;;;;;;;;;;;;;;CAgBtC;QACG,oBAAoB,EAAE;;;;;;;;;;;CAWzB;KACE,CAAC;IACF,OAAO;QACL,GAAG,KAAK;QACR,GAAG,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACzD,oBAAoB,EAClB,KAAK,CAAC,oBAAoB,CAAC;YAC3B,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9E,uBAAuB,EAAE,qBAAqB,CAAC,OAAO,CAAC;KACxD,CAAC;AACJ,CAAC"}

package/dist/assistant-embed-tests.d.ts

@@ -0,0 +1,5 @@
+/** Runnable browser mount check; opening the assistant or executing a workflow is deliberately separate. */
+export declare function embedBrowserContractTest(): string;
+/** Executable customer-side contract tests; synthetic identities are not proof of the real login seam. */
+export declare function nextSessionContractTest(): string;
+//# sourceMappingURL=assistant-embed-tests.d.ts.map

package/dist/assistant-embed-tests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistant-embed-tests.d.ts","sourceRoot":"","sources":["../src/assistant-embed-tests.ts"],"names":[],"mappings":"AAAA,4GAA4G;AAC5G,wBAAgB,wBAAwB,IAAI,MAAM,CA2BjD;AAED,0GAA0G;AAC1G,wBAAgB,uBAAuB,IAAI,MAAM,CA0EhD"}

package/dist/assistant-embed-tests.js

@@ -0,0 +1,106 @@
+/** Runnable browser mount check; opening the assistant or executing a workflow is deliberately separate. */
+export function embedBrowserContractTest() {
+    return `import assert from 'node:assert/strict';
+import test from 'node:test';
+import { chromium } from 'playwright';
+
+test('assistant mounts in the running customer application', { timeout: 30_000 }, async () => {
+  const origin = process.env.PUBLIC_APP_ORIGIN;
+  assert.ok(origin, 'Set PUBLIC_APP_ORIGIN to the running local or approved sandbox application.');
+  assert.equal(new URL(origin).origin, origin, 'PUBLIC_APP_ORIGIN must be an exact origin, without a path.');
+  const browser = await chromium.launch({ headless: true });
+  try {
+    // If the application requires login before this page, reuse its existing login fixture here.
+    // Never commit a real cookie/token or log a session. This test never submits a turn or action.
+    const page = await browser.newPage();
+    const failures = [];
+    page.on('pageerror', () => failures.push('browser JavaScript failed'));
+    await page.goto(origin);
+    await page.waitForFunction(() => Boolean(
+      customElements.get('noodle-assistant') && document.querySelector('noodle-assistant')?.shadowRoot,
+    ));
+    assert.deepEqual(failures, []);
+    assert.equal(await page.locator('noodle-assistant').count(), 1);
+  } finally { await browser.close(); }
+});
+// This proves mounting only. Separately prove real session/tenant rules, CSP, one read and a confirmed
+// action or handoff, using approved sandbox data. Installed files and a mounted component are not readiness.
+`;
+}
+/** Executable customer-side contract tests; synthetic identities are not proof of the real login seam. */
+export function nextSessionContractTest() {
+    return `import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { authenticateAssistantRequest } from '../lib/noodle-assistant-auth';
+
+vi.mock('../lib/noodle-assistant-auth', () => ({ authenticateAssistantRequest: vi.fn() }));
+
+const session = {
+  token: 'synthetic-test-session', expiresAt: '2030-01-01T00:00:00Z',
+  endpoints: { turns: 'https://cloud.example/turns', toolConfirmations: 'https://cloud.example/confirmations' },
+};
+const upstream = vi.fn<typeof fetch>();
+let POST: (request: Request) => Promise<Response>;
+
+beforeEach(async () => {
+  vi.resetModules();
+  vi.stubEnv('PUBLIC_APP_ORIGIN', 'https://app.example');
+  vi.stubEnv('NOODLE_SERVICE_URL', 'https://cloud.example');
+  vi.stubEnv('NOODLE_ASSISTANT_CLIENT_ID', 'synthetic-client');
+  vi.stubEnv('NOODLE_ASSISTANT_CLIENT_SECRET', 'synthetic-test-credential');
+  upstream.mockReset().mockImplementation(async () => Response.json(session));
+  vi.stubGlobal('fetch', upstream);
+  vi.mocked(authenticateAssistantRequest).mockReset().mockResolvedValue(null);
+  ({ POST } = await import('../app/api/assistant/session/route'));
+});
+afterEach(() => { vi.unstubAllGlobals(); vi.unstubAllEnvs(); });
+
+function request(body: unknown = {}, origin = 'https://app.example', contentType = 'application/json') {
+  return new Request('https://app.example/api/assistant/session', {
+    method: 'POST', headers: { origin, 'content-type': contentType }, body: JSON.stringify(body),
+  });
+}
+
+describe('generated assistant route (synthetic contract)', () => {
+  it('returns JSON 401, not an HTML redirect, for a signed-out request', async () => {
+    const response = await POST(request());
+    expect(response.status).toBe(401);
+    expect(response.headers.get('location')).toBeNull();
+    expect(response.headers.get('cache-control')).toBe('no-store');
+    expect(response.headers.get('content-type')).toContain('application/json');
+    expect(upstream).not.toHaveBeenCalled();
+  });
+  it('rejects wrong origins and form requests before reading the application session', async () => {
+    expect((await POST(request({}, 'https://attacker.example'))).status).toBe(403);
+    expect((await POST(request({}, 'https://app.example', 'text/plain'))).status).toBe(415);
+    expect(authenticateAssistantRequest).not.toHaveBeenCalled();
+    expect(upstream).not.toHaveBeenCalled();
+  });
+  it('does not let browser JSON replace the backend identity or tenant routes', async () => {
+    vi.mocked(authenticateAssistantRequest).mockResolvedValue({ user: { id: 'person-a', tenant: 'tenant-a' } });
+    expect((await POST(request({ user: { id: 'person-b', tenant: 'tenant-b' } }))).status).toBe(400);
+    expect((await POST(request({ routing: { endpoints: { api: 'https://attacker.example' } } }))).status).toBe(400);
+    expect(upstream).not.toHaveBeenCalled();
+  });
+  it('exchanges only the verified identity and returns the short-lived session', async () => {
+    vi.mocked(authenticateAssistantRequest).mockResolvedValue({ user: { id: 'person-a', tenant: 'tenant-a' } });
+    const response = await POST(request({ context: { page: 'tasks' } }));
+    expect(response.status).toBe(200);
+    expect(await response.json()).toEqual(session);
+    expect(JSON.parse(String(upstream.mock.calls[0]?.[1]?.body))).toMatchObject({
+      user: { id: 'person-a', tenant: 'tenant-a' }, origin: 'https://app.example', context: { page: 'tasks' },
+    });
+  });
+  it('fails closed on a cross-tenant sign-in refusal without retrying the ticket', async () => {
+    vi.mocked(authenticateAssistantRequest).mockResolvedValue({ user: { id: 'person-a' }, signInTicket: 'synthetic-bound-ticket' });
+    upstream.mockResolvedValue(Response.json({ code: 'elevation_tenant_mismatch' }, { status: 403 }));
+    const response = await POST(request());
+    expect(response.status).toBe(403);
+    expect((await response.json()).code).toBe('elevation_tenant_mismatch');
+    expect(upstream).toHaveBeenCalledTimes(1);
+  });
+});
+// Add acceptance tests using your application's own signed-out, tenant-A and tenant-B session fixtures.
+// These synthetic tests prove route wiring, not the membership rules inside authenticateAssistantRequest.
+`;
+}
+//# sourceMappingURL=assistant-embed-tests.js.map

package/dist/assistant-embed-tests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistant-embed-tests.js","sourceRoot":"","sources":["../src/assistant-embed-tests.ts"],"names":[],"mappings":"AAAA,4GAA4G;AAC5G,MAAM,UAAU,wBAAwB;IACtC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;CAyBR,CAAC;AACF,CAAC;AAED,0GAA0G;AAC1G,MAAM,UAAU,uBAAuB;IACrC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwER,CAAC;AACF,CAAC"}

package/dist/assistant-embed-vue.d.ts

@@ -0,0 +1,3 @@
+/** Vue stays static; complex SDK properties are set before connecting the element, including CSRF. */
+export declare function vueEmbedFiles(): Record<string, string>;
+//# sourceMappingURL=assistant-embed-vue.d.ts.map

package/dist/assistant-embed-vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistant-embed-vue.d.ts","sourceRoot":"","sources":["../src/assistant-embed-vue.ts"],"names":[],"mappings":"AAAA,sGAAsG;AACtG,wBAAgB,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA0EtD"}

package/dist/assistant-embed-vue.js

@@ -0,0 +1,77 @@
+/** Vue stays static; complex SDK properties are set before connecting the element, including CSRF. */
+export function vueEmbedFiles() {
+    return {
+        'src/components/NoodleAssistant.vue': `<script setup lang="ts">
+import { onBeforeUnmount, onMounted, ref, watch } from 'vue';
+import type { NoodleAssistantElement } from '@noodleseed/assistant';
+import { assistantSessionFetch } from '../lib/noodle-assistant-transport';
+
+const props = defineProps<{ principalKey: string; csrfToken: string }>();
+const host = ref<HTMLDivElement>();
+let element: NoodleAssistantElement | undefined;
+let disposed = false;
+
+onMounted(async () => {
+  await import('@noodleseed/assistant');
+  if (disposed || !host.value) return;
+  element = document.createElement('noodle-assistant') as NoodleAssistantElement;
+  element.fetch = assistantSessionFetch(window.location.origin, () => props.csrfToken);
+  element.sessionEndpoint = '/api/assistant/session';
+  element.setAttribute('theme', 'auto');
+  host.value.append(element);
+});
+// This key clears browser state, never grants authority. Django re-verifies the actual session.
+watch(() => props.principalKey, () => element?.resetSession());
+onBeforeUnmount(() => { disposed = true; element?.remove(); element = undefined; });
+</script>
+
+<template><div ref="host" /></template>
+`,
+        'src/lib/noodle-assistant-transport.ts': `/** Preserve Django CSRF without forwarding the token to Noodle or another origin. */
+export function assistantSessionFetch(
+  origin: string,
+  csrfToken: () => string,
+  transport: typeof fetch = fetch,
+): typeof fetch {
+  return (input, init) => {
+    const request = new Request(input instanceof Request ? input : new URL(input, origin), init);
+    const url = new URL(request.url);
+    if (url.origin === origin && url.pathname === '/api/assistant/session' && request.method === 'POST') {
+      const token = csrfToken();
+      if (!token) return Promise.reject(new Error('Application CSRF token is unavailable'));
+      request.headers.set('X-CSRFToken', token);
+    } else {
+      request.headers.delete('X-CSRFToken');
+    }
+    return transport(request);
+  };
+}
+`,
+        'test/noodle-assistant-transport.test.ts': `import { describe, expect, it, vi } from 'vitest';
+import { assistantSessionFetch } from '../src/lib/noodle-assistant-transport';
+
+describe('Django session CSRF transport', () => {
+  it('adds the current X-CSRFToken only to the same-origin session POST', async () => {
+    const transport = vi.fn<typeof fetch>().mockResolvedValue(Response.json({}));
+    let token = 'synthetic-csrf-one';
+    const request = assistantSessionFetch('https://app.example', () => token, transport);
+    await request('/api/assistant/session', { method: 'POST', body: '{}' });
+    expect((transport.mock.calls[0]?.[0] as Request).headers.get('X-CSRFToken')).toBe(token);
+    token = 'synthetic-csrf-two';
+    await request('/api/assistant/session', { method: 'POST', body: '{}' });
+    expect((transport.mock.calls[1]?.[0] as Request).headers.get('X-CSRFToken')).toBe(token);
+    await request('https://cloud.example/v1/assistant/turns', { method: 'POST', headers: { 'X-CSRFToken': token } });
+    expect((transport.mock.calls[2]?.[0] as Request).headers.has('X-CSRFToken')).toBe(false);
+  });
+  it('fails closed before network activity without an application CSRF token', async () => {
+    const transport = vi.fn<typeof fetch>();
+    await expect(assistantSessionFetch('https://app.example', () => '', transport)(
+      '/api/assistant/session', { method: 'POST', body: '{}' },
+    )).rejects.toThrow('CSRF token');
+    expect(transport).not.toHaveBeenCalled();
+  });
+});
+`,
+    };
+}
+//# sourceMappingURL=assistant-embed-vue.js.map

package/dist/assistant-embed-vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistant-embed-vue.js","sourceRoot":"","sources":["../src/assistant-embed-vue.ts"],"names":[],"mappings":"AAAA,sGAAsG;AACtG,MAAM,UAAU,aAAa;IAC3B,OAAO;QACL,oCAAoC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;CAyBzC;QACG,uCAAuC,EAAE;;;;;;;;;;;;;;;;;;;CAmB5C;QACG,yCAAyC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;CAwB9C;KACE,CAAC;AACJ,CAAC"}

package/dist/commands/assistant-embed-ops.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assistant-embed-ops.d.ts","sourceRoot":"","sources":["../../src/commands/assistant-embed-ops.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAgHnD,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,KAAK,EAAE,cAAc,EACrB,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,OAAO,CAAC,MAAM,CAAC,CA6EjB"}
+{"version":3,"file":"assistant-embed-ops.d.ts","sourceRoot":"","sources":["../../src/commands/assistant-embed-ops.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAcH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAoInD,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,KAAK,EAAE,cAAc,EACrB,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,OAAO,CAAC,MAAM,CAAC,CA8HjB"}